src/syscall/zx/posix/socket/impl.go

// Copyright 2018 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
// Code generated by third_party/go/regen-fidl; DO NOT EDIT.

package socket

import (
	_zx "syscall/zx"
	_bindings "syscall/zx/fidl"
	fuchsiaio "syscall/zx/io"
	fuchsianet "syscall/zx/net"
	fuchsiaposix "syscall/zx/posix"
)

var _ _bindings.Enum = TcpCongestionControl(0)

// TCP congestion control modes.
type TcpCongestionControl uint32

const (
	TcpCongestionControlReno  TcpCongestionControl = 1
	TcpCongestionControlCubic TcpCongestionControl = 2
)

func (_ TcpCongestionControl) I_EnumValues() []TcpCongestionControl {
	return []TcpCongestionControl{
		TcpCongestionControlReno,
		TcpCongestionControlCubic,
	}
}

func (_ TcpCongestionControl) I_EnumIsStrict() bool {
	return true
}

func (x TcpCongestionControl) IsUnknown() bool {
	switch x {
	case 1:
		return false
	case 2:
		return false
	default:
		return true
	}
}

func (x TcpCongestionControl) String() string {
	switch x {
	case 1:
		return "Reno"
	case 2:
		return "Cubic"
	}
	return "Unknown"
}

var _ _bindings.Enum = TcpState(0)

// TCP state machine state.
type TcpState uint32

const (
	TcpStateEstablished TcpState = 1
	TcpStateSynSent     TcpState = 2
	TcpStateSynRecv     TcpState = 3
	TcpStateFinWait1    TcpState = 4
	TcpStateFinWait2    TcpState = 5
	TcpStateTimeWait    TcpState = 6
	TcpStateClose       TcpState = 7
	TcpStateCloseWait   TcpState = 8
	TcpStateLastAck     TcpState = 9
	TcpStateListen      TcpState = 10
	TcpStateClosing     TcpState = 11
)

func (_ TcpState) I_EnumValues() []TcpState {
	return []TcpState{
		TcpStateEstablished,
		TcpStateSynSent,
		TcpStateSynRecv,
		TcpStateFinWait1,
		TcpStateFinWait2,
		TcpStateTimeWait,
		TcpStateClose,
		TcpStateCloseWait,
		TcpStateLastAck,
		TcpStateListen,
		TcpStateClosing,
	}
}

func (_ TcpState) I_EnumIsStrict() bool {
	return true
}

func (x TcpState) IsUnknown() bool {
	switch x {
	case 1:
		return false
	case 2:
		return false
	case 3:
		return false
	case 4:
		return false
	case 5:
		return false
	case 6:
		return false
	case 7:
		return false
	case 8:
		return false
	case 9:
		return false
	case 10:
		return false
	case 11:
		return false
	default:
		return true
	}
}

func (x TcpState) String() string {
	switch x {
	case 1:
		return "Established"
	case 2:
		return "SynSent"
	case 3:
		return "SynRecv"
	case 4:
		return "FinWait1"
	case 5:
		return "FinWait2"
	case 6:
		return "TimeWait"
	case 7:
		return "Close"
	case 8:
		return "CloseWait"
	case 9:
		return "LastAck"
	case 10:
		return "Listen"
	case 11:
		return "Closing"
	}
	return "Unknown"
}

var _ _bindings.Enum = TcpCongestionControlState(0)

// TCP congestion control state machine state.
type TcpCongestionControlState uint32

const (
	TcpCongestionControlStateOpen                    TcpCongestionControlState = 0
	TcpCongestionControlStateDisorder                TcpCongestionControlState = 1
	TcpCongestionControlStateCongestionWindowReduced TcpCongestionControlState = 2
	TcpCongestionControlStateRecovery                TcpCongestionControlState = 3
	TcpCongestionControlStateLoss                    TcpCongestionControlState = 4
)

func (_ TcpCongestionControlState) I_EnumValues() []TcpCongestionControlState {
	return []TcpCongestionControlState{
		TcpCongestionControlStateOpen,
		TcpCongestionControlStateDisorder,
		TcpCongestionControlStateCongestionWindowReduced,
		TcpCongestionControlStateRecovery,
		TcpCongestionControlStateLoss,
	}
}

func (_ TcpCongestionControlState) I_EnumIsStrict() bool {
	return true
}

func (x TcpCongestionControlState) IsUnknown() bool {
	switch x {
	case 0:
		return false
	case 1:
		return false
	case 2:
		return false
	case 3:
		return false
	case 4:
		return false
	default:
		return true
	}
}

func (x TcpCongestionControlState) String() string {
	switch x {
	case 0:
		return "Open"
	case 1:
		return "Disorder"
	case 2:
		return "CongestionWindowReduced"
	case 3:
		return "Recovery"
	case 4:
		return "Loss"
	}
	return "Unknown"
}

var _ _bindings.Enum = Domain(0)

// A socket's domain.
//
// Determines the addressing domain for a socket.
type Domain int16

const (

	// An IPv4 socket. Equivalent to `AF_INET`.
	DomainIpv4 Domain = 0

	// An IPv6 socket. Equivalent to `AF_INET6`.
	DomainIpv6 Domain = 1
)

func (_ Domain) I_EnumValues() []Domain {
	return []Domain{
		DomainIpv4,
		DomainIpv6,
	}
}

func (_ Domain) I_EnumIsStrict() bool {
	return true
}

func (x Domain) IsUnknown() bool {
	switch x {
	case 0:
		return false
	case 1:
		return false
	default:
		return true
	}
}

func (x Domain) String() string {
	switch x {
	case 0:
		return "Ipv4"
	case 1:
		return "Ipv6"
	}
	return "Unknown"
}

var _ _bindings.Enum = DatagramSocketProtocol(0)

// Protocols supported by [`fuchsia.posix.socket/DatagramSocket`].
//
// `DatagramSocketProtocol` enumerates the protocols supported by the network stack over datagram
// sockets.
type DatagramSocketProtocol uint32

const (

	// UDP (User Datagram Protocol).
	//
	// A UDP socket is equivalent to the POSIX API of `SOCK_DGRAM` with a protocol of 0 or
	// `IPPROTO_UDP`.
	DatagramSocketProtocolUdp DatagramSocketProtocol = 1

	// ICMP (Internet Control Message Protocol) echo.
	//
	// An ICMP echo socket is equivalent to the POSIX API of `SOCK_DGRAM` with a protocol of
	// `IPPROTO_ICMP` `IPPROTO_ICMPV6` (depending on provided domain).
	//
	// Datagrams sent over an ICMP echo socket *must* have a valid ICMP or ICMPv6 echo header.
	DatagramSocketProtocolIcmpEcho DatagramSocketProtocol = 2
)

func (_ DatagramSocketProtocol) I_EnumValues() []DatagramSocketProtocol {
	return []DatagramSocketProtocol{
		DatagramSocketProtocolUdp,
		DatagramSocketProtocolIcmpEcho,
	}
}

func (_ DatagramSocketProtocol) I_EnumIsStrict() bool {
	return true
}

func (x DatagramSocketProtocol) IsUnknown() bool {
	switch x {
	case 1:
		return false
	case 2:
		return false
	default:
		return true
	}
}

func (x DatagramSocketProtocol) String() string {
	switch x {
	case 1:
		return "Udp"
	case 2:
		return "IcmpEcho"
	}
	return "Unknown"
}

var _ _bindings.Enum = StreamSocketProtocol(0)

// Protocols supported by [`fuchsia.posix.socket/StreamSocket`].
//
// `StreamSocketProtocol` enumerates the protocols supported by the network stack over stream
// sockets.
type StreamSocketProtocol uint32

const (

	// TCP (Transmission Control Protocol).
	//
	// A TCP socket is equivalent to the POSIX API of `SOCK_STREAM` with a protocol of 0 or
	// `IPPROTO_TCP`.
	StreamSocketProtocolTcp StreamSocketProtocol = 0
)

func (_ StreamSocketProtocol) I_EnumValues() []StreamSocketProtocol {
	return []StreamSocketProtocol{
		StreamSocketProtocolTcp,
	}
}

func (_ StreamSocketProtocol) I_EnumIsStrict() bool {
	return true
}

func (x StreamSocketProtocol) IsUnknown() bool {
	switch x {
	case 0:
		return false
	default:
		return true
	}
}

func (x StreamSocketProtocol) String() string {
	switch x {
	case 0:
		return "Tcp"
	}
	return "Unknown"
}

var _ _bindings.Bits = ShutdownMode(0)

// Socket shutdown mode.
type ShutdownMode uint16

const (
	ShutdownModeRead  ShutdownMode = 1
	ShutdownModeWrite ShutdownMode = 2
	ShutdownMode_Mask ShutdownMode = 3
)

func (_ ShutdownMode) I_BitsMask() ShutdownMode {
	return ShutdownMode_Mask
}

func (_ ShutdownMode) I_BitsIsStrict() bool {
	return true
}

func (x ShutdownMode) HasUnknownBits() bool {
	return x.GetUnknownBits() != 0
}

func (x ShutdownMode) GetUnknownBits() uint64 {
	return uint64(^ShutdownMode_Mask & x)
}

func (x ShutdownMode) InvertBits() ShutdownMode {
	return ShutdownMode_Mask & ^x
}

// HasBits validates that all flipped bits in the mask are set.
func (x ShutdownMode) HasBits(mask ShutdownMode) bool {
	return mask|x == x
}

// ClearBits ensures all flipped bits in the mask are unset.
func (x ShutdownMode) ClearBits(mask ShutdownMode) ShutdownMode {
	return ^mask & x
}

func (x ShutdownMode) String() string {
	switch x {
	case 1:
		return "Read"
	case 2:
		return "Write"
	}
	return "Unknown"
}

var _ _bindings.Bits = RecvMsgFlags(0)

// Flags controlling RecvMsg behavior.
type RecvMsgFlags uint16

const (
	RecvMsgFlagsPeek  RecvMsgFlags = 2
	RecvMsgFlags_Mask RecvMsgFlags = 2
)

func (_ RecvMsgFlags) I_BitsMask() RecvMsgFlags {
	return RecvMsgFlags_Mask
}

func (_ RecvMsgFlags) I_BitsIsStrict() bool {
	return true
}

func (x RecvMsgFlags) HasUnknownBits() bool {
	return x.GetUnknownBits() != 0
}

func (x RecvMsgFlags) GetUnknownBits() uint64 {
	return uint64(^RecvMsgFlags_Mask & x)
}

func (x RecvMsgFlags) InvertBits() RecvMsgFlags {
	return RecvMsgFlags_Mask & ^x
}

// HasBits validates that all flipped bits in the mask are set.
func (x RecvMsgFlags) HasBits(mask RecvMsgFlags) bool {
	return mask|x == x
}

// ClearBits ensures all flipped bits in the mask are unset.
func (x RecvMsgFlags) ClearBits(mask RecvMsgFlags) RecvMsgFlags {
	return ^mask & x
}

func (x RecvMsgFlags) String() string {
	switch x {
	case 2:
		return "Peek"
	}
	return "Unknown"
}

var _ _bindings.Bits = SendMsgFlags(0)

type SendMsgFlags uint16

const (
	SendMsgFlagsReserved SendMsgFlags = 32768
	SendMsgFlags_Mask    SendMsgFlags = 32768
)

func (_ SendMsgFlags) I_BitsMask() SendMsgFlags {
	return SendMsgFlags_Mask
}

func (_ SendMsgFlags) I_BitsIsStrict() bool {
	return true
}

func (x SendMsgFlags) HasUnknownBits() bool {
	return x.GetUnknownBits() != 0
}

func (x SendMsgFlags) GetUnknownBits() uint64 {
	return uint64(^SendMsgFlags_Mask & x)
}

func (x SendMsgFlags) InvertBits() SendMsgFlags {
	return SendMsgFlags_Mask & ^x
}

// HasBits validates that all flipped bits in the mask are set.
func (x SendMsgFlags) HasBits(mask SendMsgFlags) bool {
	return mask|x == x
}

// ClearBits ensures all flipped bits in the mask are unset.
func (x SendMsgFlags) ClearBits(mask SendMsgFlags) SendMsgFlags {
	return ^mask & x
}

func (x SendMsgFlags) String() string {
	switch x {
	case 32768:
		return "Reserved"
	}
	return "Unknown"
}

var _ _bindings.Bits = InterfaceFlags(0)

// Bits representing the interface flags as returned by the SIOCGIFFLAGS ioctl
// operation. These bitmasks are intended to track the C API definition. For
// example, `InterfaceFlags.UP` corresponds to `IFF_UP`, etc.
type InterfaceFlags uint16

const (
	InterfaceFlagsUp           InterfaceFlags = 1
	InterfaceFlagsBroadcast    InterfaceFlags = 2
	InterfaceFlagsDebug        InterfaceFlags = 4
	InterfaceFlagsLoopback     InterfaceFlags = 8
	InterfaceFlagsPointtopoint InterfaceFlags = 16
	InterfaceFlagsNotrailers   InterfaceFlags = 32
	InterfaceFlagsRunning      InterfaceFlags = 64
	InterfaceFlagsNoarp        InterfaceFlags = 128
	InterfaceFlagsPromisc      InterfaceFlags = 256
	InterfaceFlagsAllmulti     InterfaceFlags = 512
	InterfaceFlagsLeader       InterfaceFlags = 1024
	InterfaceFlagsFollower     InterfaceFlags = 2048
	InterfaceFlagsMulticast    InterfaceFlags = 4096
	InterfaceFlagsPortsel      InterfaceFlags = 8192
	InterfaceFlagsAutomedia    InterfaceFlags = 16384
	InterfaceFlagsDynamic      InterfaceFlags = 32768
	InterfaceFlags_Mask        InterfaceFlags = 65535
)

func (_ InterfaceFlags) I_BitsMask() InterfaceFlags {
	return InterfaceFlags_Mask
}

func (_ InterfaceFlags) I_BitsIsStrict() bool {
	return true
}

func (x InterfaceFlags) HasUnknownBits() bool {
	return x.GetUnknownBits() != 0
}

func (x InterfaceFlags) GetUnknownBits() uint64 {
	return uint64(^InterfaceFlags_Mask & x)
}

func (x InterfaceFlags) InvertBits() InterfaceFlags {
	return InterfaceFlags_Mask & ^x
}

// HasBits validates that all flipped bits in the mask are set.
func (x InterfaceFlags) HasBits(mask InterfaceFlags) bool {
	return mask|x == x
}

// ClearBits ensures all flipped bits in the mask are unset.
func (x InterfaceFlags) ClearBits(mask InterfaceFlags) InterfaceFlags {
	return ^mask & x
}

func (x InterfaceFlags) String() string {
	switch x {
	case 1:
		return "Up"
	case 2:
		return "Broadcast"
	case 4:
		return "Debug"
	case 8:
		return "Loopback"
	case 16:
		return "Pointtopoint"
	case 32:
		return "Notrailers"
	case 64:
		return "Running"
	case 128:
		return "Noarp"
	case 256:
		return "Promisc"
	case 512:
		return "Allmulti"
	case 1024:
		return "Leader"
	case 2048:
		return "Follower"
	case 4096:
		return "Multicast"
	case 8192:
		return "Portsel"
	case 16384:
		return "Automedia"
	case 32768:
		return "Dynamic"
	}
	return "Unknown"
}

type BaseSocketBindResponse struct {
	_ struct{} `fidl:"s" fidl_size_v1:"1" fidl_alignment_v1:"1" fidl_size_v2:"1" fidl_alignment_v2:"1"`
}

var _mBaseSocketBindResponse = _bindings.CreateLazyMarshaler(BaseSocketBindResponse{})

func (msg *BaseSocketBindResponse) Marshaler() _bindings.Marshaler {
	return _mBaseSocketBindResponse
}

type BaseSocketConnectResponse struct {
	_ struct{} `fidl:"s" fidl_size_v1:"1" fidl_alignment_v1:"1" fidl_size_v2:"1" fidl_alignment_v2:"1"`
}

var _mBaseSocketConnectResponse = _bindings.CreateLazyMarshaler(BaseSocketConnectResponse{})

func (msg *BaseSocketConnectResponse) Marshaler() _bindings.Marshaler {
	return _mBaseSocketConnectResponse
}

type BaseSocketDisconnectResponse struct {
	_ struct{} `fidl:"s" fidl_size_v1:"1" fidl_alignment_v1:"1" fidl_size_v2:"1" fidl_alignment_v2:"1"`
}

var _mBaseSocketDisconnectResponse = _bindings.CreateLazyMarshaler(BaseSocketDisconnectResponse{})

func (msg *BaseSocketDisconnectResponse) Marshaler() _bindings.Marshaler {
	return _mBaseSocketDisconnectResponse
}

type BaseSocketGetSockNameResponse struct {
	_    struct{}                 `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Addr fuchsianet.SocketAddress `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mBaseSocketGetSockNameResponse = _bindings.CreateLazyMarshaler(BaseSocketGetSockNameResponse{})

func (msg *BaseSocketGetSockNameResponse) Marshaler() _bindings.Marshaler {
	return _mBaseSocketGetSockNameResponse
}

type BaseSocketGetPeerNameResponse struct {
	_    struct{}                 `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Addr fuchsianet.SocketAddress `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mBaseSocketGetPeerNameResponse = _bindings.CreateLazyMarshaler(BaseSocketGetPeerNameResponse{})

func (msg *BaseSocketGetPeerNameResponse) Marshaler() _bindings.Marshaler {
	return _mBaseSocketGetPeerNameResponse
}

type BaseSocketShutdownResponse struct {
	_ struct{} `fidl:"s" fidl_size_v1:"1" fidl_alignment_v1:"1" fidl_size_v2:"1" fidl_alignment_v2:"1"`
}

var _mBaseSocketShutdownResponse = _bindings.CreateLazyMarshaler(BaseSocketShutdownResponse{})

func (msg *BaseSocketShutdownResponse) Marshaler() _bindings.Marshaler {
	return _mBaseSocketShutdownResponse
}

type BaseSocketShutdown2Response struct {
	_ struct{} `fidl:"s" fidl_size_v1:"1" fidl_alignment_v1:"1" fidl_size_v2:"1" fidl_alignment_v2:"1"`
}

var _mBaseSocketShutdown2Response = _bindings.CreateLazyMarshaler(BaseSocketShutdown2Response{})

func (msg *BaseSocketShutdown2Response) Marshaler() _bindings.Marshaler {
	return _mBaseSocketShutdown2Response
}

type BaseSocketSetReuseAddressResponse struct {
	_ struct{} `fidl:"s" fidl_size_v1:"1" fidl_alignment_v1:"1" fidl_size_v2:"1" fidl_alignment_v2:"1"`
}

var _mBaseSocketSetReuseAddressResponse = _bindings.CreateLazyMarshaler(BaseSocketSetReuseAddressResponse{})

func (msg *BaseSocketSetReuseAddressResponse) Marshaler() _bindings.Marshaler {
	return _mBaseSocketSetReuseAddressResponse
}

type BaseSocketGetReuseAddressResponse struct {
	_     struct{} `fidl:"s" fidl_size_v1:"1" fidl_alignment_v1:"1" fidl_size_v2:"1" fidl_alignment_v2:"1"`
	Value bool     `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mBaseSocketGetReuseAddressResponse = _bindings.CreateLazyMarshaler(BaseSocketGetReuseAddressResponse{})

func (msg *BaseSocketGetReuseAddressResponse) Marshaler() _bindings.Marshaler {
	return _mBaseSocketGetReuseAddressResponse
}

type BaseSocketGetErrorResponse struct {
	_ struct{} `fidl:"s" fidl_size_v1:"1" fidl_alignment_v1:"1" fidl_size_v2:"1" fidl_alignment_v2:"1"`
}

var _mBaseSocketGetErrorResponse = _bindings.CreateLazyMarshaler(BaseSocketGetErrorResponse{})

func (msg *BaseSocketGetErrorResponse) Marshaler() _bindings.Marshaler {
	return _mBaseSocketGetErrorResponse
}

type BaseSocketSetBroadcastResponse struct {
	_ struct{} `fidl:"s" fidl_size_v1:"1" fidl_alignment_v1:"1" fidl_size_v2:"1" fidl_alignment_v2:"1"`
}

var _mBaseSocketSetBroadcastResponse = _bindings.CreateLazyMarshaler(BaseSocketSetBroadcastResponse{})

func (msg *BaseSocketSetBroadcastResponse) Marshaler() _bindings.Marshaler {
	return _mBaseSocketSetBroadcastResponse
}

type BaseSocketGetBroadcastResponse struct {
	_     struct{} `fidl:"s" fidl_size_v1:"1" fidl_alignment_v1:"1" fidl_size_v2:"1" fidl_alignment_v2:"1"`
	Value bool     `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mBaseSocketGetBroadcastResponse = _bindings.CreateLazyMarshaler(BaseSocketGetBroadcastResponse{})

func (msg *BaseSocketGetBroadcastResponse) Marshaler() _bindings.Marshaler {
	return _mBaseSocketGetBroadcastResponse
}

type BaseSocketSetSendBufferResponse struct {
	_ struct{} `fidl:"s" fidl_size_v1:"1" fidl_alignment_v1:"1" fidl_size_v2:"1" fidl_alignment_v2:"1"`
}

var _mBaseSocketSetSendBufferResponse = _bindings.CreateLazyMarshaler(BaseSocketSetSendBufferResponse{})

func (msg *BaseSocketSetSendBufferResponse) Marshaler() _bindings.Marshaler {
	return _mBaseSocketSetSendBufferResponse
}

type BaseSocketGetSendBufferResponse struct {
	_          struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	ValueBytes uint64   `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mBaseSocketGetSendBufferResponse = _bindings.CreateLazyMarshaler(BaseSocketGetSendBufferResponse{})

func (msg *BaseSocketGetSendBufferResponse) Marshaler() _bindings.Marshaler {
	return _mBaseSocketGetSendBufferResponse
}

type BaseSocketSetReceiveBufferResponse struct {
	_ struct{} `fidl:"s" fidl_size_v1:"1" fidl_alignment_v1:"1" fidl_size_v2:"1" fidl_alignment_v2:"1"`
}

var _mBaseSocketSetReceiveBufferResponse = _bindings.CreateLazyMarshaler(BaseSocketSetReceiveBufferResponse{})

func (msg *BaseSocketSetReceiveBufferResponse) Marshaler() _bindings.Marshaler {
	return _mBaseSocketSetReceiveBufferResponse
}

type BaseSocketGetReceiveBufferResponse struct {
	_          struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	ValueBytes uint64   `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mBaseSocketGetReceiveBufferResponse = _bindings.CreateLazyMarshaler(BaseSocketGetReceiveBufferResponse{})

func (msg *BaseSocketGetReceiveBufferResponse) Marshaler() _bindings.Marshaler {
	return _mBaseSocketGetReceiveBufferResponse
}

type BaseSocketSetKeepAliveResponse struct {
	_ struct{} `fidl:"s" fidl_size_v1:"1" fidl_alignment_v1:"1" fidl_size_v2:"1" fidl_alignment_v2:"1"`
}

var _mBaseSocketSetKeepAliveResponse = _bindings.CreateLazyMarshaler(BaseSocketSetKeepAliveResponse{})

func (msg *BaseSocketSetKeepAliveResponse) Marshaler() _bindings.Marshaler {
	return _mBaseSocketSetKeepAliveResponse
}

type BaseSocketGetKeepAliveResponse struct {
	_     struct{} `fidl:"s" fidl_size_v1:"1" fidl_alignment_v1:"1" fidl_size_v2:"1" fidl_alignment_v2:"1"`
	Value bool     `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mBaseSocketGetKeepAliveResponse = _bindings.CreateLazyMarshaler(BaseSocketGetKeepAliveResponse{})

func (msg *BaseSocketGetKeepAliveResponse) Marshaler() _bindings.Marshaler {
	return _mBaseSocketGetKeepAliveResponse
}

type BaseSocketSetOutOfBandInlineResponse struct {
	_ struct{} `fidl:"s" fidl_size_v1:"1" fidl_alignment_v1:"1" fidl_size_v2:"1" fidl_alignment_v2:"1"`
}

var _mBaseSocketSetOutOfBandInlineResponse = _bindings.CreateLazyMarshaler(BaseSocketSetOutOfBandInlineResponse{})

func (msg *BaseSocketSetOutOfBandInlineResponse) Marshaler() _bindings.Marshaler {
	return _mBaseSocketSetOutOfBandInlineResponse
}

type BaseSocketGetOutOfBandInlineResponse struct {
	_     struct{} `fidl:"s" fidl_size_v1:"1" fidl_alignment_v1:"1" fidl_size_v2:"1" fidl_alignment_v2:"1"`
	Value bool     `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mBaseSocketGetOutOfBandInlineResponse = _bindings.CreateLazyMarshaler(BaseSocketGetOutOfBandInlineResponse{})

func (msg *BaseSocketGetOutOfBandInlineResponse) Marshaler() _bindings.Marshaler {
	return _mBaseSocketGetOutOfBandInlineResponse
}

type BaseSocketSetNoCheckResponse struct {
	_ struct{} `fidl:"s" fidl_size_v1:"1" fidl_alignment_v1:"1" fidl_size_v2:"1" fidl_alignment_v2:"1"`
}

var _mBaseSocketSetNoCheckResponse = _bindings.CreateLazyMarshaler(BaseSocketSetNoCheckResponse{})

func (msg *BaseSocketSetNoCheckResponse) Marshaler() _bindings.Marshaler {
	return _mBaseSocketSetNoCheckResponse
}

type BaseSocketGetNoCheckResponse struct {
	_     struct{} `fidl:"s" fidl_size_v1:"1" fidl_alignment_v1:"1" fidl_size_v2:"1" fidl_alignment_v2:"1"`
	Value bool     `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mBaseSocketGetNoCheckResponse = _bindings.CreateLazyMarshaler(BaseSocketGetNoCheckResponse{})

func (msg *BaseSocketGetNoCheckResponse) Marshaler() _bindings.Marshaler {
	return _mBaseSocketGetNoCheckResponse
}

type BaseSocketSetLingerResponse struct {
	_ struct{} `fidl:"s" fidl_size_v1:"1" fidl_alignment_v1:"1" fidl_size_v2:"1" fidl_alignment_v2:"1"`
}

var _mBaseSocketSetLingerResponse = _bindings.CreateLazyMarshaler(BaseSocketSetLingerResponse{})

func (msg *BaseSocketSetLingerResponse) Marshaler() _bindings.Marshaler {
	return _mBaseSocketSetLingerResponse
}

type BaseSocketGetLingerResponse struct {
	_          struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"4" fidl_size_v2:"8" fidl_alignment_v2:"4"`
	Linger     bool     `fidl_offset_v1:"0" fidl_offset_v2:"0"`
	LengthSecs uint32   `fidl_offset_v1:"4" fidl_offset_v2:"4"`
}

var _mBaseSocketGetLingerResponse = _bindings.CreateLazyMarshaler(BaseSocketGetLingerResponse{})

func (msg *BaseSocketGetLingerResponse) Marshaler() _bindings.Marshaler {
	return _mBaseSocketGetLingerResponse
}

type BaseSocketSetReusePortResponse struct {
	_ struct{} `fidl:"s" fidl_size_v1:"1" fidl_alignment_v1:"1" fidl_size_v2:"1" fidl_alignment_v2:"1"`
}

var _mBaseSocketSetReusePortResponse = _bindings.CreateLazyMarshaler(BaseSocketSetReusePortResponse{})

func (msg *BaseSocketSetReusePortResponse) Marshaler() _bindings.Marshaler {
	return _mBaseSocketSetReusePortResponse
}

type BaseSocketGetReusePortResponse struct {
	_     struct{} `fidl:"s" fidl_size_v1:"1" fidl_alignment_v1:"1" fidl_size_v2:"1" fidl_alignment_v2:"1"`
	Value bool     `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mBaseSocketGetReusePortResponse = _bindings.CreateLazyMarshaler(BaseSocketGetReusePortResponse{})

func (msg *BaseSocketGetReusePortResponse) Marshaler() _bindings.Marshaler {
	return _mBaseSocketGetReusePortResponse
}

type BaseSocketGetAcceptConnResponse struct {
	_     struct{} `fidl:"s" fidl_size_v1:"1" fidl_alignment_v1:"1" fidl_size_v2:"1" fidl_alignment_v2:"1"`
	Value bool     `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mBaseSocketGetAcceptConnResponse = _bindings.CreateLazyMarshaler(BaseSocketGetAcceptConnResponse{})

func (msg *BaseSocketGetAcceptConnResponse) Marshaler() _bindings.Marshaler {
	return _mBaseSocketGetAcceptConnResponse
}

type BaseSocketSetBindToDeviceResponse struct {
	_ struct{} `fidl:"s" fidl_size_v1:"1" fidl_alignment_v1:"1" fidl_size_v2:"1" fidl_alignment_v2:"1"`
}

var _mBaseSocketSetBindToDeviceResponse = _bindings.CreateLazyMarshaler(BaseSocketSetBindToDeviceResponse{})

func (msg *BaseSocketSetBindToDeviceResponse) Marshaler() _bindings.Marshaler {
	return _mBaseSocketSetBindToDeviceResponse
}

type BaseSocketGetBindToDeviceResponse struct {
	_     struct{} `fidl:"s" fidl_size_v1:"16" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Value string   `fidl_offset_v1:"0" fidl_offset_v2:"0" fidl_bounds:"15"`
}

var _mBaseSocketGetBindToDeviceResponse = _bindings.CreateLazyMarshaler(BaseSocketGetBindToDeviceResponse{})

func (msg *BaseSocketGetBindToDeviceResponse) Marshaler() _bindings.Marshaler {
	return _mBaseSocketGetBindToDeviceResponse
}

type BaseSocketSetTimestampResponse struct {
	_ struct{} `fidl:"s" fidl_size_v1:"1" fidl_alignment_v1:"1" fidl_size_v2:"1" fidl_alignment_v2:"1"`
}

var _mBaseSocketSetTimestampResponse = _bindings.CreateLazyMarshaler(BaseSocketSetTimestampResponse{})

func (msg *BaseSocketSetTimestampResponse) Marshaler() _bindings.Marshaler {
	return _mBaseSocketSetTimestampResponse
}

type BaseSocketGetTimestampResponse struct {
	_     struct{} `fidl:"s" fidl_size_v1:"1" fidl_alignment_v1:"1" fidl_size_v2:"1" fidl_alignment_v2:"1"`
	Value bool     `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mBaseSocketGetTimestampResponse = _bindings.CreateLazyMarshaler(BaseSocketGetTimestampResponse{})

func (msg *BaseSocketGetTimestampResponse) Marshaler() _bindings.Marshaler {
	return _mBaseSocketGetTimestampResponse
}

type BaseSocketSetIpTypeOfServiceResponse struct {
	_ struct{} `fidl:"s" fidl_size_v1:"1" fidl_alignment_v1:"1" fidl_size_v2:"1" fidl_alignment_v2:"1"`
}

var _mBaseSocketSetIpTypeOfServiceResponse = _bindings.CreateLazyMarshaler(BaseSocketSetIpTypeOfServiceResponse{})

func (msg *BaseSocketSetIpTypeOfServiceResponse) Marshaler() _bindings.Marshaler {
	return _mBaseSocketSetIpTypeOfServiceResponse
}

type BaseSocketGetIpTypeOfServiceResponse struct {
	_     struct{} `fidl:"s" fidl_size_v1:"1" fidl_alignment_v1:"1" fidl_size_v2:"1" fidl_alignment_v2:"1"`
	Value uint8    `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mBaseSocketGetIpTypeOfServiceResponse = _bindings.CreateLazyMarshaler(BaseSocketGetIpTypeOfServiceResponse{})

func (msg *BaseSocketGetIpTypeOfServiceResponse) Marshaler() _bindings.Marshaler {
	return _mBaseSocketGetIpTypeOfServiceResponse
}

type BaseSocketSetIpTtlResponse struct {
	_ struct{} `fidl:"s" fidl_size_v1:"1" fidl_alignment_v1:"1" fidl_size_v2:"1" fidl_alignment_v2:"1"`
}

var _mBaseSocketSetIpTtlResponse = _bindings.CreateLazyMarshaler(BaseSocketSetIpTtlResponse{})

func (msg *BaseSocketSetIpTtlResponse) Marshaler() _bindings.Marshaler {
	return _mBaseSocketSetIpTtlResponse
}

type BaseSocketGetIpTtlResponse struct {
	_     struct{} `fidl:"s" fidl_size_v1:"1" fidl_alignment_v1:"1" fidl_size_v2:"1" fidl_alignment_v2:"1"`
	Value uint8    `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mBaseSocketGetIpTtlResponse = _bindings.CreateLazyMarshaler(BaseSocketGetIpTtlResponse{})

func (msg *BaseSocketGetIpTtlResponse) Marshaler() _bindings.Marshaler {
	return _mBaseSocketGetIpTtlResponse
}

type BaseSocketSetIpPacketInfoResponse struct {
	_ struct{} `fidl:"s" fidl_size_v1:"1" fidl_alignment_v1:"1" fidl_size_v2:"1" fidl_alignment_v2:"1"`
}

var _mBaseSocketSetIpPacketInfoResponse = _bindings.CreateLazyMarshaler(BaseSocketSetIpPacketInfoResponse{})

func (msg *BaseSocketSetIpPacketInfoResponse) Marshaler() _bindings.Marshaler {
	return _mBaseSocketSetIpPacketInfoResponse
}

type BaseSocketGetIpPacketInfoResponse struct {
	_     struct{} `fidl:"s" fidl_size_v1:"1" fidl_alignment_v1:"1" fidl_size_v2:"1" fidl_alignment_v2:"1"`
	Value bool     `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mBaseSocketGetIpPacketInfoResponse = _bindings.CreateLazyMarshaler(BaseSocketGetIpPacketInfoResponse{})

func (msg *BaseSocketGetIpPacketInfoResponse) Marshaler() _bindings.Marshaler {
	return _mBaseSocketGetIpPacketInfoResponse
}

type BaseSocketSetIpReceiveTypeOfServiceResponse struct {
	_ struct{} `fidl:"s" fidl_size_v1:"1" fidl_alignment_v1:"1" fidl_size_v2:"1" fidl_alignment_v2:"1"`
}

var _mBaseSocketSetIpReceiveTypeOfServiceResponse = _bindings.CreateLazyMarshaler(BaseSocketSetIpReceiveTypeOfServiceResponse{})

func (msg *BaseSocketSetIpReceiveTypeOfServiceResponse) Marshaler() _bindings.Marshaler {
	return _mBaseSocketSetIpReceiveTypeOfServiceResponse
}

type BaseSocketGetIpReceiveTypeOfServiceResponse struct {
	_     struct{} `fidl:"s" fidl_size_v1:"1" fidl_alignment_v1:"1" fidl_size_v2:"1" fidl_alignment_v2:"1"`
	Value bool     `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mBaseSocketGetIpReceiveTypeOfServiceResponse = _bindings.CreateLazyMarshaler(BaseSocketGetIpReceiveTypeOfServiceResponse{})

func (msg *BaseSocketGetIpReceiveTypeOfServiceResponse) Marshaler() _bindings.Marshaler {
	return _mBaseSocketGetIpReceiveTypeOfServiceResponse
}

type BaseSocketSetIpMulticastInterfaceResponse struct {
	_ struct{} `fidl:"s" fidl_size_v1:"1" fidl_alignment_v1:"1" fidl_size_v2:"1" fidl_alignment_v2:"1"`
}

var _mBaseSocketSetIpMulticastInterfaceResponse = _bindings.CreateLazyMarshaler(BaseSocketSetIpMulticastInterfaceResponse{})

func (msg *BaseSocketSetIpMulticastInterfaceResponse) Marshaler() _bindings.Marshaler {
	return _mBaseSocketSetIpMulticastInterfaceResponse
}

type BaseSocketGetIpMulticastInterfaceResponse struct {
	_     struct{}               `fidl:"s" fidl_size_v1:"4" fidl_alignment_v1:"1" fidl_size_v2:"4" fidl_alignment_v2:"1"`
	Value fuchsianet.Ipv4Address `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mBaseSocketGetIpMulticastInterfaceResponse = _bindings.CreateLazyMarshaler(BaseSocketGetIpMulticastInterfaceResponse{})

func (msg *BaseSocketGetIpMulticastInterfaceResponse) Marshaler() _bindings.Marshaler {
	return _mBaseSocketGetIpMulticastInterfaceResponse
}

type BaseSocketSetIpMulticastTtlResponse struct {
	_ struct{} `fidl:"s" fidl_size_v1:"1" fidl_alignment_v1:"1" fidl_size_v2:"1" fidl_alignment_v2:"1"`
}

var _mBaseSocketSetIpMulticastTtlResponse = _bindings.CreateLazyMarshaler(BaseSocketSetIpMulticastTtlResponse{})

func (msg *BaseSocketSetIpMulticastTtlResponse) Marshaler() _bindings.Marshaler {
	return _mBaseSocketSetIpMulticastTtlResponse
}

type BaseSocketGetIpMulticastTtlResponse struct {
	_     struct{} `fidl:"s" fidl_size_v1:"1" fidl_alignment_v1:"1" fidl_size_v2:"1" fidl_alignment_v2:"1"`
	Value uint8    `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mBaseSocketGetIpMulticastTtlResponse = _bindings.CreateLazyMarshaler(BaseSocketGetIpMulticastTtlResponse{})

func (msg *BaseSocketGetIpMulticastTtlResponse) Marshaler() _bindings.Marshaler {
	return _mBaseSocketGetIpMulticastTtlResponse
}

type BaseSocketSetIpMulticastLoopbackResponse struct {
	_ struct{} `fidl:"s" fidl_size_v1:"1" fidl_alignment_v1:"1" fidl_size_v2:"1" fidl_alignment_v2:"1"`
}

var _mBaseSocketSetIpMulticastLoopbackResponse = _bindings.CreateLazyMarshaler(BaseSocketSetIpMulticastLoopbackResponse{})

func (msg *BaseSocketSetIpMulticastLoopbackResponse) Marshaler() _bindings.Marshaler {
	return _mBaseSocketSetIpMulticastLoopbackResponse
}

type BaseSocketGetIpMulticastLoopbackResponse struct {
	_     struct{} `fidl:"s" fidl_size_v1:"1" fidl_alignment_v1:"1" fidl_size_v2:"1" fidl_alignment_v2:"1"`
	Value bool     `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mBaseSocketGetIpMulticastLoopbackResponse = _bindings.CreateLazyMarshaler(BaseSocketGetIpMulticastLoopbackResponse{})

func (msg *BaseSocketGetIpMulticastLoopbackResponse) Marshaler() _bindings.Marshaler {
	return _mBaseSocketGetIpMulticastLoopbackResponse
}

type BaseSocketAddIpMembershipResponse struct {
	_ struct{} `fidl:"s" fidl_size_v1:"1" fidl_alignment_v1:"1" fidl_size_v2:"1" fidl_alignment_v2:"1"`
}

var _mBaseSocketAddIpMembershipResponse = _bindings.CreateLazyMarshaler(BaseSocketAddIpMembershipResponse{})

func (msg *BaseSocketAddIpMembershipResponse) Marshaler() _bindings.Marshaler {
	return _mBaseSocketAddIpMembershipResponse
}

type BaseSocketDropIpMembershipResponse struct {
	_ struct{} `fidl:"s" fidl_size_v1:"1" fidl_alignment_v1:"1" fidl_size_v2:"1" fidl_alignment_v2:"1"`
}

var _mBaseSocketDropIpMembershipResponse = _bindings.CreateLazyMarshaler(BaseSocketDropIpMembershipResponse{})

func (msg *BaseSocketDropIpMembershipResponse) Marshaler() _bindings.Marshaler {
	return _mBaseSocketDropIpMembershipResponse
}

type BaseSocketAddIpv6MembershipResponse struct {
	_ struct{} `fidl:"s" fidl_size_v1:"1" fidl_alignment_v1:"1" fidl_size_v2:"1" fidl_alignment_v2:"1"`
}

var _mBaseSocketAddIpv6MembershipResponse = _bindings.CreateLazyMarshaler(BaseSocketAddIpv6MembershipResponse{})

func (msg *BaseSocketAddIpv6MembershipResponse) Marshaler() _bindings.Marshaler {
	return _mBaseSocketAddIpv6MembershipResponse
}

type BaseSocketDropIpv6MembershipResponse struct {
	_ struct{} `fidl:"s" fidl_size_v1:"1" fidl_alignment_v1:"1" fidl_size_v2:"1" fidl_alignment_v2:"1"`
}

var _mBaseSocketDropIpv6MembershipResponse = _bindings.CreateLazyMarshaler(BaseSocketDropIpv6MembershipResponse{})

func (msg *BaseSocketDropIpv6MembershipResponse) Marshaler() _bindings.Marshaler {
	return _mBaseSocketDropIpv6MembershipResponse
}

type BaseSocketSetIpv6MulticastInterfaceResponse struct {
	_ struct{} `fidl:"s" fidl_size_v1:"1" fidl_alignment_v1:"1" fidl_size_v2:"1" fidl_alignment_v2:"1"`
}

var _mBaseSocketSetIpv6MulticastInterfaceResponse = _bindings.CreateLazyMarshaler(BaseSocketSetIpv6MulticastInterfaceResponse{})

func (msg *BaseSocketSetIpv6MulticastInterfaceResponse) Marshaler() _bindings.Marshaler {
	return _mBaseSocketSetIpv6MulticastInterfaceResponse
}

type BaseSocketGetIpv6MulticastInterfaceResponse struct {
	_     struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	Value uint64   `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mBaseSocketGetIpv6MulticastInterfaceResponse = _bindings.CreateLazyMarshaler(BaseSocketGetIpv6MulticastInterfaceResponse{})

func (msg *BaseSocketGetIpv6MulticastInterfaceResponse) Marshaler() _bindings.Marshaler {
	return _mBaseSocketGetIpv6MulticastInterfaceResponse
}

type BaseSocketSetIpv6MulticastHopsResponse struct {
	_ struct{} `fidl:"s" fidl_size_v1:"1" fidl_alignment_v1:"1" fidl_size_v2:"1" fidl_alignment_v2:"1"`
}

var _mBaseSocketSetIpv6MulticastHopsResponse = _bindings.CreateLazyMarshaler(BaseSocketSetIpv6MulticastHopsResponse{})

func (msg *BaseSocketSetIpv6MulticastHopsResponse) Marshaler() _bindings.Marshaler {
	return _mBaseSocketSetIpv6MulticastHopsResponse
}

type BaseSocketGetIpv6MulticastHopsResponse struct {
	_     struct{} `fidl:"s" fidl_size_v1:"1" fidl_alignment_v1:"1" fidl_size_v2:"1" fidl_alignment_v2:"1"`
	Value uint8    `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mBaseSocketGetIpv6MulticastHopsResponse = _bindings.CreateLazyMarshaler(BaseSocketGetIpv6MulticastHopsResponse{})

func (msg *BaseSocketGetIpv6MulticastHopsResponse) Marshaler() _bindings.Marshaler {
	return _mBaseSocketGetIpv6MulticastHopsResponse
}

type BaseSocketSetIpv6MulticastLoopbackResponse struct {
	_ struct{} `fidl:"s" fidl_size_v1:"1" fidl_alignment_v1:"1" fidl_size_v2:"1" fidl_alignment_v2:"1"`
}

var _mBaseSocketSetIpv6MulticastLoopbackResponse = _bindings.CreateLazyMarshaler(BaseSocketSetIpv6MulticastLoopbackResponse{})

func (msg *BaseSocketSetIpv6MulticastLoopbackResponse) Marshaler() _bindings.Marshaler {
	return _mBaseSocketSetIpv6MulticastLoopbackResponse
}

type BaseSocketGetIpv6MulticastLoopbackResponse struct {
	_     struct{} `fidl:"s" fidl_size_v1:"1" fidl_alignment_v1:"1" fidl_size_v2:"1" fidl_alignment_v2:"1"`
	Value bool     `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mBaseSocketGetIpv6MulticastLoopbackResponse = _bindings.CreateLazyMarshaler(BaseSocketGetIpv6MulticastLoopbackResponse{})

func (msg *BaseSocketGetIpv6MulticastLoopbackResponse) Marshaler() _bindings.Marshaler {
	return _mBaseSocketGetIpv6MulticastLoopbackResponse
}

type BaseSocketSetIpv6OnlyResponse struct {
	_ struct{} `fidl:"s" fidl_size_v1:"1" fidl_alignment_v1:"1" fidl_size_v2:"1" fidl_alignment_v2:"1"`
}

var _mBaseSocketSetIpv6OnlyResponse = _bindings.CreateLazyMarshaler(BaseSocketSetIpv6OnlyResponse{})

func (msg *BaseSocketSetIpv6OnlyResponse) Marshaler() _bindings.Marshaler {
	return _mBaseSocketSetIpv6OnlyResponse
}

type BaseSocketGetIpv6OnlyResponse struct {
	_     struct{} `fidl:"s" fidl_size_v1:"1" fidl_alignment_v1:"1" fidl_size_v2:"1" fidl_alignment_v2:"1"`
	Value bool     `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mBaseSocketGetIpv6OnlyResponse = _bindings.CreateLazyMarshaler(BaseSocketGetIpv6OnlyResponse{})

func (msg *BaseSocketGetIpv6OnlyResponse) Marshaler() _bindings.Marshaler {
	return _mBaseSocketGetIpv6OnlyResponse
}

type BaseSocketSetIpv6ReceiveTrafficClassResponse struct {
	_ struct{} `fidl:"s" fidl_size_v1:"1" fidl_alignment_v1:"1" fidl_size_v2:"1" fidl_alignment_v2:"1"`
}

var _mBaseSocketSetIpv6ReceiveTrafficClassResponse = _bindings.CreateLazyMarshaler(BaseSocketSetIpv6ReceiveTrafficClassResponse{})

func (msg *BaseSocketSetIpv6ReceiveTrafficClassResponse) Marshaler() _bindings.Marshaler {
	return _mBaseSocketSetIpv6ReceiveTrafficClassResponse
}

type BaseSocketGetIpv6ReceiveTrafficClassResponse struct {
	_     struct{} `fidl:"s" fidl_size_v1:"1" fidl_alignment_v1:"1" fidl_size_v2:"1" fidl_alignment_v2:"1"`
	Value bool     `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mBaseSocketGetIpv6ReceiveTrafficClassResponse = _bindings.CreateLazyMarshaler(BaseSocketGetIpv6ReceiveTrafficClassResponse{})

func (msg *BaseSocketGetIpv6ReceiveTrafficClassResponse) Marshaler() _bindings.Marshaler {
	return _mBaseSocketGetIpv6ReceiveTrafficClassResponse
}

type BaseSocketSetIpv6TrafficClassResponse struct {
	_ struct{} `fidl:"s" fidl_size_v1:"1" fidl_alignment_v1:"1" fidl_size_v2:"1" fidl_alignment_v2:"1"`
}

var _mBaseSocketSetIpv6TrafficClassResponse = _bindings.CreateLazyMarshaler(BaseSocketSetIpv6TrafficClassResponse{})

func (msg *BaseSocketSetIpv6TrafficClassResponse) Marshaler() _bindings.Marshaler {
	return _mBaseSocketSetIpv6TrafficClassResponse
}

type BaseSocketGetIpv6TrafficClassResponse struct {
	_     struct{} `fidl:"s" fidl_size_v1:"1" fidl_alignment_v1:"1" fidl_size_v2:"1" fidl_alignment_v2:"1"`
	Value uint8    `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mBaseSocketGetIpv6TrafficClassResponse = _bindings.CreateLazyMarshaler(BaseSocketGetIpv6TrafficClassResponse{})

func (msg *BaseSocketGetIpv6TrafficClassResponse) Marshaler() _bindings.Marshaler {
	return _mBaseSocketGetIpv6TrafficClassResponse
}

type DatagramSocketRecvMsgResponse struct {
	_         struct{}                  `fidl:"s" fidl_size_v1:"64" fidl_alignment_v1:"8" fidl_size_v2:"56" fidl_alignment_v2:"8"`
	Addr      *fuchsianet.SocketAddress `fidl_offset_v1:"0" fidl_offset_v2:"0"`
	Data      []uint8                   `fidl_offset_v1:"24" fidl_offset_v2:"16" fidl_bounds:""`
	Control   RecvControlData           `fidl_offset_v1:"40" fidl_offset_v2:"32"`
	Truncated uint32                    `fidl_offset_v1:"56" fidl_offset_v2:"48"`
}

var _mDatagramSocketRecvMsgResponse = _bindings.CreateLazyMarshaler(DatagramSocketRecvMsgResponse{})

func (msg *DatagramSocketRecvMsgResponse) Marshaler() _bindings.Marshaler {
	return _mDatagramSocketRecvMsgResponse
}

type DatagramSocketSendMsgResponse struct {
	_   struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	Len int64    `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mDatagramSocketSendMsgResponse = _bindings.CreateLazyMarshaler(DatagramSocketSendMsgResponse{})

func (msg *DatagramSocketSendMsgResponse) Marshaler() _bindings.Marshaler {
	return _mDatagramSocketSendMsgResponse
}

type DatagramSocketGetInfoResponse struct {
	_      struct{}               `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"4" fidl_size_v2:"8" fidl_alignment_v2:"4"`
	Domain Domain                 `fidl_offset_v1:"0" fidl_offset_v2:"0"`
	Proto  DatagramSocketProtocol `fidl_offset_v1:"4" fidl_offset_v2:"4"`
}

var _mDatagramSocketGetInfoResponse = _bindings.CreateLazyMarshaler(DatagramSocketGetInfoResponse{})

func (msg *DatagramSocketGetInfoResponse) Marshaler() _bindings.Marshaler {
	return _mDatagramSocketGetInfoResponse
}

type StreamSocketListenResponse struct {
	_ struct{} `fidl:"s" fidl_size_v1:"1" fidl_alignment_v1:"1" fidl_size_v2:"1" fidl_alignment_v2:"1"`
}

var _mStreamSocketListenResponse = _bindings.CreateLazyMarshaler(StreamSocketListenResponse{})

func (msg *StreamSocketListenResponse) Marshaler() _bindings.Marshaler {
	return _mStreamSocketListenResponse
}

type StreamSocketAcceptResponse struct {
	_    struct{}                     `fidl:"s" fidl_size_v1:"32" fidl_alignment_v1:"8" fidl_size_v2:"24" fidl_alignment_v2:"8"`
	Addr *fuchsianet.SocketAddress    `fidl_offset_v1:"0" fidl_offset_v2:"0"`
	S    StreamSocketWithCtxInterface `fidl_offset_v1:"24" fidl_offset_v2:"16" fidl_handle_subtype:"4"`
}

var _mStreamSocketAcceptResponse = _bindings.CreateLazyMarshaler(StreamSocketAcceptResponse{})

func (msg *StreamSocketAcceptResponse) Marshaler() _bindings.Marshaler {
	return _mStreamSocketAcceptResponse
}

type StreamSocketGetInfoResponse struct {
	_      struct{}             `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"4" fidl_size_v2:"8" fidl_alignment_v2:"4"`
	Domain Domain               `fidl_offset_v1:"0" fidl_offset_v2:"0"`
	Proto  StreamSocketProtocol `fidl_offset_v1:"4" fidl_offset_v2:"4"`
}

var _mStreamSocketGetInfoResponse = _bindings.CreateLazyMarshaler(StreamSocketGetInfoResponse{})

func (msg *StreamSocketGetInfoResponse) Marshaler() _bindings.Marshaler {
	return _mStreamSocketGetInfoResponse
}

type StreamSocketSetTcpNoDelayResponse struct {
	_ struct{} `fidl:"s" fidl_size_v1:"1" fidl_alignment_v1:"1" fidl_size_v2:"1" fidl_alignment_v2:"1"`
}

var _mStreamSocketSetTcpNoDelayResponse = _bindings.CreateLazyMarshaler(StreamSocketSetTcpNoDelayResponse{})

func (msg *StreamSocketSetTcpNoDelayResponse) Marshaler() _bindings.Marshaler {
	return _mStreamSocketSetTcpNoDelayResponse
}

type StreamSocketGetTcpNoDelayResponse struct {
	_     struct{} `fidl:"s" fidl_size_v1:"1" fidl_alignment_v1:"1" fidl_size_v2:"1" fidl_alignment_v2:"1"`
	Value bool     `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mStreamSocketGetTcpNoDelayResponse = _bindings.CreateLazyMarshaler(StreamSocketGetTcpNoDelayResponse{})

func (msg *StreamSocketGetTcpNoDelayResponse) Marshaler() _bindings.Marshaler {
	return _mStreamSocketGetTcpNoDelayResponse
}

type StreamSocketSetTcpMaxSegmentResponse struct {
	_ struct{} `fidl:"s" fidl_size_v1:"1" fidl_alignment_v1:"1" fidl_size_v2:"1" fidl_alignment_v2:"1"`
}

var _mStreamSocketSetTcpMaxSegmentResponse = _bindings.CreateLazyMarshaler(StreamSocketSetTcpMaxSegmentResponse{})

func (msg *StreamSocketSetTcpMaxSegmentResponse) Marshaler() _bindings.Marshaler {
	return _mStreamSocketSetTcpMaxSegmentResponse
}

type StreamSocketGetTcpMaxSegmentResponse struct {
	_          struct{} `fidl:"s" fidl_size_v1:"4" fidl_alignment_v1:"4" fidl_size_v2:"4" fidl_alignment_v2:"4"`
	ValueBytes uint32   `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mStreamSocketGetTcpMaxSegmentResponse = _bindings.CreateLazyMarshaler(StreamSocketGetTcpMaxSegmentResponse{})

func (msg *StreamSocketGetTcpMaxSegmentResponse) Marshaler() _bindings.Marshaler {
	return _mStreamSocketGetTcpMaxSegmentResponse
}

type StreamSocketSetTcpCorkResponse struct {
	_ struct{} `fidl:"s" fidl_size_v1:"1" fidl_alignment_v1:"1" fidl_size_v2:"1" fidl_alignment_v2:"1"`
}

var _mStreamSocketSetTcpCorkResponse = _bindings.CreateLazyMarshaler(StreamSocketSetTcpCorkResponse{})

func (msg *StreamSocketSetTcpCorkResponse) Marshaler() _bindings.Marshaler {
	return _mStreamSocketSetTcpCorkResponse
}

type StreamSocketGetTcpCorkResponse struct {
	_     struct{} `fidl:"s" fidl_size_v1:"1" fidl_alignment_v1:"1" fidl_size_v2:"1" fidl_alignment_v2:"1"`
	Value bool     `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mStreamSocketGetTcpCorkResponse = _bindings.CreateLazyMarshaler(StreamSocketGetTcpCorkResponse{})

func (msg *StreamSocketGetTcpCorkResponse) Marshaler() _bindings.Marshaler {
	return _mStreamSocketGetTcpCorkResponse
}

type StreamSocketSetTcpKeepAliveIdleResponse struct {
	_ struct{} `fidl:"s" fidl_size_v1:"1" fidl_alignment_v1:"1" fidl_size_v2:"1" fidl_alignment_v2:"1"`
}

var _mStreamSocketSetTcpKeepAliveIdleResponse = _bindings.CreateLazyMarshaler(StreamSocketSetTcpKeepAliveIdleResponse{})

func (msg *StreamSocketSetTcpKeepAliveIdleResponse) Marshaler() _bindings.Marshaler {
	return _mStreamSocketSetTcpKeepAliveIdleResponse
}

type StreamSocketGetTcpKeepAliveIdleResponse struct {
	_         struct{} `fidl:"s" fidl_size_v1:"4" fidl_alignment_v1:"4" fidl_size_v2:"4" fidl_alignment_v2:"4"`
	ValueSecs uint32   `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mStreamSocketGetTcpKeepAliveIdleResponse = _bindings.CreateLazyMarshaler(StreamSocketGetTcpKeepAliveIdleResponse{})

func (msg *StreamSocketGetTcpKeepAliveIdleResponse) Marshaler() _bindings.Marshaler {
	return _mStreamSocketGetTcpKeepAliveIdleResponse
}

type StreamSocketSetTcpKeepAliveIntervalResponse struct {
	_ struct{} `fidl:"s" fidl_size_v1:"1" fidl_alignment_v1:"1" fidl_size_v2:"1" fidl_alignment_v2:"1"`
}

var _mStreamSocketSetTcpKeepAliveIntervalResponse = _bindings.CreateLazyMarshaler(StreamSocketSetTcpKeepAliveIntervalResponse{})

func (msg *StreamSocketSetTcpKeepAliveIntervalResponse) Marshaler() _bindings.Marshaler {
	return _mStreamSocketSetTcpKeepAliveIntervalResponse
}

type StreamSocketGetTcpKeepAliveIntervalResponse struct {
	_         struct{} `fidl:"s" fidl_size_v1:"4" fidl_alignment_v1:"4" fidl_size_v2:"4" fidl_alignment_v2:"4"`
	ValueSecs uint32   `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mStreamSocketGetTcpKeepAliveIntervalResponse = _bindings.CreateLazyMarshaler(StreamSocketGetTcpKeepAliveIntervalResponse{})

func (msg *StreamSocketGetTcpKeepAliveIntervalResponse) Marshaler() _bindings.Marshaler {
	return _mStreamSocketGetTcpKeepAliveIntervalResponse
}

type StreamSocketSetTcpKeepAliveCountResponse struct {
	_ struct{} `fidl:"s" fidl_size_v1:"1" fidl_alignment_v1:"1" fidl_size_v2:"1" fidl_alignment_v2:"1"`
}

var _mStreamSocketSetTcpKeepAliveCountResponse = _bindings.CreateLazyMarshaler(StreamSocketSetTcpKeepAliveCountResponse{})

func (msg *StreamSocketSetTcpKeepAliveCountResponse) Marshaler() _bindings.Marshaler {
	return _mStreamSocketSetTcpKeepAliveCountResponse
}

type StreamSocketGetTcpKeepAliveCountResponse struct {
	_     struct{} `fidl:"s" fidl_size_v1:"4" fidl_alignment_v1:"4" fidl_size_v2:"4" fidl_alignment_v2:"4"`
	Value uint32   `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mStreamSocketGetTcpKeepAliveCountResponse = _bindings.CreateLazyMarshaler(StreamSocketGetTcpKeepAliveCountResponse{})

func (msg *StreamSocketGetTcpKeepAliveCountResponse) Marshaler() _bindings.Marshaler {
	return _mStreamSocketGetTcpKeepAliveCountResponse
}

type StreamSocketSetTcpSynCountResponse struct {
	_ struct{} `fidl:"s" fidl_size_v1:"1" fidl_alignment_v1:"1" fidl_size_v2:"1" fidl_alignment_v2:"1"`
}

var _mStreamSocketSetTcpSynCountResponse = _bindings.CreateLazyMarshaler(StreamSocketSetTcpSynCountResponse{})

func (msg *StreamSocketSetTcpSynCountResponse) Marshaler() _bindings.Marshaler {
	return _mStreamSocketSetTcpSynCountResponse
}

type StreamSocketGetTcpSynCountResponse struct {
	_     struct{} `fidl:"s" fidl_size_v1:"4" fidl_alignment_v1:"4" fidl_size_v2:"4" fidl_alignment_v2:"4"`
	Value uint32   `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mStreamSocketGetTcpSynCountResponse = _bindings.CreateLazyMarshaler(StreamSocketGetTcpSynCountResponse{})

func (msg *StreamSocketGetTcpSynCountResponse) Marshaler() _bindings.Marshaler {
	return _mStreamSocketGetTcpSynCountResponse
}

type StreamSocketSetTcpLingerResponse struct {
	_ struct{} `fidl:"s" fidl_size_v1:"1" fidl_alignment_v1:"1" fidl_size_v2:"1" fidl_alignment_v2:"1"`
}

var _mStreamSocketSetTcpLingerResponse = _bindings.CreateLazyMarshaler(StreamSocketSetTcpLingerResponse{})

func (msg *StreamSocketSetTcpLingerResponse) Marshaler() _bindings.Marshaler {
	return _mStreamSocketSetTcpLingerResponse
}

type StreamSocketGetTcpLingerResponse struct {
	_         struct{}       `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	ValueSecs OptionalUint32 `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mStreamSocketGetTcpLingerResponse = _bindings.CreateLazyMarshaler(StreamSocketGetTcpLingerResponse{})

func (msg *StreamSocketGetTcpLingerResponse) Marshaler() _bindings.Marshaler {
	return _mStreamSocketGetTcpLingerResponse
}

type StreamSocketSetTcpDeferAcceptResponse struct {
	_ struct{} `fidl:"s" fidl_size_v1:"1" fidl_alignment_v1:"1" fidl_size_v2:"1" fidl_alignment_v2:"1"`
}

var _mStreamSocketSetTcpDeferAcceptResponse = _bindings.CreateLazyMarshaler(StreamSocketSetTcpDeferAcceptResponse{})

func (msg *StreamSocketSetTcpDeferAcceptResponse) Marshaler() _bindings.Marshaler {
	return _mStreamSocketSetTcpDeferAcceptResponse
}

type StreamSocketGetTcpDeferAcceptResponse struct {
	_         struct{} `fidl:"s" fidl_size_v1:"4" fidl_alignment_v1:"4" fidl_size_v2:"4" fidl_alignment_v2:"4"`
	ValueSecs uint32   `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mStreamSocketGetTcpDeferAcceptResponse = _bindings.CreateLazyMarshaler(StreamSocketGetTcpDeferAcceptResponse{})

func (msg *StreamSocketGetTcpDeferAcceptResponse) Marshaler() _bindings.Marshaler {
	return _mStreamSocketGetTcpDeferAcceptResponse
}

type StreamSocketSetTcpWindowClampResponse struct {
	_ struct{} `fidl:"s" fidl_size_v1:"1" fidl_alignment_v1:"1" fidl_size_v2:"1" fidl_alignment_v2:"1"`
}

var _mStreamSocketSetTcpWindowClampResponse = _bindings.CreateLazyMarshaler(StreamSocketSetTcpWindowClampResponse{})

func (msg *StreamSocketSetTcpWindowClampResponse) Marshaler() _bindings.Marshaler {
	return _mStreamSocketSetTcpWindowClampResponse
}

type StreamSocketGetTcpWindowClampResponse struct {
	_     struct{} `fidl:"s" fidl_size_v1:"4" fidl_alignment_v1:"4" fidl_size_v2:"4" fidl_alignment_v2:"4"`
	Value uint32   `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mStreamSocketGetTcpWindowClampResponse = _bindings.CreateLazyMarshaler(StreamSocketGetTcpWindowClampResponse{})

func (msg *StreamSocketGetTcpWindowClampResponse) Marshaler() _bindings.Marshaler {
	return _mStreamSocketGetTcpWindowClampResponse
}

type StreamSocketGetTcpInfoResponse struct {
	_    struct{} `fidl:"s" fidl_size_v1:"16" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Info TcpInfo  `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mStreamSocketGetTcpInfoResponse = _bindings.CreateLazyMarshaler(StreamSocketGetTcpInfoResponse{})

func (msg *StreamSocketGetTcpInfoResponse) Marshaler() _bindings.Marshaler {
	return _mStreamSocketGetTcpInfoResponse
}

type StreamSocketSetTcpQuickAckResponse struct {
	_ struct{} `fidl:"s" fidl_size_v1:"1" fidl_alignment_v1:"1" fidl_size_v2:"1" fidl_alignment_v2:"1"`
}

var _mStreamSocketSetTcpQuickAckResponse = _bindings.CreateLazyMarshaler(StreamSocketSetTcpQuickAckResponse{})

func (msg *StreamSocketSetTcpQuickAckResponse) Marshaler() _bindings.Marshaler {
	return _mStreamSocketSetTcpQuickAckResponse
}

type StreamSocketGetTcpQuickAckResponse struct {
	_     struct{} `fidl:"s" fidl_size_v1:"1" fidl_alignment_v1:"1" fidl_size_v2:"1" fidl_alignment_v2:"1"`
	Value bool     `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mStreamSocketGetTcpQuickAckResponse = _bindings.CreateLazyMarshaler(StreamSocketGetTcpQuickAckResponse{})

func (msg *StreamSocketGetTcpQuickAckResponse) Marshaler() _bindings.Marshaler {
	return _mStreamSocketGetTcpQuickAckResponse
}

type StreamSocketSetTcpCongestionResponse struct {
	_ struct{} `fidl:"s" fidl_size_v1:"1" fidl_alignment_v1:"1" fidl_size_v2:"1" fidl_alignment_v2:"1"`
}

var _mStreamSocketSetTcpCongestionResponse = _bindings.CreateLazyMarshaler(StreamSocketSetTcpCongestionResponse{})

func (msg *StreamSocketSetTcpCongestionResponse) Marshaler() _bindings.Marshaler {
	return _mStreamSocketSetTcpCongestionResponse
}

type StreamSocketGetTcpCongestionResponse struct {
	_     struct{}             `fidl:"s" fidl_size_v1:"4" fidl_alignment_v1:"4" fidl_size_v2:"4" fidl_alignment_v2:"4"`
	Value TcpCongestionControl `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mStreamSocketGetTcpCongestionResponse = _bindings.CreateLazyMarshaler(StreamSocketGetTcpCongestionResponse{})

func (msg *StreamSocketGetTcpCongestionResponse) Marshaler() _bindings.Marshaler {
	return _mStreamSocketGetTcpCongestionResponse
}

type StreamSocketSetTcpUserTimeoutResponse struct {
	_ struct{} `fidl:"s" fidl_size_v1:"1" fidl_alignment_v1:"1" fidl_size_v2:"1" fidl_alignment_v2:"1"`
}

var _mStreamSocketSetTcpUserTimeoutResponse = _bindings.CreateLazyMarshaler(StreamSocketSetTcpUserTimeoutResponse{})

func (msg *StreamSocketSetTcpUserTimeoutResponse) Marshaler() _bindings.Marshaler {
	return _mStreamSocketSetTcpUserTimeoutResponse
}

type StreamSocketGetTcpUserTimeoutResponse struct {
	_           struct{} `fidl:"s" fidl_size_v1:"4" fidl_alignment_v1:"4" fidl_size_v2:"4" fidl_alignment_v2:"4"`
	ValueMillis uint32   `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mStreamSocketGetTcpUserTimeoutResponse = _bindings.CreateLazyMarshaler(StreamSocketGetTcpUserTimeoutResponse{})

func (msg *StreamSocketGetTcpUserTimeoutResponse) Marshaler() _bindings.Marshaler {
	return _mStreamSocketGetTcpUserTimeoutResponse
}

type ProviderStreamSocketResponse struct {
	_ struct{}                     `fidl:"s" fidl_size_v1:"4" fidl_alignment_v1:"4" fidl_size_v2:"4" fidl_alignment_v2:"4"`
	S StreamSocketWithCtxInterface `fidl_offset_v1:"0" fidl_offset_v2:"0" fidl_handle_subtype:"4"`
}

var _mProviderStreamSocketResponse = _bindings.CreateLazyMarshaler(ProviderStreamSocketResponse{})

func (msg *ProviderStreamSocketResponse) Marshaler() _bindings.Marshaler {
	return _mProviderStreamSocketResponse
}

type ProviderDatagramSocketResponse struct {
	_ struct{}                       `fidl:"s" fidl_size_v1:"4" fidl_alignment_v1:"4" fidl_size_v2:"4" fidl_alignment_v2:"4"`
	S DatagramSocketWithCtxInterface `fidl_offset_v1:"0" fidl_offset_v2:"0" fidl_handle_subtype:"4"`
}

var _mProviderDatagramSocketResponse = _bindings.CreateLazyMarshaler(ProviderDatagramSocketResponse{})

func (msg *ProviderDatagramSocketResponse) Marshaler() _bindings.Marshaler {
	return _mProviderDatagramSocketResponse
}

type ProviderInterfaceIndexToNameResponse struct {
	_    struct{} `fidl:"s" fidl_size_v1:"16" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Name string   `fidl_offset_v1:"0" fidl_offset_v2:"0" fidl_bounds:"15"`
}

var _mProviderInterfaceIndexToNameResponse = _bindings.CreateLazyMarshaler(ProviderInterfaceIndexToNameResponse{})

func (msg *ProviderInterfaceIndexToNameResponse) Marshaler() _bindings.Marshaler {
	return _mProviderInterfaceIndexToNameResponse
}

type ProviderInterfaceNameToIndexResponse struct {
	_     struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	Index uint64   `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mProviderInterfaceNameToIndexResponse = _bindings.CreateLazyMarshaler(ProviderInterfaceNameToIndexResponse{})

func (msg *ProviderInterfaceNameToIndexResponse) Marshaler() _bindings.Marshaler {
	return _mProviderInterfaceNameToIndexResponse
}

type ProviderInterfaceNameToFlagsResponse struct {
	_     struct{}       `fidl:"s" fidl_size_v1:"2" fidl_alignment_v1:"2" fidl_size_v2:"2" fidl_alignment_v2:"2"`
	Flags InterfaceFlags `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mProviderInterfaceNameToFlagsResponse = _bindings.CreateLazyMarshaler(ProviderInterfaceNameToFlagsResponse{})

func (msg *ProviderInterfaceNameToFlagsResponse) Marshaler() _bindings.Marshaler {
	return _mProviderInterfaceNameToFlagsResponse
}

// IPv4 multicast membership options.
type IpMulticastMembership struct {
	_ struct{} `fidl:"s" fidl_size_v1:"16" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	// Interface index for membership.
	Iface uint64 `fidl_offset_v1:"0" fidl_offset_v2:"0"`
	// Local interface address requesting or relinquishing ownership.
	LocalAddr fuchsianet.Ipv4Address `fidl_offset_v1:"8" fidl_offset_v2:"8"`
	// Address of the multicast group the membership refers to.
	McastAddr fuchsianet.Ipv4Address `fidl_offset_v1:"12" fidl_offset_v2:"12"`
}

var _mIpMulticastMembership = _bindings.CreateLazyMarshaler(IpMulticastMembership{})

func (msg *IpMulticastMembership) Marshaler() _bindings.Marshaler {
	return _mIpMulticastMembership
}

// IPv6 multicast membership options.
type Ipv6MulticastMembership struct {
	_ struct{} `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"24" fidl_alignment_v2:"8"`
	// Interface index for membership.
	Iface uint64 `fidl_offset_v1:"0" fidl_offset_v2:"0"`
	// Address of the multicast group the membership refers to.
	McastAddr fuchsianet.Ipv6Address `fidl_offset_v1:"8" fidl_offset_v2:"8"`
}

var _mIpv6MulticastMembership = _bindings.CreateLazyMarshaler(Ipv6MulticastMembership{})

func (msg *Ipv6MulticastMembership) Marshaler() _bindings.Marshaler {
	return _mIpv6MulticastMembership
}

type Empty struct {
	_ struct{} `fidl:"s" fidl_size_v1:"1" fidl_alignment_v1:"1" fidl_size_v2:"1" fidl_alignment_v2:"1"`
}

var _mEmpty = _bindings.CreateLazyMarshaler(Empty{})

func (msg *Empty) Marshaler() _bindings.Marshaler {
	return _mEmpty
}

type baseSocketWithCtxCloneRequest struct {
	_      struct{}                              `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	Flags  uint32                                `fidl_offset_v1:"0" fidl_offset_v2:"0"`
	Object fuchsiaio.NodeWithCtxInterfaceRequest `fidl_offset_v1:"4" fidl_offset_v2:"4" fidl_handle_subtype:"4" fidl_bounds:"0"`
}

var _mbaseSocketWithCtxCloneRequest = _bindings.CreateLazyMarshaler(baseSocketWithCtxCloneRequest{})

func (msg *baseSocketWithCtxCloneRequest) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxCloneRequest
}

type baseSocketWithCtxCloseResponse struct {
	_ struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	S int32    `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mbaseSocketWithCtxCloseResponse = _bindings.CreateLazyMarshaler(baseSocketWithCtxCloseResponse{})

func (msg *baseSocketWithCtxCloseResponse) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxCloseResponse
}

type baseSocketWithCtxDescribeResponse struct {
	_    struct{}           `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Info fuchsiaio.NodeInfo `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mbaseSocketWithCtxDescribeResponse = _bindings.CreateLazyMarshaler(baseSocketWithCtxDescribeResponse{})

func (msg *baseSocketWithCtxDescribeResponse) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxDescribeResponse
}

type baseSocketWithCtxOnOpenResponse struct {
	_    struct{}            `fidl:"s" fidl_size_v1:"32" fidl_alignment_v1:"8" fidl_size_v2:"24" fidl_alignment_v2:"8"`
	S    int32               `fidl_offset_v1:"0" fidl_offset_v2:"0"`
	Info *fuchsiaio.NodeInfo `fidl_offset_v1:"8" fidl_offset_v2:"8"`
}

var _mbaseSocketWithCtxOnOpenResponse = _bindings.CreateLazyMarshaler(baseSocketWithCtxOnOpenResponse{})

func (msg *baseSocketWithCtxOnOpenResponse) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxOnOpenResponse
}

type baseSocketWithCtxSyncResponse struct {
	_ struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	S int32    `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mbaseSocketWithCtxSyncResponse = _bindings.CreateLazyMarshaler(baseSocketWithCtxSyncResponse{})

func (msg *baseSocketWithCtxSyncResponse) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxSyncResponse
}

type baseSocketWithCtxGetAttrResponse struct {
	_          struct{}                 `fidl:"s" fidl_size_v1:"64" fidl_alignment_v1:"8" fidl_size_v2:"64" fidl_alignment_v2:"8"`
	S          int32                    `fidl_offset_v1:"0" fidl_offset_v2:"0"`
	Attributes fuchsiaio.NodeAttributes `fidl_offset_v1:"8" fidl_offset_v2:"8"`
}

var _mbaseSocketWithCtxGetAttrResponse = _bindings.CreateLazyMarshaler(baseSocketWithCtxGetAttrResponse{})

func (msg *baseSocketWithCtxGetAttrResponse) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxGetAttrResponse
}

type baseSocketWithCtxSetAttrRequest struct {
	_          struct{}                 `fidl:"s" fidl_size_v1:"64" fidl_alignment_v1:"8" fidl_size_v2:"64" fidl_alignment_v2:"8"`
	Flags      uint32                   `fidl_offset_v1:"0" fidl_offset_v2:"0"`
	Attributes fuchsiaio.NodeAttributes `fidl_offset_v1:"8" fidl_offset_v2:"8"`
}

var _mbaseSocketWithCtxSetAttrRequest = _bindings.CreateLazyMarshaler(baseSocketWithCtxSetAttrRequest{})

func (msg *baseSocketWithCtxSetAttrRequest) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxSetAttrRequest
}

type baseSocketWithCtxSetAttrResponse struct {
	_ struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	S int32    `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mbaseSocketWithCtxSetAttrResponse = _bindings.CreateLazyMarshaler(baseSocketWithCtxSetAttrResponse{})

func (msg *baseSocketWithCtxSetAttrResponse) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxSetAttrResponse
}

type baseSocketWithCtxNodeGetFlagsResponse struct {
	_     struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	S     int32    `fidl_offset_v1:"0" fidl_offset_v2:"0"`
	Flags uint32   `fidl_offset_v1:"4" fidl_offset_v2:"4"`
}

var _mbaseSocketWithCtxNodeGetFlagsResponse = _bindings.CreateLazyMarshaler(baseSocketWithCtxNodeGetFlagsResponse{})

func (msg *baseSocketWithCtxNodeGetFlagsResponse) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxNodeGetFlagsResponse
}

type baseSocketWithCtxNodeSetFlagsRequest struct {
	_     struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	Flags uint32   `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mbaseSocketWithCtxNodeSetFlagsRequest = _bindings.CreateLazyMarshaler(baseSocketWithCtxNodeSetFlagsRequest{})

func (msg *baseSocketWithCtxNodeSetFlagsRequest) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxNodeSetFlagsRequest
}

type baseSocketWithCtxNodeSetFlagsResponse struct {
	_ struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	S int32    `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mbaseSocketWithCtxNodeSetFlagsResponse = _bindings.CreateLazyMarshaler(baseSocketWithCtxNodeSetFlagsResponse{})

func (msg *baseSocketWithCtxNodeSetFlagsResponse) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxNodeSetFlagsResponse
}

type baseSocketWithCtxBindRequest struct {
	_    struct{}                 `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Addr fuchsianet.SocketAddress `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mbaseSocketWithCtxBindRequest = _bindings.CreateLazyMarshaler(baseSocketWithCtxBindRequest{})

func (msg *baseSocketWithCtxBindRequest) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxBindRequest
}

type baseSocketWithCtxBindResponse struct {
	_      struct{}             `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketBindResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mbaseSocketWithCtxBindResponse = _bindings.CreateLazyMarshaler(baseSocketWithCtxBindResponse{})

func (msg *baseSocketWithCtxBindResponse) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxBindResponse
}

type baseSocketWithCtxConnectRequest struct {
	_    struct{}                 `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Addr fuchsianet.SocketAddress `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mbaseSocketWithCtxConnectRequest = _bindings.CreateLazyMarshaler(baseSocketWithCtxConnectRequest{})

func (msg *baseSocketWithCtxConnectRequest) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxConnectRequest
}

type baseSocketWithCtxConnectResponse struct {
	_      struct{}                `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketConnectResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mbaseSocketWithCtxConnectResponse = _bindings.CreateLazyMarshaler(baseSocketWithCtxConnectResponse{})

func (msg *baseSocketWithCtxConnectResponse) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxConnectResponse
}

type baseSocketWithCtxDisconnectResponse struct {
	_      struct{}                   `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketDisconnectResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mbaseSocketWithCtxDisconnectResponse = _bindings.CreateLazyMarshaler(baseSocketWithCtxDisconnectResponse{})

func (msg *baseSocketWithCtxDisconnectResponse) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxDisconnectResponse
}

type baseSocketWithCtxGetSockNameResponse struct {
	_      struct{}                    `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketGetSockNameResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mbaseSocketWithCtxGetSockNameResponse = _bindings.CreateLazyMarshaler(baseSocketWithCtxGetSockNameResponse{})

func (msg *baseSocketWithCtxGetSockNameResponse) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxGetSockNameResponse
}

type baseSocketWithCtxGetPeerNameResponse struct {
	_      struct{}                    `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketGetPeerNameResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mbaseSocketWithCtxGetPeerNameResponse = _bindings.CreateLazyMarshaler(baseSocketWithCtxGetPeerNameResponse{})

func (msg *baseSocketWithCtxGetPeerNameResponse) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxGetPeerNameResponse
}

type baseSocketWithCtxShutdownRequest struct {
	_    struct{}     `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	Mode ShutdownMode `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mbaseSocketWithCtxShutdownRequest = _bindings.CreateLazyMarshaler(baseSocketWithCtxShutdownRequest{})

func (msg *baseSocketWithCtxShutdownRequest) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxShutdownRequest
}

type baseSocketWithCtxShutdownResponse struct {
	_      struct{}                 `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketShutdownResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mbaseSocketWithCtxShutdownResponse = _bindings.CreateLazyMarshaler(baseSocketWithCtxShutdownResponse{})

func (msg *baseSocketWithCtxShutdownResponse) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxShutdownResponse
}

type baseSocketWithCtxShutdown2Request struct {
	_    struct{}     `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	Mode ShutdownMode `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mbaseSocketWithCtxShutdown2Request = _bindings.CreateLazyMarshaler(baseSocketWithCtxShutdown2Request{})

func (msg *baseSocketWithCtxShutdown2Request) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxShutdown2Request
}

type baseSocketWithCtxShutdown2Response struct {
	_      struct{}                  `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketShutdown2Result `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mbaseSocketWithCtxShutdown2Response = _bindings.CreateLazyMarshaler(baseSocketWithCtxShutdown2Response{})

func (msg *baseSocketWithCtxShutdown2Response) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxShutdown2Response
}

type baseSocketWithCtxSetReuseAddressRequest struct {
	_     struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	Value bool     `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mbaseSocketWithCtxSetReuseAddressRequest = _bindings.CreateLazyMarshaler(baseSocketWithCtxSetReuseAddressRequest{})

func (msg *baseSocketWithCtxSetReuseAddressRequest) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxSetReuseAddressRequest
}

type baseSocketWithCtxSetReuseAddressResponse struct {
	_      struct{}                        `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketSetReuseAddressResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mbaseSocketWithCtxSetReuseAddressResponse = _bindings.CreateLazyMarshaler(baseSocketWithCtxSetReuseAddressResponse{})

func (msg *baseSocketWithCtxSetReuseAddressResponse) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxSetReuseAddressResponse
}

type baseSocketWithCtxGetReuseAddressResponse struct {
	_      struct{}                        `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketGetReuseAddressResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mbaseSocketWithCtxGetReuseAddressResponse = _bindings.CreateLazyMarshaler(baseSocketWithCtxGetReuseAddressResponse{})

func (msg *baseSocketWithCtxGetReuseAddressResponse) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxGetReuseAddressResponse
}

type baseSocketWithCtxGetErrorResponse struct {
	_      struct{}                 `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketGetErrorResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mbaseSocketWithCtxGetErrorResponse = _bindings.CreateLazyMarshaler(baseSocketWithCtxGetErrorResponse{})

func (msg *baseSocketWithCtxGetErrorResponse) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxGetErrorResponse
}

type baseSocketWithCtxSetBroadcastRequest struct {
	_     struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	Value bool     `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mbaseSocketWithCtxSetBroadcastRequest = _bindings.CreateLazyMarshaler(baseSocketWithCtxSetBroadcastRequest{})

func (msg *baseSocketWithCtxSetBroadcastRequest) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxSetBroadcastRequest
}

type baseSocketWithCtxSetBroadcastResponse struct {
	_      struct{}                     `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketSetBroadcastResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mbaseSocketWithCtxSetBroadcastResponse = _bindings.CreateLazyMarshaler(baseSocketWithCtxSetBroadcastResponse{})

func (msg *baseSocketWithCtxSetBroadcastResponse) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxSetBroadcastResponse
}

type baseSocketWithCtxGetBroadcastResponse struct {
	_      struct{}                     `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketGetBroadcastResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mbaseSocketWithCtxGetBroadcastResponse = _bindings.CreateLazyMarshaler(baseSocketWithCtxGetBroadcastResponse{})

func (msg *baseSocketWithCtxGetBroadcastResponse) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxGetBroadcastResponse
}

type baseSocketWithCtxSetSendBufferRequest struct {
	_          struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	ValueBytes uint64   `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mbaseSocketWithCtxSetSendBufferRequest = _bindings.CreateLazyMarshaler(baseSocketWithCtxSetSendBufferRequest{})

func (msg *baseSocketWithCtxSetSendBufferRequest) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxSetSendBufferRequest
}

type baseSocketWithCtxSetSendBufferResponse struct {
	_      struct{}                      `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketSetSendBufferResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mbaseSocketWithCtxSetSendBufferResponse = _bindings.CreateLazyMarshaler(baseSocketWithCtxSetSendBufferResponse{})

func (msg *baseSocketWithCtxSetSendBufferResponse) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxSetSendBufferResponse
}

type baseSocketWithCtxGetSendBufferResponse struct {
	_      struct{}                      `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketGetSendBufferResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mbaseSocketWithCtxGetSendBufferResponse = _bindings.CreateLazyMarshaler(baseSocketWithCtxGetSendBufferResponse{})

func (msg *baseSocketWithCtxGetSendBufferResponse) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxGetSendBufferResponse
}

type baseSocketWithCtxSetReceiveBufferRequest struct {
	_          struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	ValueBytes uint64   `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mbaseSocketWithCtxSetReceiveBufferRequest = _bindings.CreateLazyMarshaler(baseSocketWithCtxSetReceiveBufferRequest{})

func (msg *baseSocketWithCtxSetReceiveBufferRequest) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxSetReceiveBufferRequest
}

type baseSocketWithCtxSetReceiveBufferResponse struct {
	_      struct{}                         `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketSetReceiveBufferResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mbaseSocketWithCtxSetReceiveBufferResponse = _bindings.CreateLazyMarshaler(baseSocketWithCtxSetReceiveBufferResponse{})

func (msg *baseSocketWithCtxSetReceiveBufferResponse) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxSetReceiveBufferResponse
}

type baseSocketWithCtxGetReceiveBufferResponse struct {
	_      struct{}                         `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketGetReceiveBufferResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mbaseSocketWithCtxGetReceiveBufferResponse = _bindings.CreateLazyMarshaler(baseSocketWithCtxGetReceiveBufferResponse{})

func (msg *baseSocketWithCtxGetReceiveBufferResponse) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxGetReceiveBufferResponse
}

type baseSocketWithCtxSetKeepAliveRequest struct {
	_     struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	Value bool     `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mbaseSocketWithCtxSetKeepAliveRequest = _bindings.CreateLazyMarshaler(baseSocketWithCtxSetKeepAliveRequest{})

func (msg *baseSocketWithCtxSetKeepAliveRequest) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxSetKeepAliveRequest
}

type baseSocketWithCtxSetKeepAliveResponse struct {
	_      struct{}                     `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketSetKeepAliveResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mbaseSocketWithCtxSetKeepAliveResponse = _bindings.CreateLazyMarshaler(baseSocketWithCtxSetKeepAliveResponse{})

func (msg *baseSocketWithCtxSetKeepAliveResponse) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxSetKeepAliveResponse
}

type baseSocketWithCtxGetKeepAliveResponse struct {
	_      struct{}                     `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketGetKeepAliveResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mbaseSocketWithCtxGetKeepAliveResponse = _bindings.CreateLazyMarshaler(baseSocketWithCtxGetKeepAliveResponse{})

func (msg *baseSocketWithCtxGetKeepAliveResponse) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxGetKeepAliveResponse
}

type baseSocketWithCtxSetOutOfBandInlineRequest struct {
	_     struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	Value bool     `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mbaseSocketWithCtxSetOutOfBandInlineRequest = _bindings.CreateLazyMarshaler(baseSocketWithCtxSetOutOfBandInlineRequest{})

func (msg *baseSocketWithCtxSetOutOfBandInlineRequest) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxSetOutOfBandInlineRequest
}

type baseSocketWithCtxSetOutOfBandInlineResponse struct {
	_      struct{}                           `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketSetOutOfBandInlineResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mbaseSocketWithCtxSetOutOfBandInlineResponse = _bindings.CreateLazyMarshaler(baseSocketWithCtxSetOutOfBandInlineResponse{})

func (msg *baseSocketWithCtxSetOutOfBandInlineResponse) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxSetOutOfBandInlineResponse
}

type baseSocketWithCtxGetOutOfBandInlineResponse struct {
	_      struct{}                           `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketGetOutOfBandInlineResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mbaseSocketWithCtxGetOutOfBandInlineResponse = _bindings.CreateLazyMarshaler(baseSocketWithCtxGetOutOfBandInlineResponse{})

func (msg *baseSocketWithCtxGetOutOfBandInlineResponse) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxGetOutOfBandInlineResponse
}

type baseSocketWithCtxSetNoCheckRequest struct {
	_     struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	Value bool     `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mbaseSocketWithCtxSetNoCheckRequest = _bindings.CreateLazyMarshaler(baseSocketWithCtxSetNoCheckRequest{})

func (msg *baseSocketWithCtxSetNoCheckRequest) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxSetNoCheckRequest
}

type baseSocketWithCtxSetNoCheckResponse struct {
	_      struct{}                   `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketSetNoCheckResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mbaseSocketWithCtxSetNoCheckResponse = _bindings.CreateLazyMarshaler(baseSocketWithCtxSetNoCheckResponse{})

func (msg *baseSocketWithCtxSetNoCheckResponse) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxSetNoCheckResponse
}

type baseSocketWithCtxGetNoCheckResponse struct {
	_      struct{}                   `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketGetNoCheckResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mbaseSocketWithCtxGetNoCheckResponse = _bindings.CreateLazyMarshaler(baseSocketWithCtxGetNoCheckResponse{})

func (msg *baseSocketWithCtxGetNoCheckResponse) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxGetNoCheckResponse
}

type baseSocketWithCtxSetLingerRequest struct {
	_          struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	Linger     bool     `fidl_offset_v1:"0" fidl_offset_v2:"0"`
	LengthSecs uint32   `fidl_offset_v1:"4" fidl_offset_v2:"4"`
}

var _mbaseSocketWithCtxSetLingerRequest = _bindings.CreateLazyMarshaler(baseSocketWithCtxSetLingerRequest{})

func (msg *baseSocketWithCtxSetLingerRequest) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxSetLingerRequest
}

type baseSocketWithCtxSetLingerResponse struct {
	_      struct{}                  `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketSetLingerResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mbaseSocketWithCtxSetLingerResponse = _bindings.CreateLazyMarshaler(baseSocketWithCtxSetLingerResponse{})

func (msg *baseSocketWithCtxSetLingerResponse) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxSetLingerResponse
}

type baseSocketWithCtxGetLingerResponse struct {
	_      struct{}                  `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketGetLingerResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mbaseSocketWithCtxGetLingerResponse = _bindings.CreateLazyMarshaler(baseSocketWithCtxGetLingerResponse{})

func (msg *baseSocketWithCtxGetLingerResponse) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxGetLingerResponse
}

type baseSocketWithCtxSetReusePortRequest struct {
	_     struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	Value bool     `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mbaseSocketWithCtxSetReusePortRequest = _bindings.CreateLazyMarshaler(baseSocketWithCtxSetReusePortRequest{})

func (msg *baseSocketWithCtxSetReusePortRequest) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxSetReusePortRequest
}

type baseSocketWithCtxSetReusePortResponse struct {
	_      struct{}                     `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketSetReusePortResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mbaseSocketWithCtxSetReusePortResponse = _bindings.CreateLazyMarshaler(baseSocketWithCtxSetReusePortResponse{})

func (msg *baseSocketWithCtxSetReusePortResponse) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxSetReusePortResponse
}

type baseSocketWithCtxGetReusePortResponse struct {
	_      struct{}                     `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketGetReusePortResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mbaseSocketWithCtxGetReusePortResponse = _bindings.CreateLazyMarshaler(baseSocketWithCtxGetReusePortResponse{})

func (msg *baseSocketWithCtxGetReusePortResponse) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxGetReusePortResponse
}

type baseSocketWithCtxGetAcceptConnResponse struct {
	_      struct{}                      `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketGetAcceptConnResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mbaseSocketWithCtxGetAcceptConnResponse = _bindings.CreateLazyMarshaler(baseSocketWithCtxGetAcceptConnResponse{})

func (msg *baseSocketWithCtxGetAcceptConnResponse) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxGetAcceptConnResponse
}

type baseSocketWithCtxSetBindToDeviceRequest struct {
	_     struct{} `fidl:"s" fidl_size_v1:"16" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Value string   `fidl_offset_v1:"0" fidl_offset_v2:"0" fidl_bounds:"15"`
}

var _mbaseSocketWithCtxSetBindToDeviceRequest = _bindings.CreateLazyMarshaler(baseSocketWithCtxSetBindToDeviceRequest{})

func (msg *baseSocketWithCtxSetBindToDeviceRequest) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxSetBindToDeviceRequest
}

type baseSocketWithCtxSetBindToDeviceResponse struct {
	_      struct{}                        `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketSetBindToDeviceResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mbaseSocketWithCtxSetBindToDeviceResponse = _bindings.CreateLazyMarshaler(baseSocketWithCtxSetBindToDeviceResponse{})

func (msg *baseSocketWithCtxSetBindToDeviceResponse) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxSetBindToDeviceResponse
}

type baseSocketWithCtxGetBindToDeviceResponse struct {
	_      struct{}                        `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketGetBindToDeviceResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mbaseSocketWithCtxGetBindToDeviceResponse = _bindings.CreateLazyMarshaler(baseSocketWithCtxGetBindToDeviceResponse{})

func (msg *baseSocketWithCtxGetBindToDeviceResponse) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxGetBindToDeviceResponse
}

type baseSocketWithCtxSetTimestampRequest struct {
	_     struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	Value bool     `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mbaseSocketWithCtxSetTimestampRequest = _bindings.CreateLazyMarshaler(baseSocketWithCtxSetTimestampRequest{})

func (msg *baseSocketWithCtxSetTimestampRequest) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxSetTimestampRequest
}

type baseSocketWithCtxSetTimestampResponse struct {
	_      struct{}                     `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketSetTimestampResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mbaseSocketWithCtxSetTimestampResponse = _bindings.CreateLazyMarshaler(baseSocketWithCtxSetTimestampResponse{})

func (msg *baseSocketWithCtxSetTimestampResponse) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxSetTimestampResponse
}

type baseSocketWithCtxGetTimestampResponse struct {
	_      struct{}                     `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketGetTimestampResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mbaseSocketWithCtxGetTimestampResponse = _bindings.CreateLazyMarshaler(baseSocketWithCtxGetTimestampResponse{})

func (msg *baseSocketWithCtxGetTimestampResponse) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxGetTimestampResponse
}

type baseSocketWithCtxSetIpTypeOfServiceRequest struct {
	_     struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	Value uint8    `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mbaseSocketWithCtxSetIpTypeOfServiceRequest = _bindings.CreateLazyMarshaler(baseSocketWithCtxSetIpTypeOfServiceRequest{})

func (msg *baseSocketWithCtxSetIpTypeOfServiceRequest) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxSetIpTypeOfServiceRequest
}

type baseSocketWithCtxSetIpTypeOfServiceResponse struct {
	_      struct{}                           `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketSetIpTypeOfServiceResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mbaseSocketWithCtxSetIpTypeOfServiceResponse = _bindings.CreateLazyMarshaler(baseSocketWithCtxSetIpTypeOfServiceResponse{})

func (msg *baseSocketWithCtxSetIpTypeOfServiceResponse) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxSetIpTypeOfServiceResponse
}

type baseSocketWithCtxGetIpTypeOfServiceResponse struct {
	_      struct{}                           `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketGetIpTypeOfServiceResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mbaseSocketWithCtxGetIpTypeOfServiceResponse = _bindings.CreateLazyMarshaler(baseSocketWithCtxGetIpTypeOfServiceResponse{})

func (msg *baseSocketWithCtxGetIpTypeOfServiceResponse) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxGetIpTypeOfServiceResponse
}

type baseSocketWithCtxSetIpTtlRequest struct {
	_     struct{}      `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Value OptionalUint8 `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mbaseSocketWithCtxSetIpTtlRequest = _bindings.CreateLazyMarshaler(baseSocketWithCtxSetIpTtlRequest{})

func (msg *baseSocketWithCtxSetIpTtlRequest) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxSetIpTtlRequest
}

type baseSocketWithCtxSetIpTtlResponse struct {
	_      struct{}                 `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketSetIpTtlResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mbaseSocketWithCtxSetIpTtlResponse = _bindings.CreateLazyMarshaler(baseSocketWithCtxSetIpTtlResponse{})

func (msg *baseSocketWithCtxSetIpTtlResponse) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxSetIpTtlResponse
}

type baseSocketWithCtxGetIpTtlResponse struct {
	_      struct{}                 `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketGetIpTtlResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mbaseSocketWithCtxGetIpTtlResponse = _bindings.CreateLazyMarshaler(baseSocketWithCtxGetIpTtlResponse{})

func (msg *baseSocketWithCtxGetIpTtlResponse) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxGetIpTtlResponse
}

type baseSocketWithCtxSetIpPacketInfoRequest struct {
	_     struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	Value bool     `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mbaseSocketWithCtxSetIpPacketInfoRequest = _bindings.CreateLazyMarshaler(baseSocketWithCtxSetIpPacketInfoRequest{})

func (msg *baseSocketWithCtxSetIpPacketInfoRequest) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxSetIpPacketInfoRequest
}

type baseSocketWithCtxSetIpPacketInfoResponse struct {
	_      struct{}                        `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketSetIpPacketInfoResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mbaseSocketWithCtxSetIpPacketInfoResponse = _bindings.CreateLazyMarshaler(baseSocketWithCtxSetIpPacketInfoResponse{})

func (msg *baseSocketWithCtxSetIpPacketInfoResponse) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxSetIpPacketInfoResponse
}

type baseSocketWithCtxGetIpPacketInfoResponse struct {
	_      struct{}                        `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketGetIpPacketInfoResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mbaseSocketWithCtxGetIpPacketInfoResponse = _bindings.CreateLazyMarshaler(baseSocketWithCtxGetIpPacketInfoResponse{})

func (msg *baseSocketWithCtxGetIpPacketInfoResponse) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxGetIpPacketInfoResponse
}

type baseSocketWithCtxSetIpReceiveTypeOfServiceRequest struct {
	_     struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	Value bool     `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mbaseSocketWithCtxSetIpReceiveTypeOfServiceRequest = _bindings.CreateLazyMarshaler(baseSocketWithCtxSetIpReceiveTypeOfServiceRequest{})

func (msg *baseSocketWithCtxSetIpReceiveTypeOfServiceRequest) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxSetIpReceiveTypeOfServiceRequest
}

type baseSocketWithCtxSetIpReceiveTypeOfServiceResponse struct {
	_      struct{}                                  `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketSetIpReceiveTypeOfServiceResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mbaseSocketWithCtxSetIpReceiveTypeOfServiceResponse = _bindings.CreateLazyMarshaler(baseSocketWithCtxSetIpReceiveTypeOfServiceResponse{})

func (msg *baseSocketWithCtxSetIpReceiveTypeOfServiceResponse) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxSetIpReceiveTypeOfServiceResponse
}

type baseSocketWithCtxGetIpReceiveTypeOfServiceResponse struct {
	_      struct{}                                  `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketGetIpReceiveTypeOfServiceResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mbaseSocketWithCtxGetIpReceiveTypeOfServiceResponse = _bindings.CreateLazyMarshaler(baseSocketWithCtxGetIpReceiveTypeOfServiceResponse{})

func (msg *baseSocketWithCtxGetIpReceiveTypeOfServiceResponse) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxGetIpReceiveTypeOfServiceResponse
}

type baseSocketWithCtxSetIpMulticastInterfaceRequest struct {
	_       struct{}               `fidl:"s" fidl_size_v1:"16" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Iface   uint64                 `fidl_offset_v1:"0" fidl_offset_v2:"0"`
	Address fuchsianet.Ipv4Address `fidl_offset_v1:"8" fidl_offset_v2:"8"`
}

var _mbaseSocketWithCtxSetIpMulticastInterfaceRequest = _bindings.CreateLazyMarshaler(baseSocketWithCtxSetIpMulticastInterfaceRequest{})

func (msg *baseSocketWithCtxSetIpMulticastInterfaceRequest) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxSetIpMulticastInterfaceRequest
}

type baseSocketWithCtxSetIpMulticastInterfaceResponse struct {
	_      struct{}                                `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketSetIpMulticastInterfaceResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mbaseSocketWithCtxSetIpMulticastInterfaceResponse = _bindings.CreateLazyMarshaler(baseSocketWithCtxSetIpMulticastInterfaceResponse{})

func (msg *baseSocketWithCtxSetIpMulticastInterfaceResponse) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxSetIpMulticastInterfaceResponse
}

type baseSocketWithCtxGetIpMulticastInterfaceResponse struct {
	_      struct{}                                `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketGetIpMulticastInterfaceResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mbaseSocketWithCtxGetIpMulticastInterfaceResponse = _bindings.CreateLazyMarshaler(baseSocketWithCtxGetIpMulticastInterfaceResponse{})

func (msg *baseSocketWithCtxGetIpMulticastInterfaceResponse) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxGetIpMulticastInterfaceResponse
}

type baseSocketWithCtxSetIpMulticastTtlRequest struct {
	_     struct{}      `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Value OptionalUint8 `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mbaseSocketWithCtxSetIpMulticastTtlRequest = _bindings.CreateLazyMarshaler(baseSocketWithCtxSetIpMulticastTtlRequest{})

func (msg *baseSocketWithCtxSetIpMulticastTtlRequest) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxSetIpMulticastTtlRequest
}

type baseSocketWithCtxSetIpMulticastTtlResponse struct {
	_      struct{}                          `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketSetIpMulticastTtlResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mbaseSocketWithCtxSetIpMulticastTtlResponse = _bindings.CreateLazyMarshaler(baseSocketWithCtxSetIpMulticastTtlResponse{})

func (msg *baseSocketWithCtxSetIpMulticastTtlResponse) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxSetIpMulticastTtlResponse
}

type baseSocketWithCtxGetIpMulticastTtlResponse struct {
	_      struct{}                          `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketGetIpMulticastTtlResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mbaseSocketWithCtxGetIpMulticastTtlResponse = _bindings.CreateLazyMarshaler(baseSocketWithCtxGetIpMulticastTtlResponse{})

func (msg *baseSocketWithCtxGetIpMulticastTtlResponse) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxGetIpMulticastTtlResponse
}

type baseSocketWithCtxSetIpMulticastLoopbackRequest struct {
	_     struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	Value bool     `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mbaseSocketWithCtxSetIpMulticastLoopbackRequest = _bindings.CreateLazyMarshaler(baseSocketWithCtxSetIpMulticastLoopbackRequest{})

func (msg *baseSocketWithCtxSetIpMulticastLoopbackRequest) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxSetIpMulticastLoopbackRequest
}

type baseSocketWithCtxSetIpMulticastLoopbackResponse struct {
	_      struct{}                               `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketSetIpMulticastLoopbackResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mbaseSocketWithCtxSetIpMulticastLoopbackResponse = _bindings.CreateLazyMarshaler(baseSocketWithCtxSetIpMulticastLoopbackResponse{})

func (msg *baseSocketWithCtxSetIpMulticastLoopbackResponse) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxSetIpMulticastLoopbackResponse
}

type baseSocketWithCtxGetIpMulticastLoopbackResponse struct {
	_      struct{}                               `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketGetIpMulticastLoopbackResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mbaseSocketWithCtxGetIpMulticastLoopbackResponse = _bindings.CreateLazyMarshaler(baseSocketWithCtxGetIpMulticastLoopbackResponse{})

func (msg *baseSocketWithCtxGetIpMulticastLoopbackResponse) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxGetIpMulticastLoopbackResponse
}

type baseSocketWithCtxAddIpMembershipRequest struct {
	_          struct{}              `fidl:"s" fidl_size_v1:"16" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Membership IpMulticastMembership `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mbaseSocketWithCtxAddIpMembershipRequest = _bindings.CreateLazyMarshaler(baseSocketWithCtxAddIpMembershipRequest{})

func (msg *baseSocketWithCtxAddIpMembershipRequest) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxAddIpMembershipRequest
}

type baseSocketWithCtxAddIpMembershipResponse struct {
	_      struct{}                        `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketAddIpMembershipResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mbaseSocketWithCtxAddIpMembershipResponse = _bindings.CreateLazyMarshaler(baseSocketWithCtxAddIpMembershipResponse{})

func (msg *baseSocketWithCtxAddIpMembershipResponse) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxAddIpMembershipResponse
}

type baseSocketWithCtxDropIpMembershipRequest struct {
	_          struct{}              `fidl:"s" fidl_size_v1:"16" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Membership IpMulticastMembership `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mbaseSocketWithCtxDropIpMembershipRequest = _bindings.CreateLazyMarshaler(baseSocketWithCtxDropIpMembershipRequest{})

func (msg *baseSocketWithCtxDropIpMembershipRequest) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxDropIpMembershipRequest
}

type baseSocketWithCtxDropIpMembershipResponse struct {
	_      struct{}                         `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketDropIpMembershipResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mbaseSocketWithCtxDropIpMembershipResponse = _bindings.CreateLazyMarshaler(baseSocketWithCtxDropIpMembershipResponse{})

func (msg *baseSocketWithCtxDropIpMembershipResponse) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxDropIpMembershipResponse
}

type baseSocketWithCtxAddIpv6MembershipRequest struct {
	_          struct{}                `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"24" fidl_alignment_v2:"8"`
	Membership Ipv6MulticastMembership `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mbaseSocketWithCtxAddIpv6MembershipRequest = _bindings.CreateLazyMarshaler(baseSocketWithCtxAddIpv6MembershipRequest{})

func (msg *baseSocketWithCtxAddIpv6MembershipRequest) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxAddIpv6MembershipRequest
}

type baseSocketWithCtxAddIpv6MembershipResponse struct {
	_      struct{}                          `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketAddIpv6MembershipResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mbaseSocketWithCtxAddIpv6MembershipResponse = _bindings.CreateLazyMarshaler(baseSocketWithCtxAddIpv6MembershipResponse{})

func (msg *baseSocketWithCtxAddIpv6MembershipResponse) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxAddIpv6MembershipResponse
}

type baseSocketWithCtxDropIpv6MembershipRequest struct {
	_          struct{}                `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"24" fidl_alignment_v2:"8"`
	Membership Ipv6MulticastMembership `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mbaseSocketWithCtxDropIpv6MembershipRequest = _bindings.CreateLazyMarshaler(baseSocketWithCtxDropIpv6MembershipRequest{})

func (msg *baseSocketWithCtxDropIpv6MembershipRequest) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxDropIpv6MembershipRequest
}

type baseSocketWithCtxDropIpv6MembershipResponse struct {
	_      struct{}                           `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketDropIpv6MembershipResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mbaseSocketWithCtxDropIpv6MembershipResponse = _bindings.CreateLazyMarshaler(baseSocketWithCtxDropIpv6MembershipResponse{})

func (msg *baseSocketWithCtxDropIpv6MembershipResponse) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxDropIpv6MembershipResponse
}

type baseSocketWithCtxSetIpv6MulticastInterfaceRequest struct {
	_     struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	Value uint64   `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mbaseSocketWithCtxSetIpv6MulticastInterfaceRequest = _bindings.CreateLazyMarshaler(baseSocketWithCtxSetIpv6MulticastInterfaceRequest{})

func (msg *baseSocketWithCtxSetIpv6MulticastInterfaceRequest) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxSetIpv6MulticastInterfaceRequest
}

type baseSocketWithCtxSetIpv6MulticastInterfaceResponse struct {
	_      struct{}                                  `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketSetIpv6MulticastInterfaceResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mbaseSocketWithCtxSetIpv6MulticastInterfaceResponse = _bindings.CreateLazyMarshaler(baseSocketWithCtxSetIpv6MulticastInterfaceResponse{})

func (msg *baseSocketWithCtxSetIpv6MulticastInterfaceResponse) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxSetIpv6MulticastInterfaceResponse
}

type baseSocketWithCtxGetIpv6MulticastInterfaceResponse struct {
	_      struct{}                                  `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketGetIpv6MulticastInterfaceResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mbaseSocketWithCtxGetIpv6MulticastInterfaceResponse = _bindings.CreateLazyMarshaler(baseSocketWithCtxGetIpv6MulticastInterfaceResponse{})

func (msg *baseSocketWithCtxGetIpv6MulticastInterfaceResponse) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxGetIpv6MulticastInterfaceResponse
}

type baseSocketWithCtxSetIpv6MulticastHopsRequest struct {
	_     struct{}      `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Value OptionalUint8 `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mbaseSocketWithCtxSetIpv6MulticastHopsRequest = _bindings.CreateLazyMarshaler(baseSocketWithCtxSetIpv6MulticastHopsRequest{})

func (msg *baseSocketWithCtxSetIpv6MulticastHopsRequest) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxSetIpv6MulticastHopsRequest
}

type baseSocketWithCtxSetIpv6MulticastHopsResponse struct {
	_      struct{}                             `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketSetIpv6MulticastHopsResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mbaseSocketWithCtxSetIpv6MulticastHopsResponse = _bindings.CreateLazyMarshaler(baseSocketWithCtxSetIpv6MulticastHopsResponse{})

func (msg *baseSocketWithCtxSetIpv6MulticastHopsResponse) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxSetIpv6MulticastHopsResponse
}

type baseSocketWithCtxGetIpv6MulticastHopsResponse struct {
	_      struct{}                             `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketGetIpv6MulticastHopsResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mbaseSocketWithCtxGetIpv6MulticastHopsResponse = _bindings.CreateLazyMarshaler(baseSocketWithCtxGetIpv6MulticastHopsResponse{})

func (msg *baseSocketWithCtxGetIpv6MulticastHopsResponse) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxGetIpv6MulticastHopsResponse
}

type baseSocketWithCtxSetIpv6MulticastLoopbackRequest struct {
	_     struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	Value bool     `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mbaseSocketWithCtxSetIpv6MulticastLoopbackRequest = _bindings.CreateLazyMarshaler(baseSocketWithCtxSetIpv6MulticastLoopbackRequest{})

func (msg *baseSocketWithCtxSetIpv6MulticastLoopbackRequest) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxSetIpv6MulticastLoopbackRequest
}

type baseSocketWithCtxSetIpv6MulticastLoopbackResponse struct {
	_      struct{}                                 `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketSetIpv6MulticastLoopbackResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mbaseSocketWithCtxSetIpv6MulticastLoopbackResponse = _bindings.CreateLazyMarshaler(baseSocketWithCtxSetIpv6MulticastLoopbackResponse{})

func (msg *baseSocketWithCtxSetIpv6MulticastLoopbackResponse) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxSetIpv6MulticastLoopbackResponse
}

type baseSocketWithCtxGetIpv6MulticastLoopbackResponse struct {
	_      struct{}                                 `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketGetIpv6MulticastLoopbackResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mbaseSocketWithCtxGetIpv6MulticastLoopbackResponse = _bindings.CreateLazyMarshaler(baseSocketWithCtxGetIpv6MulticastLoopbackResponse{})

func (msg *baseSocketWithCtxGetIpv6MulticastLoopbackResponse) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxGetIpv6MulticastLoopbackResponse
}

type baseSocketWithCtxSetIpv6OnlyRequest struct {
	_     struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	Value bool     `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mbaseSocketWithCtxSetIpv6OnlyRequest = _bindings.CreateLazyMarshaler(baseSocketWithCtxSetIpv6OnlyRequest{})

func (msg *baseSocketWithCtxSetIpv6OnlyRequest) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxSetIpv6OnlyRequest
}

type baseSocketWithCtxSetIpv6OnlyResponse struct {
	_      struct{}                    `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketSetIpv6OnlyResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mbaseSocketWithCtxSetIpv6OnlyResponse = _bindings.CreateLazyMarshaler(baseSocketWithCtxSetIpv6OnlyResponse{})

func (msg *baseSocketWithCtxSetIpv6OnlyResponse) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxSetIpv6OnlyResponse
}

type baseSocketWithCtxGetIpv6OnlyResponse struct {
	_      struct{}                    `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketGetIpv6OnlyResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mbaseSocketWithCtxGetIpv6OnlyResponse = _bindings.CreateLazyMarshaler(baseSocketWithCtxGetIpv6OnlyResponse{})

func (msg *baseSocketWithCtxGetIpv6OnlyResponse) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxGetIpv6OnlyResponse
}

type baseSocketWithCtxSetIpv6ReceiveTrafficClassRequest struct {
	_     struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	Value bool     `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mbaseSocketWithCtxSetIpv6ReceiveTrafficClassRequest = _bindings.CreateLazyMarshaler(baseSocketWithCtxSetIpv6ReceiveTrafficClassRequest{})

func (msg *baseSocketWithCtxSetIpv6ReceiveTrafficClassRequest) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxSetIpv6ReceiveTrafficClassRequest
}

type baseSocketWithCtxSetIpv6ReceiveTrafficClassResponse struct {
	_      struct{}                                   `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketSetIpv6ReceiveTrafficClassResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mbaseSocketWithCtxSetIpv6ReceiveTrafficClassResponse = _bindings.CreateLazyMarshaler(baseSocketWithCtxSetIpv6ReceiveTrafficClassResponse{})

func (msg *baseSocketWithCtxSetIpv6ReceiveTrafficClassResponse) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxSetIpv6ReceiveTrafficClassResponse
}

type baseSocketWithCtxGetIpv6ReceiveTrafficClassResponse struct {
	_      struct{}                                   `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketGetIpv6ReceiveTrafficClassResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mbaseSocketWithCtxGetIpv6ReceiveTrafficClassResponse = _bindings.CreateLazyMarshaler(baseSocketWithCtxGetIpv6ReceiveTrafficClassResponse{})

func (msg *baseSocketWithCtxGetIpv6ReceiveTrafficClassResponse) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxGetIpv6ReceiveTrafficClassResponse
}

type baseSocketWithCtxSetIpv6TrafficClassRequest struct {
	_     struct{}      `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Value OptionalUint8 `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mbaseSocketWithCtxSetIpv6TrafficClassRequest = _bindings.CreateLazyMarshaler(baseSocketWithCtxSetIpv6TrafficClassRequest{})

func (msg *baseSocketWithCtxSetIpv6TrafficClassRequest) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxSetIpv6TrafficClassRequest
}

type baseSocketWithCtxSetIpv6TrafficClassResponse struct {
	_      struct{}                            `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketSetIpv6TrafficClassResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mbaseSocketWithCtxSetIpv6TrafficClassResponse = _bindings.CreateLazyMarshaler(baseSocketWithCtxSetIpv6TrafficClassResponse{})

func (msg *baseSocketWithCtxSetIpv6TrafficClassResponse) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxSetIpv6TrafficClassResponse
}

type baseSocketWithCtxGetIpv6TrafficClassResponse struct {
	_      struct{}                            `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketGetIpv6TrafficClassResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mbaseSocketWithCtxGetIpv6TrafficClassResponse = _bindings.CreateLazyMarshaler(baseSocketWithCtxGetIpv6TrafficClassResponse{})

func (msg *baseSocketWithCtxGetIpv6TrafficClassResponse) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxGetIpv6TrafficClassResponse
}

type datagramSocketWithCtxCloneRequest struct {
	_      struct{}                              `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	Flags  uint32                                `fidl_offset_v1:"0" fidl_offset_v2:"0"`
	Object fuchsiaio.NodeWithCtxInterfaceRequest `fidl_offset_v1:"4" fidl_offset_v2:"4" fidl_handle_subtype:"4" fidl_bounds:"0"`
}

var _mdatagramSocketWithCtxCloneRequest = _bindings.CreateLazyMarshaler(datagramSocketWithCtxCloneRequest{})

func (msg *datagramSocketWithCtxCloneRequest) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxCloneRequest
}

type datagramSocketWithCtxCloseResponse struct {
	_ struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	S int32    `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxCloseResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxCloseResponse{})

func (msg *datagramSocketWithCtxCloseResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxCloseResponse
}

type datagramSocketWithCtxDescribeResponse struct {
	_    struct{}           `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Info fuchsiaio.NodeInfo `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxDescribeResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxDescribeResponse{})

func (msg *datagramSocketWithCtxDescribeResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxDescribeResponse
}

type datagramSocketWithCtxOnOpenResponse struct {
	_    struct{}            `fidl:"s" fidl_size_v1:"32" fidl_alignment_v1:"8" fidl_size_v2:"24" fidl_alignment_v2:"8"`
	S    int32               `fidl_offset_v1:"0" fidl_offset_v2:"0"`
	Info *fuchsiaio.NodeInfo `fidl_offset_v1:"8" fidl_offset_v2:"8"`
}

var _mdatagramSocketWithCtxOnOpenResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxOnOpenResponse{})

func (msg *datagramSocketWithCtxOnOpenResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxOnOpenResponse
}

type datagramSocketWithCtxSyncResponse struct {
	_ struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	S int32    `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxSyncResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxSyncResponse{})

func (msg *datagramSocketWithCtxSyncResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxSyncResponse
}

type datagramSocketWithCtxGetAttrResponse struct {
	_          struct{}                 `fidl:"s" fidl_size_v1:"64" fidl_alignment_v1:"8" fidl_size_v2:"64" fidl_alignment_v2:"8"`
	S          int32                    `fidl_offset_v1:"0" fidl_offset_v2:"0"`
	Attributes fuchsiaio.NodeAttributes `fidl_offset_v1:"8" fidl_offset_v2:"8"`
}

var _mdatagramSocketWithCtxGetAttrResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxGetAttrResponse{})

func (msg *datagramSocketWithCtxGetAttrResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxGetAttrResponse
}

type datagramSocketWithCtxSetAttrRequest struct {
	_          struct{}                 `fidl:"s" fidl_size_v1:"64" fidl_alignment_v1:"8" fidl_size_v2:"64" fidl_alignment_v2:"8"`
	Flags      uint32                   `fidl_offset_v1:"0" fidl_offset_v2:"0"`
	Attributes fuchsiaio.NodeAttributes `fidl_offset_v1:"8" fidl_offset_v2:"8"`
}

var _mdatagramSocketWithCtxSetAttrRequest = _bindings.CreateLazyMarshaler(datagramSocketWithCtxSetAttrRequest{})

func (msg *datagramSocketWithCtxSetAttrRequest) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxSetAttrRequest
}

type datagramSocketWithCtxSetAttrResponse struct {
	_ struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	S int32    `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxSetAttrResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxSetAttrResponse{})

func (msg *datagramSocketWithCtxSetAttrResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxSetAttrResponse
}

type datagramSocketWithCtxNodeGetFlagsResponse struct {
	_     struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	S     int32    `fidl_offset_v1:"0" fidl_offset_v2:"0"`
	Flags uint32   `fidl_offset_v1:"4" fidl_offset_v2:"4"`
}

var _mdatagramSocketWithCtxNodeGetFlagsResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxNodeGetFlagsResponse{})

func (msg *datagramSocketWithCtxNodeGetFlagsResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxNodeGetFlagsResponse
}

type datagramSocketWithCtxNodeSetFlagsRequest struct {
	_     struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	Flags uint32   `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxNodeSetFlagsRequest = _bindings.CreateLazyMarshaler(datagramSocketWithCtxNodeSetFlagsRequest{})

func (msg *datagramSocketWithCtxNodeSetFlagsRequest) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxNodeSetFlagsRequest
}

type datagramSocketWithCtxNodeSetFlagsResponse struct {
	_ struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	S int32    `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxNodeSetFlagsResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxNodeSetFlagsResponse{})

func (msg *datagramSocketWithCtxNodeSetFlagsResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxNodeSetFlagsResponse
}

type datagramSocketWithCtxBindRequest struct {
	_    struct{}                 `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Addr fuchsianet.SocketAddress `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxBindRequest = _bindings.CreateLazyMarshaler(datagramSocketWithCtxBindRequest{})

func (msg *datagramSocketWithCtxBindRequest) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxBindRequest
}

type datagramSocketWithCtxBindResponse struct {
	_      struct{}             `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketBindResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxBindResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxBindResponse{})

func (msg *datagramSocketWithCtxBindResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxBindResponse
}

type datagramSocketWithCtxConnectRequest struct {
	_    struct{}                 `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Addr fuchsianet.SocketAddress `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxConnectRequest = _bindings.CreateLazyMarshaler(datagramSocketWithCtxConnectRequest{})

func (msg *datagramSocketWithCtxConnectRequest) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxConnectRequest
}

type datagramSocketWithCtxConnectResponse struct {
	_      struct{}                `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketConnectResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxConnectResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxConnectResponse{})

func (msg *datagramSocketWithCtxConnectResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxConnectResponse
}

type datagramSocketWithCtxDisconnectResponse struct {
	_      struct{}                   `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketDisconnectResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxDisconnectResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxDisconnectResponse{})

func (msg *datagramSocketWithCtxDisconnectResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxDisconnectResponse
}

type datagramSocketWithCtxGetSockNameResponse struct {
	_      struct{}                    `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketGetSockNameResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxGetSockNameResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxGetSockNameResponse{})

func (msg *datagramSocketWithCtxGetSockNameResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxGetSockNameResponse
}

type datagramSocketWithCtxGetPeerNameResponse struct {
	_      struct{}                    `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketGetPeerNameResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxGetPeerNameResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxGetPeerNameResponse{})

func (msg *datagramSocketWithCtxGetPeerNameResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxGetPeerNameResponse
}

type datagramSocketWithCtxShutdownRequest struct {
	_    struct{}     `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	Mode ShutdownMode `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxShutdownRequest = _bindings.CreateLazyMarshaler(datagramSocketWithCtxShutdownRequest{})

func (msg *datagramSocketWithCtxShutdownRequest) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxShutdownRequest
}

type datagramSocketWithCtxShutdownResponse struct {
	_      struct{}                 `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketShutdownResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxShutdownResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxShutdownResponse{})

func (msg *datagramSocketWithCtxShutdownResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxShutdownResponse
}

type datagramSocketWithCtxShutdown2Request struct {
	_    struct{}     `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	Mode ShutdownMode `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxShutdown2Request = _bindings.CreateLazyMarshaler(datagramSocketWithCtxShutdown2Request{})

func (msg *datagramSocketWithCtxShutdown2Request) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxShutdown2Request
}

type datagramSocketWithCtxShutdown2Response struct {
	_      struct{}                  `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketShutdown2Result `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxShutdown2Response = _bindings.CreateLazyMarshaler(datagramSocketWithCtxShutdown2Response{})

func (msg *datagramSocketWithCtxShutdown2Response) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxShutdown2Response
}

type datagramSocketWithCtxSetReuseAddressRequest struct {
	_     struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	Value bool     `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxSetReuseAddressRequest = _bindings.CreateLazyMarshaler(datagramSocketWithCtxSetReuseAddressRequest{})

func (msg *datagramSocketWithCtxSetReuseAddressRequest) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxSetReuseAddressRequest
}

type datagramSocketWithCtxSetReuseAddressResponse struct {
	_      struct{}                        `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketSetReuseAddressResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxSetReuseAddressResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxSetReuseAddressResponse{})

func (msg *datagramSocketWithCtxSetReuseAddressResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxSetReuseAddressResponse
}

type datagramSocketWithCtxGetReuseAddressResponse struct {
	_      struct{}                        `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketGetReuseAddressResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxGetReuseAddressResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxGetReuseAddressResponse{})

func (msg *datagramSocketWithCtxGetReuseAddressResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxGetReuseAddressResponse
}

type datagramSocketWithCtxGetErrorResponse struct {
	_      struct{}                 `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketGetErrorResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxGetErrorResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxGetErrorResponse{})

func (msg *datagramSocketWithCtxGetErrorResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxGetErrorResponse
}

type datagramSocketWithCtxSetBroadcastRequest struct {
	_     struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	Value bool     `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxSetBroadcastRequest = _bindings.CreateLazyMarshaler(datagramSocketWithCtxSetBroadcastRequest{})

func (msg *datagramSocketWithCtxSetBroadcastRequest) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxSetBroadcastRequest
}

type datagramSocketWithCtxSetBroadcastResponse struct {
	_      struct{}                     `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketSetBroadcastResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxSetBroadcastResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxSetBroadcastResponse{})

func (msg *datagramSocketWithCtxSetBroadcastResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxSetBroadcastResponse
}

type datagramSocketWithCtxGetBroadcastResponse struct {
	_      struct{}                     `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketGetBroadcastResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxGetBroadcastResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxGetBroadcastResponse{})

func (msg *datagramSocketWithCtxGetBroadcastResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxGetBroadcastResponse
}

type datagramSocketWithCtxSetSendBufferRequest struct {
	_          struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	ValueBytes uint64   `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxSetSendBufferRequest = _bindings.CreateLazyMarshaler(datagramSocketWithCtxSetSendBufferRequest{})

func (msg *datagramSocketWithCtxSetSendBufferRequest) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxSetSendBufferRequest
}

type datagramSocketWithCtxSetSendBufferResponse struct {
	_      struct{}                      `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketSetSendBufferResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxSetSendBufferResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxSetSendBufferResponse{})

func (msg *datagramSocketWithCtxSetSendBufferResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxSetSendBufferResponse
}

type datagramSocketWithCtxGetSendBufferResponse struct {
	_      struct{}                      `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketGetSendBufferResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxGetSendBufferResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxGetSendBufferResponse{})

func (msg *datagramSocketWithCtxGetSendBufferResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxGetSendBufferResponse
}

type datagramSocketWithCtxSetReceiveBufferRequest struct {
	_          struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	ValueBytes uint64   `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxSetReceiveBufferRequest = _bindings.CreateLazyMarshaler(datagramSocketWithCtxSetReceiveBufferRequest{})

func (msg *datagramSocketWithCtxSetReceiveBufferRequest) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxSetReceiveBufferRequest
}

type datagramSocketWithCtxSetReceiveBufferResponse struct {
	_      struct{}                         `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketSetReceiveBufferResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxSetReceiveBufferResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxSetReceiveBufferResponse{})

func (msg *datagramSocketWithCtxSetReceiveBufferResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxSetReceiveBufferResponse
}

type datagramSocketWithCtxGetReceiveBufferResponse struct {
	_      struct{}                         `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketGetReceiveBufferResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxGetReceiveBufferResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxGetReceiveBufferResponse{})

func (msg *datagramSocketWithCtxGetReceiveBufferResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxGetReceiveBufferResponse
}

type datagramSocketWithCtxSetKeepAliveRequest struct {
	_     struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	Value bool     `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxSetKeepAliveRequest = _bindings.CreateLazyMarshaler(datagramSocketWithCtxSetKeepAliveRequest{})

func (msg *datagramSocketWithCtxSetKeepAliveRequest) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxSetKeepAliveRequest
}

type datagramSocketWithCtxSetKeepAliveResponse struct {
	_      struct{}                     `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketSetKeepAliveResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxSetKeepAliveResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxSetKeepAliveResponse{})

func (msg *datagramSocketWithCtxSetKeepAliveResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxSetKeepAliveResponse
}

type datagramSocketWithCtxGetKeepAliveResponse struct {
	_      struct{}                     `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketGetKeepAliveResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxGetKeepAliveResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxGetKeepAliveResponse{})

func (msg *datagramSocketWithCtxGetKeepAliveResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxGetKeepAliveResponse
}

type datagramSocketWithCtxSetOutOfBandInlineRequest struct {
	_     struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	Value bool     `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxSetOutOfBandInlineRequest = _bindings.CreateLazyMarshaler(datagramSocketWithCtxSetOutOfBandInlineRequest{})

func (msg *datagramSocketWithCtxSetOutOfBandInlineRequest) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxSetOutOfBandInlineRequest
}

type datagramSocketWithCtxSetOutOfBandInlineResponse struct {
	_      struct{}                           `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketSetOutOfBandInlineResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxSetOutOfBandInlineResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxSetOutOfBandInlineResponse{})

func (msg *datagramSocketWithCtxSetOutOfBandInlineResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxSetOutOfBandInlineResponse
}

type datagramSocketWithCtxGetOutOfBandInlineResponse struct {
	_      struct{}                           `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketGetOutOfBandInlineResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxGetOutOfBandInlineResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxGetOutOfBandInlineResponse{})

func (msg *datagramSocketWithCtxGetOutOfBandInlineResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxGetOutOfBandInlineResponse
}

type datagramSocketWithCtxSetNoCheckRequest struct {
	_     struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	Value bool     `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxSetNoCheckRequest = _bindings.CreateLazyMarshaler(datagramSocketWithCtxSetNoCheckRequest{})

func (msg *datagramSocketWithCtxSetNoCheckRequest) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxSetNoCheckRequest
}

type datagramSocketWithCtxSetNoCheckResponse struct {
	_      struct{}                   `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketSetNoCheckResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxSetNoCheckResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxSetNoCheckResponse{})

func (msg *datagramSocketWithCtxSetNoCheckResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxSetNoCheckResponse
}

type datagramSocketWithCtxGetNoCheckResponse struct {
	_      struct{}                   `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketGetNoCheckResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxGetNoCheckResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxGetNoCheckResponse{})

func (msg *datagramSocketWithCtxGetNoCheckResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxGetNoCheckResponse
}

type datagramSocketWithCtxSetLingerRequest struct {
	_          struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	Linger     bool     `fidl_offset_v1:"0" fidl_offset_v2:"0"`
	LengthSecs uint32   `fidl_offset_v1:"4" fidl_offset_v2:"4"`
}

var _mdatagramSocketWithCtxSetLingerRequest = _bindings.CreateLazyMarshaler(datagramSocketWithCtxSetLingerRequest{})

func (msg *datagramSocketWithCtxSetLingerRequest) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxSetLingerRequest
}

type datagramSocketWithCtxSetLingerResponse struct {
	_      struct{}                  `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketSetLingerResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxSetLingerResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxSetLingerResponse{})

func (msg *datagramSocketWithCtxSetLingerResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxSetLingerResponse
}

type datagramSocketWithCtxGetLingerResponse struct {
	_      struct{}                  `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketGetLingerResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxGetLingerResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxGetLingerResponse{})

func (msg *datagramSocketWithCtxGetLingerResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxGetLingerResponse
}

type datagramSocketWithCtxSetReusePortRequest struct {
	_     struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	Value bool     `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxSetReusePortRequest = _bindings.CreateLazyMarshaler(datagramSocketWithCtxSetReusePortRequest{})

func (msg *datagramSocketWithCtxSetReusePortRequest) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxSetReusePortRequest
}

type datagramSocketWithCtxSetReusePortResponse struct {
	_      struct{}                     `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketSetReusePortResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxSetReusePortResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxSetReusePortResponse{})

func (msg *datagramSocketWithCtxSetReusePortResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxSetReusePortResponse
}

type datagramSocketWithCtxGetReusePortResponse struct {
	_      struct{}                     `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketGetReusePortResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxGetReusePortResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxGetReusePortResponse{})

func (msg *datagramSocketWithCtxGetReusePortResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxGetReusePortResponse
}

type datagramSocketWithCtxGetAcceptConnResponse struct {
	_      struct{}                      `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketGetAcceptConnResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxGetAcceptConnResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxGetAcceptConnResponse{})

func (msg *datagramSocketWithCtxGetAcceptConnResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxGetAcceptConnResponse
}

type datagramSocketWithCtxSetBindToDeviceRequest struct {
	_     struct{} `fidl:"s" fidl_size_v1:"16" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Value string   `fidl_offset_v1:"0" fidl_offset_v2:"0" fidl_bounds:"15"`
}

var _mdatagramSocketWithCtxSetBindToDeviceRequest = _bindings.CreateLazyMarshaler(datagramSocketWithCtxSetBindToDeviceRequest{})

func (msg *datagramSocketWithCtxSetBindToDeviceRequest) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxSetBindToDeviceRequest
}

type datagramSocketWithCtxSetBindToDeviceResponse struct {
	_      struct{}                        `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketSetBindToDeviceResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxSetBindToDeviceResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxSetBindToDeviceResponse{})

func (msg *datagramSocketWithCtxSetBindToDeviceResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxSetBindToDeviceResponse
}

type datagramSocketWithCtxGetBindToDeviceResponse struct {
	_      struct{}                        `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketGetBindToDeviceResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxGetBindToDeviceResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxGetBindToDeviceResponse{})

func (msg *datagramSocketWithCtxGetBindToDeviceResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxGetBindToDeviceResponse
}

type datagramSocketWithCtxSetTimestampRequest struct {
	_     struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	Value bool     `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxSetTimestampRequest = _bindings.CreateLazyMarshaler(datagramSocketWithCtxSetTimestampRequest{})

func (msg *datagramSocketWithCtxSetTimestampRequest) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxSetTimestampRequest
}

type datagramSocketWithCtxSetTimestampResponse struct {
	_      struct{}                     `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketSetTimestampResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxSetTimestampResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxSetTimestampResponse{})

func (msg *datagramSocketWithCtxSetTimestampResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxSetTimestampResponse
}

type datagramSocketWithCtxGetTimestampResponse struct {
	_      struct{}                     `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketGetTimestampResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxGetTimestampResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxGetTimestampResponse{})

func (msg *datagramSocketWithCtxGetTimestampResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxGetTimestampResponse
}

type datagramSocketWithCtxSetIpTypeOfServiceRequest struct {
	_     struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	Value uint8    `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxSetIpTypeOfServiceRequest = _bindings.CreateLazyMarshaler(datagramSocketWithCtxSetIpTypeOfServiceRequest{})

func (msg *datagramSocketWithCtxSetIpTypeOfServiceRequest) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxSetIpTypeOfServiceRequest
}

type datagramSocketWithCtxSetIpTypeOfServiceResponse struct {
	_      struct{}                           `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketSetIpTypeOfServiceResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxSetIpTypeOfServiceResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxSetIpTypeOfServiceResponse{})

func (msg *datagramSocketWithCtxSetIpTypeOfServiceResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxSetIpTypeOfServiceResponse
}

type datagramSocketWithCtxGetIpTypeOfServiceResponse struct {
	_      struct{}                           `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketGetIpTypeOfServiceResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxGetIpTypeOfServiceResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxGetIpTypeOfServiceResponse{})

func (msg *datagramSocketWithCtxGetIpTypeOfServiceResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxGetIpTypeOfServiceResponse
}

type datagramSocketWithCtxSetIpTtlRequest struct {
	_     struct{}      `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Value OptionalUint8 `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxSetIpTtlRequest = _bindings.CreateLazyMarshaler(datagramSocketWithCtxSetIpTtlRequest{})

func (msg *datagramSocketWithCtxSetIpTtlRequest) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxSetIpTtlRequest
}

type datagramSocketWithCtxSetIpTtlResponse struct {
	_      struct{}                 `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketSetIpTtlResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxSetIpTtlResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxSetIpTtlResponse{})

func (msg *datagramSocketWithCtxSetIpTtlResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxSetIpTtlResponse
}

type datagramSocketWithCtxGetIpTtlResponse struct {
	_      struct{}                 `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketGetIpTtlResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxGetIpTtlResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxGetIpTtlResponse{})

func (msg *datagramSocketWithCtxGetIpTtlResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxGetIpTtlResponse
}

type datagramSocketWithCtxSetIpPacketInfoRequest struct {
	_     struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	Value bool     `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxSetIpPacketInfoRequest = _bindings.CreateLazyMarshaler(datagramSocketWithCtxSetIpPacketInfoRequest{})

func (msg *datagramSocketWithCtxSetIpPacketInfoRequest) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxSetIpPacketInfoRequest
}

type datagramSocketWithCtxSetIpPacketInfoResponse struct {
	_      struct{}                        `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketSetIpPacketInfoResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxSetIpPacketInfoResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxSetIpPacketInfoResponse{})

func (msg *datagramSocketWithCtxSetIpPacketInfoResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxSetIpPacketInfoResponse
}

type datagramSocketWithCtxGetIpPacketInfoResponse struct {
	_      struct{}                        `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketGetIpPacketInfoResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxGetIpPacketInfoResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxGetIpPacketInfoResponse{})

func (msg *datagramSocketWithCtxGetIpPacketInfoResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxGetIpPacketInfoResponse
}

type datagramSocketWithCtxSetIpReceiveTypeOfServiceRequest struct {
	_     struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	Value bool     `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxSetIpReceiveTypeOfServiceRequest = _bindings.CreateLazyMarshaler(datagramSocketWithCtxSetIpReceiveTypeOfServiceRequest{})

func (msg *datagramSocketWithCtxSetIpReceiveTypeOfServiceRequest) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxSetIpReceiveTypeOfServiceRequest
}

type datagramSocketWithCtxSetIpReceiveTypeOfServiceResponse struct {
	_      struct{}                                  `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketSetIpReceiveTypeOfServiceResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxSetIpReceiveTypeOfServiceResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxSetIpReceiveTypeOfServiceResponse{})

func (msg *datagramSocketWithCtxSetIpReceiveTypeOfServiceResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxSetIpReceiveTypeOfServiceResponse
}

type datagramSocketWithCtxGetIpReceiveTypeOfServiceResponse struct {
	_      struct{}                                  `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketGetIpReceiveTypeOfServiceResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxGetIpReceiveTypeOfServiceResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxGetIpReceiveTypeOfServiceResponse{})

func (msg *datagramSocketWithCtxGetIpReceiveTypeOfServiceResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxGetIpReceiveTypeOfServiceResponse
}

type datagramSocketWithCtxSetIpMulticastInterfaceRequest struct {
	_       struct{}               `fidl:"s" fidl_size_v1:"16" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Iface   uint64                 `fidl_offset_v1:"0" fidl_offset_v2:"0"`
	Address fuchsianet.Ipv4Address `fidl_offset_v1:"8" fidl_offset_v2:"8"`
}

var _mdatagramSocketWithCtxSetIpMulticastInterfaceRequest = _bindings.CreateLazyMarshaler(datagramSocketWithCtxSetIpMulticastInterfaceRequest{})

func (msg *datagramSocketWithCtxSetIpMulticastInterfaceRequest) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxSetIpMulticastInterfaceRequest
}

type datagramSocketWithCtxSetIpMulticastInterfaceResponse struct {
	_      struct{}                                `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketSetIpMulticastInterfaceResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxSetIpMulticastInterfaceResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxSetIpMulticastInterfaceResponse{})

func (msg *datagramSocketWithCtxSetIpMulticastInterfaceResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxSetIpMulticastInterfaceResponse
}

type datagramSocketWithCtxGetIpMulticastInterfaceResponse struct {
	_      struct{}                                `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketGetIpMulticastInterfaceResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxGetIpMulticastInterfaceResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxGetIpMulticastInterfaceResponse{})

func (msg *datagramSocketWithCtxGetIpMulticastInterfaceResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxGetIpMulticastInterfaceResponse
}

type datagramSocketWithCtxSetIpMulticastTtlRequest struct {
	_     struct{}      `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Value OptionalUint8 `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxSetIpMulticastTtlRequest = _bindings.CreateLazyMarshaler(datagramSocketWithCtxSetIpMulticastTtlRequest{})

func (msg *datagramSocketWithCtxSetIpMulticastTtlRequest) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxSetIpMulticastTtlRequest
}

type datagramSocketWithCtxSetIpMulticastTtlResponse struct {
	_      struct{}                          `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketSetIpMulticastTtlResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxSetIpMulticastTtlResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxSetIpMulticastTtlResponse{})

func (msg *datagramSocketWithCtxSetIpMulticastTtlResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxSetIpMulticastTtlResponse
}

type datagramSocketWithCtxGetIpMulticastTtlResponse struct {
	_      struct{}                          `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketGetIpMulticastTtlResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxGetIpMulticastTtlResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxGetIpMulticastTtlResponse{})

func (msg *datagramSocketWithCtxGetIpMulticastTtlResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxGetIpMulticastTtlResponse
}

type datagramSocketWithCtxSetIpMulticastLoopbackRequest struct {
	_     struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	Value bool     `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxSetIpMulticastLoopbackRequest = _bindings.CreateLazyMarshaler(datagramSocketWithCtxSetIpMulticastLoopbackRequest{})

func (msg *datagramSocketWithCtxSetIpMulticastLoopbackRequest) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxSetIpMulticastLoopbackRequest
}

type datagramSocketWithCtxSetIpMulticastLoopbackResponse struct {
	_      struct{}                               `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketSetIpMulticastLoopbackResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxSetIpMulticastLoopbackResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxSetIpMulticastLoopbackResponse{})

func (msg *datagramSocketWithCtxSetIpMulticastLoopbackResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxSetIpMulticastLoopbackResponse
}

type datagramSocketWithCtxGetIpMulticastLoopbackResponse struct {
	_      struct{}                               `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketGetIpMulticastLoopbackResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxGetIpMulticastLoopbackResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxGetIpMulticastLoopbackResponse{})

func (msg *datagramSocketWithCtxGetIpMulticastLoopbackResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxGetIpMulticastLoopbackResponse
}

type datagramSocketWithCtxAddIpMembershipRequest struct {
	_          struct{}              `fidl:"s" fidl_size_v1:"16" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Membership IpMulticastMembership `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxAddIpMembershipRequest = _bindings.CreateLazyMarshaler(datagramSocketWithCtxAddIpMembershipRequest{})

func (msg *datagramSocketWithCtxAddIpMembershipRequest) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxAddIpMembershipRequest
}

type datagramSocketWithCtxAddIpMembershipResponse struct {
	_      struct{}                        `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketAddIpMembershipResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxAddIpMembershipResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxAddIpMembershipResponse{})

func (msg *datagramSocketWithCtxAddIpMembershipResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxAddIpMembershipResponse
}

type datagramSocketWithCtxDropIpMembershipRequest struct {
	_          struct{}              `fidl:"s" fidl_size_v1:"16" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Membership IpMulticastMembership `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxDropIpMembershipRequest = _bindings.CreateLazyMarshaler(datagramSocketWithCtxDropIpMembershipRequest{})

func (msg *datagramSocketWithCtxDropIpMembershipRequest) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxDropIpMembershipRequest
}

type datagramSocketWithCtxDropIpMembershipResponse struct {
	_      struct{}                         `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketDropIpMembershipResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxDropIpMembershipResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxDropIpMembershipResponse{})

func (msg *datagramSocketWithCtxDropIpMembershipResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxDropIpMembershipResponse
}

type datagramSocketWithCtxAddIpv6MembershipRequest struct {
	_          struct{}                `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"24" fidl_alignment_v2:"8"`
	Membership Ipv6MulticastMembership `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxAddIpv6MembershipRequest = _bindings.CreateLazyMarshaler(datagramSocketWithCtxAddIpv6MembershipRequest{})

func (msg *datagramSocketWithCtxAddIpv6MembershipRequest) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxAddIpv6MembershipRequest
}

type datagramSocketWithCtxAddIpv6MembershipResponse struct {
	_      struct{}                          `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketAddIpv6MembershipResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxAddIpv6MembershipResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxAddIpv6MembershipResponse{})

func (msg *datagramSocketWithCtxAddIpv6MembershipResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxAddIpv6MembershipResponse
}

type datagramSocketWithCtxDropIpv6MembershipRequest struct {
	_          struct{}                `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"24" fidl_alignment_v2:"8"`
	Membership Ipv6MulticastMembership `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxDropIpv6MembershipRequest = _bindings.CreateLazyMarshaler(datagramSocketWithCtxDropIpv6MembershipRequest{})

func (msg *datagramSocketWithCtxDropIpv6MembershipRequest) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxDropIpv6MembershipRequest
}

type datagramSocketWithCtxDropIpv6MembershipResponse struct {
	_      struct{}                           `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketDropIpv6MembershipResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxDropIpv6MembershipResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxDropIpv6MembershipResponse{})

func (msg *datagramSocketWithCtxDropIpv6MembershipResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxDropIpv6MembershipResponse
}

type datagramSocketWithCtxSetIpv6MulticastInterfaceRequest struct {
	_     struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	Value uint64   `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxSetIpv6MulticastInterfaceRequest = _bindings.CreateLazyMarshaler(datagramSocketWithCtxSetIpv6MulticastInterfaceRequest{})

func (msg *datagramSocketWithCtxSetIpv6MulticastInterfaceRequest) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxSetIpv6MulticastInterfaceRequest
}

type datagramSocketWithCtxSetIpv6MulticastInterfaceResponse struct {
	_      struct{}                                  `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketSetIpv6MulticastInterfaceResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxSetIpv6MulticastInterfaceResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxSetIpv6MulticastInterfaceResponse{})

func (msg *datagramSocketWithCtxSetIpv6MulticastInterfaceResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxSetIpv6MulticastInterfaceResponse
}

type datagramSocketWithCtxGetIpv6MulticastInterfaceResponse struct {
	_      struct{}                                  `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketGetIpv6MulticastInterfaceResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxGetIpv6MulticastInterfaceResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxGetIpv6MulticastInterfaceResponse{})

func (msg *datagramSocketWithCtxGetIpv6MulticastInterfaceResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxGetIpv6MulticastInterfaceResponse
}

type datagramSocketWithCtxSetIpv6MulticastHopsRequest struct {
	_     struct{}      `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Value OptionalUint8 `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxSetIpv6MulticastHopsRequest = _bindings.CreateLazyMarshaler(datagramSocketWithCtxSetIpv6MulticastHopsRequest{})

func (msg *datagramSocketWithCtxSetIpv6MulticastHopsRequest) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxSetIpv6MulticastHopsRequest
}

type datagramSocketWithCtxSetIpv6MulticastHopsResponse struct {
	_      struct{}                             `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketSetIpv6MulticastHopsResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxSetIpv6MulticastHopsResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxSetIpv6MulticastHopsResponse{})

func (msg *datagramSocketWithCtxSetIpv6MulticastHopsResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxSetIpv6MulticastHopsResponse
}

type datagramSocketWithCtxGetIpv6MulticastHopsResponse struct {
	_      struct{}                             `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketGetIpv6MulticastHopsResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxGetIpv6MulticastHopsResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxGetIpv6MulticastHopsResponse{})

func (msg *datagramSocketWithCtxGetIpv6MulticastHopsResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxGetIpv6MulticastHopsResponse
}

type datagramSocketWithCtxSetIpv6MulticastLoopbackRequest struct {
	_     struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	Value bool     `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxSetIpv6MulticastLoopbackRequest = _bindings.CreateLazyMarshaler(datagramSocketWithCtxSetIpv6MulticastLoopbackRequest{})

func (msg *datagramSocketWithCtxSetIpv6MulticastLoopbackRequest) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxSetIpv6MulticastLoopbackRequest
}

type datagramSocketWithCtxSetIpv6MulticastLoopbackResponse struct {
	_      struct{}                                 `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketSetIpv6MulticastLoopbackResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxSetIpv6MulticastLoopbackResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxSetIpv6MulticastLoopbackResponse{})

func (msg *datagramSocketWithCtxSetIpv6MulticastLoopbackResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxSetIpv6MulticastLoopbackResponse
}

type datagramSocketWithCtxGetIpv6MulticastLoopbackResponse struct {
	_      struct{}                                 `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketGetIpv6MulticastLoopbackResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxGetIpv6MulticastLoopbackResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxGetIpv6MulticastLoopbackResponse{})

func (msg *datagramSocketWithCtxGetIpv6MulticastLoopbackResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxGetIpv6MulticastLoopbackResponse
}

type datagramSocketWithCtxSetIpv6OnlyRequest struct {
	_     struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	Value bool     `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxSetIpv6OnlyRequest = _bindings.CreateLazyMarshaler(datagramSocketWithCtxSetIpv6OnlyRequest{})

func (msg *datagramSocketWithCtxSetIpv6OnlyRequest) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxSetIpv6OnlyRequest
}

type datagramSocketWithCtxSetIpv6OnlyResponse struct {
	_      struct{}                    `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketSetIpv6OnlyResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxSetIpv6OnlyResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxSetIpv6OnlyResponse{})

func (msg *datagramSocketWithCtxSetIpv6OnlyResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxSetIpv6OnlyResponse
}

type datagramSocketWithCtxGetIpv6OnlyResponse struct {
	_      struct{}                    `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketGetIpv6OnlyResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxGetIpv6OnlyResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxGetIpv6OnlyResponse{})

func (msg *datagramSocketWithCtxGetIpv6OnlyResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxGetIpv6OnlyResponse
}

type datagramSocketWithCtxSetIpv6ReceiveTrafficClassRequest struct {
	_     struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	Value bool     `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxSetIpv6ReceiveTrafficClassRequest = _bindings.CreateLazyMarshaler(datagramSocketWithCtxSetIpv6ReceiveTrafficClassRequest{})

func (msg *datagramSocketWithCtxSetIpv6ReceiveTrafficClassRequest) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxSetIpv6ReceiveTrafficClassRequest
}

type datagramSocketWithCtxSetIpv6ReceiveTrafficClassResponse struct {
	_      struct{}                                   `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketSetIpv6ReceiveTrafficClassResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxSetIpv6ReceiveTrafficClassResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxSetIpv6ReceiveTrafficClassResponse{})

func (msg *datagramSocketWithCtxSetIpv6ReceiveTrafficClassResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxSetIpv6ReceiveTrafficClassResponse
}

type datagramSocketWithCtxGetIpv6ReceiveTrafficClassResponse struct {
	_      struct{}                                   `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketGetIpv6ReceiveTrafficClassResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxGetIpv6ReceiveTrafficClassResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxGetIpv6ReceiveTrafficClassResponse{})

func (msg *datagramSocketWithCtxGetIpv6ReceiveTrafficClassResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxGetIpv6ReceiveTrafficClassResponse
}

type datagramSocketWithCtxSetIpv6TrafficClassRequest struct {
	_     struct{}      `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Value OptionalUint8 `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxSetIpv6TrafficClassRequest = _bindings.CreateLazyMarshaler(datagramSocketWithCtxSetIpv6TrafficClassRequest{})

func (msg *datagramSocketWithCtxSetIpv6TrafficClassRequest) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxSetIpv6TrafficClassRequest
}

type datagramSocketWithCtxSetIpv6TrafficClassResponse struct {
	_      struct{}                            `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketSetIpv6TrafficClassResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxSetIpv6TrafficClassResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxSetIpv6TrafficClassResponse{})

func (msg *datagramSocketWithCtxSetIpv6TrafficClassResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxSetIpv6TrafficClassResponse
}

type datagramSocketWithCtxGetIpv6TrafficClassResponse struct {
	_      struct{}                            `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketGetIpv6TrafficClassResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxGetIpv6TrafficClassResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxGetIpv6TrafficClassResponse{})

func (msg *datagramSocketWithCtxGetIpv6TrafficClassResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxGetIpv6TrafficClassResponse
}

type datagramSocketWithCtxRecvMsgRequest struct {
	_           struct{}     `fidl:"s" fidl_size_v1:"16" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	WantAddr    bool         `fidl_offset_v1:"0" fidl_offset_v2:"0"`
	DataLen     uint32       `fidl_offset_v1:"4" fidl_offset_v2:"4"`
	WantControl bool         `fidl_offset_v1:"8" fidl_offset_v2:"8"`
	Flags       RecvMsgFlags `fidl_offset_v1:"10" fidl_offset_v2:"10"`
}

var _mdatagramSocketWithCtxRecvMsgRequest = _bindings.CreateLazyMarshaler(datagramSocketWithCtxRecvMsgRequest{})

func (msg *datagramSocketWithCtxRecvMsgRequest) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxRecvMsgRequest
}

type datagramSocketWithCtxRecvMsgResponse struct {
	_      struct{}                    `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result DatagramSocketRecvMsgResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxRecvMsgResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxRecvMsgResponse{})

func (msg *datagramSocketWithCtxRecvMsgResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxRecvMsgResponse
}

type datagramSocketWithCtxSendMsgRequest struct {
	_       struct{}                  `fidl:"s" fidl_size_v1:"64" fidl_alignment_v1:"8" fidl_size_v2:"56" fidl_alignment_v2:"8"`
	Addr    *fuchsianet.SocketAddress `fidl_offset_v1:"0" fidl_offset_v2:"0"`
	Data    []uint8                   `fidl_offset_v1:"24" fidl_offset_v2:"16" fidl_bounds:""`
	Control SendControlData           `fidl_offset_v1:"40" fidl_offset_v2:"32"`
	Flags   SendMsgFlags              `fidl_offset_v1:"56" fidl_offset_v2:"48"`
}

var _mdatagramSocketWithCtxSendMsgRequest = _bindings.CreateLazyMarshaler(datagramSocketWithCtxSendMsgRequest{})

func (msg *datagramSocketWithCtxSendMsgRequest) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxSendMsgRequest
}

type datagramSocketWithCtxSendMsgResponse struct {
	_      struct{}                    `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result DatagramSocketSendMsgResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxSendMsgResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxSendMsgResponse{})

func (msg *datagramSocketWithCtxSendMsgResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxSendMsgResponse
}

type datagramSocketWithCtxGetInfoResponse struct {
	_      struct{}                    `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result DatagramSocketGetInfoResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxGetInfoResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxGetInfoResponse{})

func (msg *datagramSocketWithCtxGetInfoResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxGetInfoResponse
}

type streamSocketWithCtxCloneRequest struct {
	_      struct{}                              `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	Flags  uint32                                `fidl_offset_v1:"0" fidl_offset_v2:"0"`
	Object fuchsiaio.NodeWithCtxInterfaceRequest `fidl_offset_v1:"4" fidl_offset_v2:"4" fidl_handle_subtype:"4" fidl_bounds:"0"`
}

var _mstreamSocketWithCtxCloneRequest = _bindings.CreateLazyMarshaler(streamSocketWithCtxCloneRequest{})

func (msg *streamSocketWithCtxCloneRequest) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxCloneRequest
}

type streamSocketWithCtxCloseResponse struct {
	_ struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	S int32    `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxCloseResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxCloseResponse{})

func (msg *streamSocketWithCtxCloseResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxCloseResponse
}

type streamSocketWithCtxDescribeResponse struct {
	_    struct{}           `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Info fuchsiaio.NodeInfo `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxDescribeResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxDescribeResponse{})

func (msg *streamSocketWithCtxDescribeResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxDescribeResponse
}

type streamSocketWithCtxOnOpenResponse struct {
	_    struct{}            `fidl:"s" fidl_size_v1:"32" fidl_alignment_v1:"8" fidl_size_v2:"24" fidl_alignment_v2:"8"`
	S    int32               `fidl_offset_v1:"0" fidl_offset_v2:"0"`
	Info *fuchsiaio.NodeInfo `fidl_offset_v1:"8" fidl_offset_v2:"8"`
}

var _mstreamSocketWithCtxOnOpenResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxOnOpenResponse{})

func (msg *streamSocketWithCtxOnOpenResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxOnOpenResponse
}

type streamSocketWithCtxSyncResponse struct {
	_ struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	S int32    `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxSyncResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxSyncResponse{})

func (msg *streamSocketWithCtxSyncResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxSyncResponse
}

type streamSocketWithCtxGetAttrResponse struct {
	_          struct{}                 `fidl:"s" fidl_size_v1:"64" fidl_alignment_v1:"8" fidl_size_v2:"64" fidl_alignment_v2:"8"`
	S          int32                    `fidl_offset_v1:"0" fidl_offset_v2:"0"`
	Attributes fuchsiaio.NodeAttributes `fidl_offset_v1:"8" fidl_offset_v2:"8"`
}

var _mstreamSocketWithCtxGetAttrResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxGetAttrResponse{})

func (msg *streamSocketWithCtxGetAttrResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxGetAttrResponse
}

type streamSocketWithCtxSetAttrRequest struct {
	_          struct{}                 `fidl:"s" fidl_size_v1:"64" fidl_alignment_v1:"8" fidl_size_v2:"64" fidl_alignment_v2:"8"`
	Flags      uint32                   `fidl_offset_v1:"0" fidl_offset_v2:"0"`
	Attributes fuchsiaio.NodeAttributes `fidl_offset_v1:"8" fidl_offset_v2:"8"`
}

var _mstreamSocketWithCtxSetAttrRequest = _bindings.CreateLazyMarshaler(streamSocketWithCtxSetAttrRequest{})

func (msg *streamSocketWithCtxSetAttrRequest) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxSetAttrRequest
}

type streamSocketWithCtxSetAttrResponse struct {
	_ struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	S int32    `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxSetAttrResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxSetAttrResponse{})

func (msg *streamSocketWithCtxSetAttrResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxSetAttrResponse
}

type streamSocketWithCtxNodeGetFlagsResponse struct {
	_     struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	S     int32    `fidl_offset_v1:"0" fidl_offset_v2:"0"`
	Flags uint32   `fidl_offset_v1:"4" fidl_offset_v2:"4"`
}

var _mstreamSocketWithCtxNodeGetFlagsResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxNodeGetFlagsResponse{})

func (msg *streamSocketWithCtxNodeGetFlagsResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxNodeGetFlagsResponse
}

type streamSocketWithCtxNodeSetFlagsRequest struct {
	_     struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	Flags uint32   `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxNodeSetFlagsRequest = _bindings.CreateLazyMarshaler(streamSocketWithCtxNodeSetFlagsRequest{})

func (msg *streamSocketWithCtxNodeSetFlagsRequest) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxNodeSetFlagsRequest
}

type streamSocketWithCtxNodeSetFlagsResponse struct {
	_ struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	S int32    `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxNodeSetFlagsResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxNodeSetFlagsResponse{})

func (msg *streamSocketWithCtxNodeSetFlagsResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxNodeSetFlagsResponse
}

type streamSocketWithCtxBindRequest struct {
	_    struct{}                 `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Addr fuchsianet.SocketAddress `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxBindRequest = _bindings.CreateLazyMarshaler(streamSocketWithCtxBindRequest{})

func (msg *streamSocketWithCtxBindRequest) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxBindRequest
}

type streamSocketWithCtxBindResponse struct {
	_      struct{}             `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketBindResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxBindResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxBindResponse{})

func (msg *streamSocketWithCtxBindResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxBindResponse
}

type streamSocketWithCtxConnectRequest struct {
	_    struct{}                 `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Addr fuchsianet.SocketAddress `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxConnectRequest = _bindings.CreateLazyMarshaler(streamSocketWithCtxConnectRequest{})

func (msg *streamSocketWithCtxConnectRequest) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxConnectRequest
}

type streamSocketWithCtxConnectResponse struct {
	_      struct{}                `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketConnectResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxConnectResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxConnectResponse{})

func (msg *streamSocketWithCtxConnectResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxConnectResponse
}

type streamSocketWithCtxDisconnectResponse struct {
	_      struct{}                   `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketDisconnectResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxDisconnectResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxDisconnectResponse{})

func (msg *streamSocketWithCtxDisconnectResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxDisconnectResponse
}

type streamSocketWithCtxGetSockNameResponse struct {
	_      struct{}                    `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketGetSockNameResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxGetSockNameResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxGetSockNameResponse{})

func (msg *streamSocketWithCtxGetSockNameResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxGetSockNameResponse
}

type streamSocketWithCtxGetPeerNameResponse struct {
	_      struct{}                    `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketGetPeerNameResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxGetPeerNameResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxGetPeerNameResponse{})

func (msg *streamSocketWithCtxGetPeerNameResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxGetPeerNameResponse
}

type streamSocketWithCtxShutdownRequest struct {
	_    struct{}     `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	Mode ShutdownMode `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxShutdownRequest = _bindings.CreateLazyMarshaler(streamSocketWithCtxShutdownRequest{})

func (msg *streamSocketWithCtxShutdownRequest) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxShutdownRequest
}

type streamSocketWithCtxShutdownResponse struct {
	_      struct{}                 `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketShutdownResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxShutdownResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxShutdownResponse{})

func (msg *streamSocketWithCtxShutdownResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxShutdownResponse
}

type streamSocketWithCtxShutdown2Request struct {
	_    struct{}     `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	Mode ShutdownMode `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxShutdown2Request = _bindings.CreateLazyMarshaler(streamSocketWithCtxShutdown2Request{})

func (msg *streamSocketWithCtxShutdown2Request) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxShutdown2Request
}

type streamSocketWithCtxShutdown2Response struct {
	_      struct{}                  `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketShutdown2Result `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxShutdown2Response = _bindings.CreateLazyMarshaler(streamSocketWithCtxShutdown2Response{})

func (msg *streamSocketWithCtxShutdown2Response) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxShutdown2Response
}

type streamSocketWithCtxSetReuseAddressRequest struct {
	_     struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	Value bool     `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxSetReuseAddressRequest = _bindings.CreateLazyMarshaler(streamSocketWithCtxSetReuseAddressRequest{})

func (msg *streamSocketWithCtxSetReuseAddressRequest) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxSetReuseAddressRequest
}

type streamSocketWithCtxSetReuseAddressResponse struct {
	_      struct{}                        `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketSetReuseAddressResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxSetReuseAddressResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxSetReuseAddressResponse{})

func (msg *streamSocketWithCtxSetReuseAddressResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxSetReuseAddressResponse
}

type streamSocketWithCtxGetReuseAddressResponse struct {
	_      struct{}                        `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketGetReuseAddressResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxGetReuseAddressResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxGetReuseAddressResponse{})

func (msg *streamSocketWithCtxGetReuseAddressResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxGetReuseAddressResponse
}

type streamSocketWithCtxGetErrorResponse struct {
	_      struct{}                 `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketGetErrorResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxGetErrorResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxGetErrorResponse{})

func (msg *streamSocketWithCtxGetErrorResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxGetErrorResponse
}

type streamSocketWithCtxSetBroadcastRequest struct {
	_     struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	Value bool     `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxSetBroadcastRequest = _bindings.CreateLazyMarshaler(streamSocketWithCtxSetBroadcastRequest{})

func (msg *streamSocketWithCtxSetBroadcastRequest) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxSetBroadcastRequest
}

type streamSocketWithCtxSetBroadcastResponse struct {
	_      struct{}                     `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketSetBroadcastResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxSetBroadcastResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxSetBroadcastResponse{})

func (msg *streamSocketWithCtxSetBroadcastResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxSetBroadcastResponse
}

type streamSocketWithCtxGetBroadcastResponse struct {
	_      struct{}                     `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketGetBroadcastResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxGetBroadcastResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxGetBroadcastResponse{})

func (msg *streamSocketWithCtxGetBroadcastResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxGetBroadcastResponse
}

type streamSocketWithCtxSetSendBufferRequest struct {
	_          struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	ValueBytes uint64   `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxSetSendBufferRequest = _bindings.CreateLazyMarshaler(streamSocketWithCtxSetSendBufferRequest{})

func (msg *streamSocketWithCtxSetSendBufferRequest) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxSetSendBufferRequest
}

type streamSocketWithCtxSetSendBufferResponse struct {
	_      struct{}                      `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketSetSendBufferResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxSetSendBufferResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxSetSendBufferResponse{})

func (msg *streamSocketWithCtxSetSendBufferResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxSetSendBufferResponse
}

type streamSocketWithCtxGetSendBufferResponse struct {
	_      struct{}                      `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketGetSendBufferResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxGetSendBufferResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxGetSendBufferResponse{})

func (msg *streamSocketWithCtxGetSendBufferResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxGetSendBufferResponse
}

type streamSocketWithCtxSetReceiveBufferRequest struct {
	_          struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	ValueBytes uint64   `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxSetReceiveBufferRequest = _bindings.CreateLazyMarshaler(streamSocketWithCtxSetReceiveBufferRequest{})

func (msg *streamSocketWithCtxSetReceiveBufferRequest) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxSetReceiveBufferRequest
}

type streamSocketWithCtxSetReceiveBufferResponse struct {
	_      struct{}                         `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketSetReceiveBufferResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxSetReceiveBufferResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxSetReceiveBufferResponse{})

func (msg *streamSocketWithCtxSetReceiveBufferResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxSetReceiveBufferResponse
}

type streamSocketWithCtxGetReceiveBufferResponse struct {
	_      struct{}                         `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketGetReceiveBufferResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxGetReceiveBufferResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxGetReceiveBufferResponse{})

func (msg *streamSocketWithCtxGetReceiveBufferResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxGetReceiveBufferResponse
}

type streamSocketWithCtxSetKeepAliveRequest struct {
	_     struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	Value bool     `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxSetKeepAliveRequest = _bindings.CreateLazyMarshaler(streamSocketWithCtxSetKeepAliveRequest{})

func (msg *streamSocketWithCtxSetKeepAliveRequest) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxSetKeepAliveRequest
}

type streamSocketWithCtxSetKeepAliveResponse struct {
	_      struct{}                     `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketSetKeepAliveResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxSetKeepAliveResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxSetKeepAliveResponse{})

func (msg *streamSocketWithCtxSetKeepAliveResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxSetKeepAliveResponse
}

type streamSocketWithCtxGetKeepAliveResponse struct {
	_      struct{}                     `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketGetKeepAliveResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxGetKeepAliveResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxGetKeepAliveResponse{})

func (msg *streamSocketWithCtxGetKeepAliveResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxGetKeepAliveResponse
}

type streamSocketWithCtxSetOutOfBandInlineRequest struct {
	_     struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	Value bool     `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxSetOutOfBandInlineRequest = _bindings.CreateLazyMarshaler(streamSocketWithCtxSetOutOfBandInlineRequest{})

func (msg *streamSocketWithCtxSetOutOfBandInlineRequest) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxSetOutOfBandInlineRequest
}

type streamSocketWithCtxSetOutOfBandInlineResponse struct {
	_      struct{}                           `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketSetOutOfBandInlineResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxSetOutOfBandInlineResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxSetOutOfBandInlineResponse{})

func (msg *streamSocketWithCtxSetOutOfBandInlineResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxSetOutOfBandInlineResponse
}

type streamSocketWithCtxGetOutOfBandInlineResponse struct {
	_      struct{}                           `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketGetOutOfBandInlineResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxGetOutOfBandInlineResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxGetOutOfBandInlineResponse{})

func (msg *streamSocketWithCtxGetOutOfBandInlineResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxGetOutOfBandInlineResponse
}

type streamSocketWithCtxSetNoCheckRequest struct {
	_     struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	Value bool     `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxSetNoCheckRequest = _bindings.CreateLazyMarshaler(streamSocketWithCtxSetNoCheckRequest{})

func (msg *streamSocketWithCtxSetNoCheckRequest) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxSetNoCheckRequest
}

type streamSocketWithCtxSetNoCheckResponse struct {
	_      struct{}                   `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketSetNoCheckResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxSetNoCheckResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxSetNoCheckResponse{})

func (msg *streamSocketWithCtxSetNoCheckResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxSetNoCheckResponse
}

type streamSocketWithCtxGetNoCheckResponse struct {
	_      struct{}                   `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketGetNoCheckResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxGetNoCheckResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxGetNoCheckResponse{})

func (msg *streamSocketWithCtxGetNoCheckResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxGetNoCheckResponse
}

type streamSocketWithCtxSetLingerRequest struct {
	_          struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	Linger     bool     `fidl_offset_v1:"0" fidl_offset_v2:"0"`
	LengthSecs uint32   `fidl_offset_v1:"4" fidl_offset_v2:"4"`
}

var _mstreamSocketWithCtxSetLingerRequest = _bindings.CreateLazyMarshaler(streamSocketWithCtxSetLingerRequest{})

func (msg *streamSocketWithCtxSetLingerRequest) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxSetLingerRequest
}

type streamSocketWithCtxSetLingerResponse struct {
	_      struct{}                  `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketSetLingerResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxSetLingerResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxSetLingerResponse{})

func (msg *streamSocketWithCtxSetLingerResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxSetLingerResponse
}

type streamSocketWithCtxGetLingerResponse struct {
	_      struct{}                  `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketGetLingerResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxGetLingerResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxGetLingerResponse{})

func (msg *streamSocketWithCtxGetLingerResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxGetLingerResponse
}

type streamSocketWithCtxSetReusePortRequest struct {
	_     struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	Value bool     `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxSetReusePortRequest = _bindings.CreateLazyMarshaler(streamSocketWithCtxSetReusePortRequest{})

func (msg *streamSocketWithCtxSetReusePortRequest) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxSetReusePortRequest
}

type streamSocketWithCtxSetReusePortResponse struct {
	_      struct{}                     `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketSetReusePortResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxSetReusePortResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxSetReusePortResponse{})

func (msg *streamSocketWithCtxSetReusePortResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxSetReusePortResponse
}

type streamSocketWithCtxGetReusePortResponse struct {
	_      struct{}                     `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketGetReusePortResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxGetReusePortResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxGetReusePortResponse{})

func (msg *streamSocketWithCtxGetReusePortResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxGetReusePortResponse
}

type streamSocketWithCtxGetAcceptConnResponse struct {
	_      struct{}                      `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketGetAcceptConnResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxGetAcceptConnResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxGetAcceptConnResponse{})

func (msg *streamSocketWithCtxGetAcceptConnResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxGetAcceptConnResponse
}

type streamSocketWithCtxSetBindToDeviceRequest struct {
	_     struct{} `fidl:"s" fidl_size_v1:"16" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Value string   `fidl_offset_v1:"0" fidl_offset_v2:"0" fidl_bounds:"15"`
}

var _mstreamSocketWithCtxSetBindToDeviceRequest = _bindings.CreateLazyMarshaler(streamSocketWithCtxSetBindToDeviceRequest{})

func (msg *streamSocketWithCtxSetBindToDeviceRequest) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxSetBindToDeviceRequest
}

type streamSocketWithCtxSetBindToDeviceResponse struct {
	_      struct{}                        `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketSetBindToDeviceResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxSetBindToDeviceResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxSetBindToDeviceResponse{})

func (msg *streamSocketWithCtxSetBindToDeviceResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxSetBindToDeviceResponse
}

type streamSocketWithCtxGetBindToDeviceResponse struct {
	_      struct{}                        `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketGetBindToDeviceResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxGetBindToDeviceResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxGetBindToDeviceResponse{})

func (msg *streamSocketWithCtxGetBindToDeviceResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxGetBindToDeviceResponse
}

type streamSocketWithCtxSetTimestampRequest struct {
	_     struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	Value bool     `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxSetTimestampRequest = _bindings.CreateLazyMarshaler(streamSocketWithCtxSetTimestampRequest{})

func (msg *streamSocketWithCtxSetTimestampRequest) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxSetTimestampRequest
}

type streamSocketWithCtxSetTimestampResponse struct {
	_      struct{}                     `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketSetTimestampResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxSetTimestampResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxSetTimestampResponse{})

func (msg *streamSocketWithCtxSetTimestampResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxSetTimestampResponse
}

type streamSocketWithCtxGetTimestampResponse struct {
	_      struct{}                     `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketGetTimestampResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxGetTimestampResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxGetTimestampResponse{})

func (msg *streamSocketWithCtxGetTimestampResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxGetTimestampResponse
}

type streamSocketWithCtxSetIpTypeOfServiceRequest struct {
	_     struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	Value uint8    `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxSetIpTypeOfServiceRequest = _bindings.CreateLazyMarshaler(streamSocketWithCtxSetIpTypeOfServiceRequest{})

func (msg *streamSocketWithCtxSetIpTypeOfServiceRequest) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxSetIpTypeOfServiceRequest
}

type streamSocketWithCtxSetIpTypeOfServiceResponse struct {
	_      struct{}                           `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketSetIpTypeOfServiceResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxSetIpTypeOfServiceResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxSetIpTypeOfServiceResponse{})

func (msg *streamSocketWithCtxSetIpTypeOfServiceResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxSetIpTypeOfServiceResponse
}

type streamSocketWithCtxGetIpTypeOfServiceResponse struct {
	_      struct{}                           `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketGetIpTypeOfServiceResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxGetIpTypeOfServiceResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxGetIpTypeOfServiceResponse{})

func (msg *streamSocketWithCtxGetIpTypeOfServiceResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxGetIpTypeOfServiceResponse
}

type streamSocketWithCtxSetIpTtlRequest struct {
	_     struct{}      `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Value OptionalUint8 `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxSetIpTtlRequest = _bindings.CreateLazyMarshaler(streamSocketWithCtxSetIpTtlRequest{})

func (msg *streamSocketWithCtxSetIpTtlRequest) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxSetIpTtlRequest
}

type streamSocketWithCtxSetIpTtlResponse struct {
	_      struct{}                 `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketSetIpTtlResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxSetIpTtlResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxSetIpTtlResponse{})

func (msg *streamSocketWithCtxSetIpTtlResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxSetIpTtlResponse
}

type streamSocketWithCtxGetIpTtlResponse struct {
	_      struct{}                 `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketGetIpTtlResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxGetIpTtlResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxGetIpTtlResponse{})

func (msg *streamSocketWithCtxGetIpTtlResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxGetIpTtlResponse
}

type streamSocketWithCtxSetIpPacketInfoRequest struct {
	_     struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	Value bool     `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxSetIpPacketInfoRequest = _bindings.CreateLazyMarshaler(streamSocketWithCtxSetIpPacketInfoRequest{})

func (msg *streamSocketWithCtxSetIpPacketInfoRequest) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxSetIpPacketInfoRequest
}

type streamSocketWithCtxSetIpPacketInfoResponse struct {
	_      struct{}                        `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketSetIpPacketInfoResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxSetIpPacketInfoResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxSetIpPacketInfoResponse{})

func (msg *streamSocketWithCtxSetIpPacketInfoResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxSetIpPacketInfoResponse
}

type streamSocketWithCtxGetIpPacketInfoResponse struct {
	_      struct{}                        `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketGetIpPacketInfoResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxGetIpPacketInfoResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxGetIpPacketInfoResponse{})

func (msg *streamSocketWithCtxGetIpPacketInfoResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxGetIpPacketInfoResponse
}

type streamSocketWithCtxSetIpReceiveTypeOfServiceRequest struct {
	_     struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	Value bool     `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxSetIpReceiveTypeOfServiceRequest = _bindings.CreateLazyMarshaler(streamSocketWithCtxSetIpReceiveTypeOfServiceRequest{})

func (msg *streamSocketWithCtxSetIpReceiveTypeOfServiceRequest) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxSetIpReceiveTypeOfServiceRequest
}

type streamSocketWithCtxSetIpReceiveTypeOfServiceResponse struct {
	_      struct{}                                  `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketSetIpReceiveTypeOfServiceResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxSetIpReceiveTypeOfServiceResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxSetIpReceiveTypeOfServiceResponse{})

func (msg *streamSocketWithCtxSetIpReceiveTypeOfServiceResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxSetIpReceiveTypeOfServiceResponse
}

type streamSocketWithCtxGetIpReceiveTypeOfServiceResponse struct {
	_      struct{}                                  `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketGetIpReceiveTypeOfServiceResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxGetIpReceiveTypeOfServiceResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxGetIpReceiveTypeOfServiceResponse{})

func (msg *streamSocketWithCtxGetIpReceiveTypeOfServiceResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxGetIpReceiveTypeOfServiceResponse
}

type streamSocketWithCtxSetIpMulticastInterfaceRequest struct {
	_       struct{}               `fidl:"s" fidl_size_v1:"16" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Iface   uint64                 `fidl_offset_v1:"0" fidl_offset_v2:"0"`
	Address fuchsianet.Ipv4Address `fidl_offset_v1:"8" fidl_offset_v2:"8"`
}

var _mstreamSocketWithCtxSetIpMulticastInterfaceRequest = _bindings.CreateLazyMarshaler(streamSocketWithCtxSetIpMulticastInterfaceRequest{})

func (msg *streamSocketWithCtxSetIpMulticastInterfaceRequest) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxSetIpMulticastInterfaceRequest
}

type streamSocketWithCtxSetIpMulticastInterfaceResponse struct {
	_      struct{}                                `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketSetIpMulticastInterfaceResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxSetIpMulticastInterfaceResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxSetIpMulticastInterfaceResponse{})

func (msg *streamSocketWithCtxSetIpMulticastInterfaceResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxSetIpMulticastInterfaceResponse
}

type streamSocketWithCtxGetIpMulticastInterfaceResponse struct {
	_      struct{}                                `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketGetIpMulticastInterfaceResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxGetIpMulticastInterfaceResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxGetIpMulticastInterfaceResponse{})

func (msg *streamSocketWithCtxGetIpMulticastInterfaceResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxGetIpMulticastInterfaceResponse
}

type streamSocketWithCtxSetIpMulticastTtlRequest struct {
	_     struct{}      `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Value OptionalUint8 `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxSetIpMulticastTtlRequest = _bindings.CreateLazyMarshaler(streamSocketWithCtxSetIpMulticastTtlRequest{})

func (msg *streamSocketWithCtxSetIpMulticastTtlRequest) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxSetIpMulticastTtlRequest
}

type streamSocketWithCtxSetIpMulticastTtlResponse struct {
	_      struct{}                          `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketSetIpMulticastTtlResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxSetIpMulticastTtlResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxSetIpMulticastTtlResponse{})

func (msg *streamSocketWithCtxSetIpMulticastTtlResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxSetIpMulticastTtlResponse
}

type streamSocketWithCtxGetIpMulticastTtlResponse struct {
	_      struct{}                          `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketGetIpMulticastTtlResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxGetIpMulticastTtlResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxGetIpMulticastTtlResponse{})

func (msg *streamSocketWithCtxGetIpMulticastTtlResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxGetIpMulticastTtlResponse
}

type streamSocketWithCtxSetIpMulticastLoopbackRequest struct {
	_     struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	Value bool     `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxSetIpMulticastLoopbackRequest = _bindings.CreateLazyMarshaler(streamSocketWithCtxSetIpMulticastLoopbackRequest{})

func (msg *streamSocketWithCtxSetIpMulticastLoopbackRequest) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxSetIpMulticastLoopbackRequest
}

type streamSocketWithCtxSetIpMulticastLoopbackResponse struct {
	_      struct{}                               `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketSetIpMulticastLoopbackResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxSetIpMulticastLoopbackResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxSetIpMulticastLoopbackResponse{})

func (msg *streamSocketWithCtxSetIpMulticastLoopbackResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxSetIpMulticastLoopbackResponse
}

type streamSocketWithCtxGetIpMulticastLoopbackResponse struct {
	_      struct{}                               `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketGetIpMulticastLoopbackResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxGetIpMulticastLoopbackResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxGetIpMulticastLoopbackResponse{})

func (msg *streamSocketWithCtxGetIpMulticastLoopbackResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxGetIpMulticastLoopbackResponse
}

type streamSocketWithCtxAddIpMembershipRequest struct {
	_          struct{}              `fidl:"s" fidl_size_v1:"16" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Membership IpMulticastMembership `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxAddIpMembershipRequest = _bindings.CreateLazyMarshaler(streamSocketWithCtxAddIpMembershipRequest{})

func (msg *streamSocketWithCtxAddIpMembershipRequest) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxAddIpMembershipRequest
}

type streamSocketWithCtxAddIpMembershipResponse struct {
	_      struct{}                        `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketAddIpMembershipResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxAddIpMembershipResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxAddIpMembershipResponse{})

func (msg *streamSocketWithCtxAddIpMembershipResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxAddIpMembershipResponse
}

type streamSocketWithCtxDropIpMembershipRequest struct {
	_          struct{}              `fidl:"s" fidl_size_v1:"16" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Membership IpMulticastMembership `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxDropIpMembershipRequest = _bindings.CreateLazyMarshaler(streamSocketWithCtxDropIpMembershipRequest{})

func (msg *streamSocketWithCtxDropIpMembershipRequest) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxDropIpMembershipRequest
}

type streamSocketWithCtxDropIpMembershipResponse struct {
	_      struct{}                         `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketDropIpMembershipResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxDropIpMembershipResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxDropIpMembershipResponse{})

func (msg *streamSocketWithCtxDropIpMembershipResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxDropIpMembershipResponse
}

type streamSocketWithCtxAddIpv6MembershipRequest struct {
	_          struct{}                `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"24" fidl_alignment_v2:"8"`
	Membership Ipv6MulticastMembership `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxAddIpv6MembershipRequest = _bindings.CreateLazyMarshaler(streamSocketWithCtxAddIpv6MembershipRequest{})

func (msg *streamSocketWithCtxAddIpv6MembershipRequest) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxAddIpv6MembershipRequest
}

type streamSocketWithCtxAddIpv6MembershipResponse struct {
	_      struct{}                          `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketAddIpv6MembershipResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxAddIpv6MembershipResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxAddIpv6MembershipResponse{})

func (msg *streamSocketWithCtxAddIpv6MembershipResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxAddIpv6MembershipResponse
}

type streamSocketWithCtxDropIpv6MembershipRequest struct {
	_          struct{}                `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"24" fidl_alignment_v2:"8"`
	Membership Ipv6MulticastMembership `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxDropIpv6MembershipRequest = _bindings.CreateLazyMarshaler(streamSocketWithCtxDropIpv6MembershipRequest{})

func (msg *streamSocketWithCtxDropIpv6MembershipRequest) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxDropIpv6MembershipRequest
}

type streamSocketWithCtxDropIpv6MembershipResponse struct {
	_      struct{}                           `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketDropIpv6MembershipResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxDropIpv6MembershipResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxDropIpv6MembershipResponse{})

func (msg *streamSocketWithCtxDropIpv6MembershipResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxDropIpv6MembershipResponse
}

type streamSocketWithCtxSetIpv6MulticastInterfaceRequest struct {
	_     struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	Value uint64   `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxSetIpv6MulticastInterfaceRequest = _bindings.CreateLazyMarshaler(streamSocketWithCtxSetIpv6MulticastInterfaceRequest{})

func (msg *streamSocketWithCtxSetIpv6MulticastInterfaceRequest) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxSetIpv6MulticastInterfaceRequest
}

type streamSocketWithCtxSetIpv6MulticastInterfaceResponse struct {
	_      struct{}                                  `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketSetIpv6MulticastInterfaceResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxSetIpv6MulticastInterfaceResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxSetIpv6MulticastInterfaceResponse{})

func (msg *streamSocketWithCtxSetIpv6MulticastInterfaceResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxSetIpv6MulticastInterfaceResponse
}

type streamSocketWithCtxGetIpv6MulticastInterfaceResponse struct {
	_      struct{}                                  `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketGetIpv6MulticastInterfaceResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxGetIpv6MulticastInterfaceResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxGetIpv6MulticastInterfaceResponse{})

func (msg *streamSocketWithCtxGetIpv6MulticastInterfaceResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxGetIpv6MulticastInterfaceResponse
}

type streamSocketWithCtxSetIpv6MulticastHopsRequest struct {
	_     struct{}      `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Value OptionalUint8 `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxSetIpv6MulticastHopsRequest = _bindings.CreateLazyMarshaler(streamSocketWithCtxSetIpv6MulticastHopsRequest{})

func (msg *streamSocketWithCtxSetIpv6MulticastHopsRequest) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxSetIpv6MulticastHopsRequest
}

type streamSocketWithCtxSetIpv6MulticastHopsResponse struct {
	_      struct{}                             `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketSetIpv6MulticastHopsResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxSetIpv6MulticastHopsResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxSetIpv6MulticastHopsResponse{})

func (msg *streamSocketWithCtxSetIpv6MulticastHopsResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxSetIpv6MulticastHopsResponse
}

type streamSocketWithCtxGetIpv6MulticastHopsResponse struct {
	_      struct{}                             `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketGetIpv6MulticastHopsResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxGetIpv6MulticastHopsResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxGetIpv6MulticastHopsResponse{})

func (msg *streamSocketWithCtxGetIpv6MulticastHopsResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxGetIpv6MulticastHopsResponse
}

type streamSocketWithCtxSetIpv6MulticastLoopbackRequest struct {
	_     struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	Value bool     `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxSetIpv6MulticastLoopbackRequest = _bindings.CreateLazyMarshaler(streamSocketWithCtxSetIpv6MulticastLoopbackRequest{})

func (msg *streamSocketWithCtxSetIpv6MulticastLoopbackRequest) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxSetIpv6MulticastLoopbackRequest
}

type streamSocketWithCtxSetIpv6MulticastLoopbackResponse struct {
	_      struct{}                                 `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketSetIpv6MulticastLoopbackResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxSetIpv6MulticastLoopbackResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxSetIpv6MulticastLoopbackResponse{})

func (msg *streamSocketWithCtxSetIpv6MulticastLoopbackResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxSetIpv6MulticastLoopbackResponse
}

type streamSocketWithCtxGetIpv6MulticastLoopbackResponse struct {
	_      struct{}                                 `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketGetIpv6MulticastLoopbackResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxGetIpv6MulticastLoopbackResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxGetIpv6MulticastLoopbackResponse{})

func (msg *streamSocketWithCtxGetIpv6MulticastLoopbackResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxGetIpv6MulticastLoopbackResponse
}

type streamSocketWithCtxSetIpv6OnlyRequest struct {
	_     struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	Value bool     `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxSetIpv6OnlyRequest = _bindings.CreateLazyMarshaler(streamSocketWithCtxSetIpv6OnlyRequest{})

func (msg *streamSocketWithCtxSetIpv6OnlyRequest) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxSetIpv6OnlyRequest
}

type streamSocketWithCtxSetIpv6OnlyResponse struct {
	_      struct{}                    `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketSetIpv6OnlyResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxSetIpv6OnlyResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxSetIpv6OnlyResponse{})

func (msg *streamSocketWithCtxSetIpv6OnlyResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxSetIpv6OnlyResponse
}

type streamSocketWithCtxGetIpv6OnlyResponse struct {
	_      struct{}                    `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketGetIpv6OnlyResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxGetIpv6OnlyResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxGetIpv6OnlyResponse{})

func (msg *streamSocketWithCtxGetIpv6OnlyResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxGetIpv6OnlyResponse
}

type streamSocketWithCtxSetIpv6ReceiveTrafficClassRequest struct {
	_     struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	Value bool     `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxSetIpv6ReceiveTrafficClassRequest = _bindings.CreateLazyMarshaler(streamSocketWithCtxSetIpv6ReceiveTrafficClassRequest{})

func (msg *streamSocketWithCtxSetIpv6ReceiveTrafficClassRequest) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxSetIpv6ReceiveTrafficClassRequest
}

type streamSocketWithCtxSetIpv6ReceiveTrafficClassResponse struct {
	_      struct{}                                   `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketSetIpv6ReceiveTrafficClassResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxSetIpv6ReceiveTrafficClassResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxSetIpv6ReceiveTrafficClassResponse{})

func (msg *streamSocketWithCtxSetIpv6ReceiveTrafficClassResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxSetIpv6ReceiveTrafficClassResponse
}

type streamSocketWithCtxGetIpv6ReceiveTrafficClassResponse struct {
	_      struct{}                                   `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketGetIpv6ReceiveTrafficClassResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxGetIpv6ReceiveTrafficClassResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxGetIpv6ReceiveTrafficClassResponse{})

func (msg *streamSocketWithCtxGetIpv6ReceiveTrafficClassResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxGetIpv6ReceiveTrafficClassResponse
}

type streamSocketWithCtxSetIpv6TrafficClassRequest struct {
	_     struct{}      `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Value OptionalUint8 `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxSetIpv6TrafficClassRequest = _bindings.CreateLazyMarshaler(streamSocketWithCtxSetIpv6TrafficClassRequest{})

func (msg *streamSocketWithCtxSetIpv6TrafficClassRequest) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxSetIpv6TrafficClassRequest
}

type streamSocketWithCtxSetIpv6TrafficClassResponse struct {
	_      struct{}                            `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketSetIpv6TrafficClassResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxSetIpv6TrafficClassResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxSetIpv6TrafficClassResponse{})

func (msg *streamSocketWithCtxSetIpv6TrafficClassResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxSetIpv6TrafficClassResponse
}

type streamSocketWithCtxGetIpv6TrafficClassResponse struct {
	_      struct{}                            `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result BaseSocketGetIpv6TrafficClassResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxGetIpv6TrafficClassResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxGetIpv6TrafficClassResponse{})

func (msg *streamSocketWithCtxGetIpv6TrafficClassResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxGetIpv6TrafficClassResponse
}

type streamSocketWithCtxListenRequest struct {
	_       struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	Backlog int16    `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxListenRequest = _bindings.CreateLazyMarshaler(streamSocketWithCtxListenRequest{})

func (msg *streamSocketWithCtxListenRequest) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxListenRequest
}

type streamSocketWithCtxListenResponse struct {
	_      struct{}                 `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result StreamSocketListenResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxListenResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxListenResponse{})

func (msg *streamSocketWithCtxListenResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxListenResponse
}

type streamSocketWithCtxAcceptRequest struct {
	_        struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	WantAddr bool     `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxAcceptRequest = _bindings.CreateLazyMarshaler(streamSocketWithCtxAcceptRequest{})

func (msg *streamSocketWithCtxAcceptRequest) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxAcceptRequest
}

type streamSocketWithCtxAcceptResponse struct {
	_      struct{}                 `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result StreamSocketAcceptResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxAcceptResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxAcceptResponse{})

func (msg *streamSocketWithCtxAcceptResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxAcceptResponse
}

type streamSocketWithCtxGetInfoResponse struct {
	_      struct{}                  `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result StreamSocketGetInfoResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxGetInfoResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxGetInfoResponse{})

func (msg *streamSocketWithCtxGetInfoResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxGetInfoResponse
}

type streamSocketWithCtxSetTcpNoDelayRequest struct {
	_     struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	Value bool     `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxSetTcpNoDelayRequest = _bindings.CreateLazyMarshaler(streamSocketWithCtxSetTcpNoDelayRequest{})

func (msg *streamSocketWithCtxSetTcpNoDelayRequest) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxSetTcpNoDelayRequest
}

type streamSocketWithCtxSetTcpNoDelayResponse struct {
	_      struct{}                        `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result StreamSocketSetTcpNoDelayResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxSetTcpNoDelayResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxSetTcpNoDelayResponse{})

func (msg *streamSocketWithCtxSetTcpNoDelayResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxSetTcpNoDelayResponse
}

type streamSocketWithCtxGetTcpNoDelayResponse struct {
	_      struct{}                        `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result StreamSocketGetTcpNoDelayResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxGetTcpNoDelayResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxGetTcpNoDelayResponse{})

func (msg *streamSocketWithCtxGetTcpNoDelayResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxGetTcpNoDelayResponse
}

type streamSocketWithCtxSetTcpMaxSegmentRequest struct {
	_          struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	ValueBytes uint32   `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxSetTcpMaxSegmentRequest = _bindings.CreateLazyMarshaler(streamSocketWithCtxSetTcpMaxSegmentRequest{})

func (msg *streamSocketWithCtxSetTcpMaxSegmentRequest) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxSetTcpMaxSegmentRequest
}

type streamSocketWithCtxSetTcpMaxSegmentResponse struct {
	_      struct{}                           `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result StreamSocketSetTcpMaxSegmentResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxSetTcpMaxSegmentResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxSetTcpMaxSegmentResponse{})

func (msg *streamSocketWithCtxSetTcpMaxSegmentResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxSetTcpMaxSegmentResponse
}

type streamSocketWithCtxGetTcpMaxSegmentResponse struct {
	_      struct{}                           `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result StreamSocketGetTcpMaxSegmentResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxGetTcpMaxSegmentResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxGetTcpMaxSegmentResponse{})

func (msg *streamSocketWithCtxGetTcpMaxSegmentResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxGetTcpMaxSegmentResponse
}

type streamSocketWithCtxSetTcpCorkRequest struct {
	_     struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	Value bool     `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxSetTcpCorkRequest = _bindings.CreateLazyMarshaler(streamSocketWithCtxSetTcpCorkRequest{})

func (msg *streamSocketWithCtxSetTcpCorkRequest) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxSetTcpCorkRequest
}

type streamSocketWithCtxSetTcpCorkResponse struct {
	_      struct{}                     `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result StreamSocketSetTcpCorkResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxSetTcpCorkResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxSetTcpCorkResponse{})

func (msg *streamSocketWithCtxSetTcpCorkResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxSetTcpCorkResponse
}

type streamSocketWithCtxGetTcpCorkResponse struct {
	_      struct{}                     `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result StreamSocketGetTcpCorkResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxGetTcpCorkResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxGetTcpCorkResponse{})

func (msg *streamSocketWithCtxGetTcpCorkResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxGetTcpCorkResponse
}

type streamSocketWithCtxSetTcpKeepAliveIdleRequest struct {
	_         struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	ValueSecs uint32   `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxSetTcpKeepAliveIdleRequest = _bindings.CreateLazyMarshaler(streamSocketWithCtxSetTcpKeepAliveIdleRequest{})

func (msg *streamSocketWithCtxSetTcpKeepAliveIdleRequest) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxSetTcpKeepAliveIdleRequest
}

type streamSocketWithCtxSetTcpKeepAliveIdleResponse struct {
	_      struct{}                              `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result StreamSocketSetTcpKeepAliveIdleResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxSetTcpKeepAliveIdleResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxSetTcpKeepAliveIdleResponse{})

func (msg *streamSocketWithCtxSetTcpKeepAliveIdleResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxSetTcpKeepAliveIdleResponse
}

type streamSocketWithCtxGetTcpKeepAliveIdleResponse struct {
	_      struct{}                              `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result StreamSocketGetTcpKeepAliveIdleResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxGetTcpKeepAliveIdleResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxGetTcpKeepAliveIdleResponse{})

func (msg *streamSocketWithCtxGetTcpKeepAliveIdleResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxGetTcpKeepAliveIdleResponse
}

type streamSocketWithCtxSetTcpKeepAliveIntervalRequest struct {
	_         struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	ValueSecs uint32   `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxSetTcpKeepAliveIntervalRequest = _bindings.CreateLazyMarshaler(streamSocketWithCtxSetTcpKeepAliveIntervalRequest{})

func (msg *streamSocketWithCtxSetTcpKeepAliveIntervalRequest) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxSetTcpKeepAliveIntervalRequest
}

type streamSocketWithCtxSetTcpKeepAliveIntervalResponse struct {
	_      struct{}                                  `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result StreamSocketSetTcpKeepAliveIntervalResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxSetTcpKeepAliveIntervalResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxSetTcpKeepAliveIntervalResponse{})

func (msg *streamSocketWithCtxSetTcpKeepAliveIntervalResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxSetTcpKeepAliveIntervalResponse
}

type streamSocketWithCtxGetTcpKeepAliveIntervalResponse struct {
	_      struct{}                                  `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result StreamSocketGetTcpKeepAliveIntervalResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxGetTcpKeepAliveIntervalResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxGetTcpKeepAliveIntervalResponse{})

func (msg *streamSocketWithCtxGetTcpKeepAliveIntervalResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxGetTcpKeepAliveIntervalResponse
}

type streamSocketWithCtxSetTcpKeepAliveCountRequest struct {
	_     struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	Value uint32   `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxSetTcpKeepAliveCountRequest = _bindings.CreateLazyMarshaler(streamSocketWithCtxSetTcpKeepAliveCountRequest{})

func (msg *streamSocketWithCtxSetTcpKeepAliveCountRequest) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxSetTcpKeepAliveCountRequest
}

type streamSocketWithCtxSetTcpKeepAliveCountResponse struct {
	_      struct{}                               `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result StreamSocketSetTcpKeepAliveCountResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxSetTcpKeepAliveCountResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxSetTcpKeepAliveCountResponse{})

func (msg *streamSocketWithCtxSetTcpKeepAliveCountResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxSetTcpKeepAliveCountResponse
}

type streamSocketWithCtxGetTcpKeepAliveCountResponse struct {
	_      struct{}                               `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result StreamSocketGetTcpKeepAliveCountResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxGetTcpKeepAliveCountResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxGetTcpKeepAliveCountResponse{})

func (msg *streamSocketWithCtxGetTcpKeepAliveCountResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxGetTcpKeepAliveCountResponse
}

type streamSocketWithCtxSetTcpSynCountRequest struct {
	_     struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	Value uint32   `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxSetTcpSynCountRequest = _bindings.CreateLazyMarshaler(streamSocketWithCtxSetTcpSynCountRequest{})

func (msg *streamSocketWithCtxSetTcpSynCountRequest) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxSetTcpSynCountRequest
}

type streamSocketWithCtxSetTcpSynCountResponse struct {
	_      struct{}                         `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result StreamSocketSetTcpSynCountResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxSetTcpSynCountResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxSetTcpSynCountResponse{})

func (msg *streamSocketWithCtxSetTcpSynCountResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxSetTcpSynCountResponse
}

type streamSocketWithCtxGetTcpSynCountResponse struct {
	_      struct{}                         `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result StreamSocketGetTcpSynCountResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxGetTcpSynCountResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxGetTcpSynCountResponse{})

func (msg *streamSocketWithCtxGetTcpSynCountResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxGetTcpSynCountResponse
}

type streamSocketWithCtxSetTcpLingerRequest struct {
	_         struct{}       `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	ValueSecs OptionalUint32 `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxSetTcpLingerRequest = _bindings.CreateLazyMarshaler(streamSocketWithCtxSetTcpLingerRequest{})

func (msg *streamSocketWithCtxSetTcpLingerRequest) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxSetTcpLingerRequest
}

type streamSocketWithCtxSetTcpLingerResponse struct {
	_      struct{}                       `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result StreamSocketSetTcpLingerResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxSetTcpLingerResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxSetTcpLingerResponse{})

func (msg *streamSocketWithCtxSetTcpLingerResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxSetTcpLingerResponse
}

type streamSocketWithCtxGetTcpLingerResponse struct {
	_      struct{}                       `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result StreamSocketGetTcpLingerResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxGetTcpLingerResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxGetTcpLingerResponse{})

func (msg *streamSocketWithCtxGetTcpLingerResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxGetTcpLingerResponse
}

type streamSocketWithCtxSetTcpDeferAcceptRequest struct {
	_         struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	ValueSecs uint32   `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxSetTcpDeferAcceptRequest = _bindings.CreateLazyMarshaler(streamSocketWithCtxSetTcpDeferAcceptRequest{})

func (msg *streamSocketWithCtxSetTcpDeferAcceptRequest) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxSetTcpDeferAcceptRequest
}

type streamSocketWithCtxSetTcpDeferAcceptResponse struct {
	_      struct{}                            `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result StreamSocketSetTcpDeferAcceptResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxSetTcpDeferAcceptResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxSetTcpDeferAcceptResponse{})

func (msg *streamSocketWithCtxSetTcpDeferAcceptResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxSetTcpDeferAcceptResponse
}

type streamSocketWithCtxGetTcpDeferAcceptResponse struct {
	_      struct{}                            `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result StreamSocketGetTcpDeferAcceptResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxGetTcpDeferAcceptResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxGetTcpDeferAcceptResponse{})

func (msg *streamSocketWithCtxGetTcpDeferAcceptResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxGetTcpDeferAcceptResponse
}

type streamSocketWithCtxSetTcpWindowClampRequest struct {
	_     struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	Value uint32   `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxSetTcpWindowClampRequest = _bindings.CreateLazyMarshaler(streamSocketWithCtxSetTcpWindowClampRequest{})

func (msg *streamSocketWithCtxSetTcpWindowClampRequest) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxSetTcpWindowClampRequest
}

type streamSocketWithCtxSetTcpWindowClampResponse struct {
	_      struct{}                            `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result StreamSocketSetTcpWindowClampResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxSetTcpWindowClampResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxSetTcpWindowClampResponse{})

func (msg *streamSocketWithCtxSetTcpWindowClampResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxSetTcpWindowClampResponse
}

type streamSocketWithCtxGetTcpWindowClampResponse struct {
	_      struct{}                            `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result StreamSocketGetTcpWindowClampResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxGetTcpWindowClampResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxGetTcpWindowClampResponse{})

func (msg *streamSocketWithCtxGetTcpWindowClampResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxGetTcpWindowClampResponse
}

type streamSocketWithCtxGetTcpInfoResponse struct {
	_      struct{}                     `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result StreamSocketGetTcpInfoResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxGetTcpInfoResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxGetTcpInfoResponse{})

func (msg *streamSocketWithCtxGetTcpInfoResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxGetTcpInfoResponse
}

type streamSocketWithCtxSetTcpQuickAckRequest struct {
	_     struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	Value bool     `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxSetTcpQuickAckRequest = _bindings.CreateLazyMarshaler(streamSocketWithCtxSetTcpQuickAckRequest{})

func (msg *streamSocketWithCtxSetTcpQuickAckRequest) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxSetTcpQuickAckRequest
}

type streamSocketWithCtxSetTcpQuickAckResponse struct {
	_      struct{}                         `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result StreamSocketSetTcpQuickAckResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxSetTcpQuickAckResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxSetTcpQuickAckResponse{})

func (msg *streamSocketWithCtxSetTcpQuickAckResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxSetTcpQuickAckResponse
}

type streamSocketWithCtxGetTcpQuickAckResponse struct {
	_      struct{}                         `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result StreamSocketGetTcpQuickAckResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxGetTcpQuickAckResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxGetTcpQuickAckResponse{})

func (msg *streamSocketWithCtxGetTcpQuickAckResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxGetTcpQuickAckResponse
}

type streamSocketWithCtxSetTcpCongestionRequest struct {
	_     struct{}             `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	Value TcpCongestionControl `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxSetTcpCongestionRequest = _bindings.CreateLazyMarshaler(streamSocketWithCtxSetTcpCongestionRequest{})

func (msg *streamSocketWithCtxSetTcpCongestionRequest) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxSetTcpCongestionRequest
}

type streamSocketWithCtxSetTcpCongestionResponse struct {
	_      struct{}                           `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result StreamSocketSetTcpCongestionResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxSetTcpCongestionResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxSetTcpCongestionResponse{})

func (msg *streamSocketWithCtxSetTcpCongestionResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxSetTcpCongestionResponse
}

type streamSocketWithCtxGetTcpCongestionResponse struct {
	_      struct{}                           `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result StreamSocketGetTcpCongestionResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxGetTcpCongestionResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxGetTcpCongestionResponse{})

func (msg *streamSocketWithCtxGetTcpCongestionResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxGetTcpCongestionResponse
}

type streamSocketWithCtxSetTcpUserTimeoutRequest struct {
	_           struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	ValueMillis uint32   `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxSetTcpUserTimeoutRequest = _bindings.CreateLazyMarshaler(streamSocketWithCtxSetTcpUserTimeoutRequest{})

func (msg *streamSocketWithCtxSetTcpUserTimeoutRequest) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxSetTcpUserTimeoutRequest
}

type streamSocketWithCtxSetTcpUserTimeoutResponse struct {
	_      struct{}                            `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result StreamSocketSetTcpUserTimeoutResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxSetTcpUserTimeoutResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxSetTcpUserTimeoutResponse{})

func (msg *streamSocketWithCtxSetTcpUserTimeoutResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxSetTcpUserTimeoutResponse
}

type streamSocketWithCtxGetTcpUserTimeoutResponse struct {
	_      struct{}                            `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result StreamSocketGetTcpUserTimeoutResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxGetTcpUserTimeoutResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxGetTcpUserTimeoutResponse{})

func (msg *streamSocketWithCtxGetTcpUserTimeoutResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxGetTcpUserTimeoutResponse
}

type providerWithCtxStreamSocketRequest struct {
	_      struct{}             `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	Domain Domain               `fidl_offset_v1:"0" fidl_offset_v2:"0"`
	Proto  StreamSocketProtocol `fidl_offset_v1:"4" fidl_offset_v2:"4"`
}

var _mproviderWithCtxStreamSocketRequest = _bindings.CreateLazyMarshaler(providerWithCtxStreamSocketRequest{})

func (msg *providerWithCtxStreamSocketRequest) Marshaler() _bindings.Marshaler {
	return _mproviderWithCtxStreamSocketRequest
}

type providerWithCtxStreamSocketResponse struct {
	_      struct{}                   `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result ProviderStreamSocketResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mproviderWithCtxStreamSocketResponse = _bindings.CreateLazyMarshaler(providerWithCtxStreamSocketResponse{})

func (msg *providerWithCtxStreamSocketResponse) Marshaler() _bindings.Marshaler {
	return _mproviderWithCtxStreamSocketResponse
}

type providerWithCtxDatagramSocketRequest struct {
	_      struct{}               `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	Domain Domain                 `fidl_offset_v1:"0" fidl_offset_v2:"0"`
	Proto  DatagramSocketProtocol `fidl_offset_v1:"4" fidl_offset_v2:"4"`
}

var _mproviderWithCtxDatagramSocketRequest = _bindings.CreateLazyMarshaler(providerWithCtxDatagramSocketRequest{})

func (msg *providerWithCtxDatagramSocketRequest) Marshaler() _bindings.Marshaler {
	return _mproviderWithCtxDatagramSocketRequest
}

type providerWithCtxDatagramSocketResponse struct {
	_      struct{}                     `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result ProviderDatagramSocketResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mproviderWithCtxDatagramSocketResponse = _bindings.CreateLazyMarshaler(providerWithCtxDatagramSocketResponse{})

func (msg *providerWithCtxDatagramSocketResponse) Marshaler() _bindings.Marshaler {
	return _mproviderWithCtxDatagramSocketResponse
}

type providerWithCtxInterfaceIndexToNameRequest struct {
	_     struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	Index uint64   `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mproviderWithCtxInterfaceIndexToNameRequest = _bindings.CreateLazyMarshaler(providerWithCtxInterfaceIndexToNameRequest{})

func (msg *providerWithCtxInterfaceIndexToNameRequest) Marshaler() _bindings.Marshaler {
	return _mproviderWithCtxInterfaceIndexToNameRequest
}

type providerWithCtxInterfaceIndexToNameResponse struct {
	_      struct{}                           `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result ProviderInterfaceIndexToNameResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mproviderWithCtxInterfaceIndexToNameResponse = _bindings.CreateLazyMarshaler(providerWithCtxInterfaceIndexToNameResponse{})

func (msg *providerWithCtxInterfaceIndexToNameResponse) Marshaler() _bindings.Marshaler {
	return _mproviderWithCtxInterfaceIndexToNameResponse
}

type providerWithCtxInterfaceNameToIndexRequest struct {
	_    struct{} `fidl:"s" fidl_size_v1:"16" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Name string   `fidl_offset_v1:"0" fidl_offset_v2:"0" fidl_bounds:"15"`
}

var _mproviderWithCtxInterfaceNameToIndexRequest = _bindings.CreateLazyMarshaler(providerWithCtxInterfaceNameToIndexRequest{})

func (msg *providerWithCtxInterfaceNameToIndexRequest) Marshaler() _bindings.Marshaler {
	return _mproviderWithCtxInterfaceNameToIndexRequest
}

type providerWithCtxInterfaceNameToIndexResponse struct {
	_      struct{}                           `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result ProviderInterfaceNameToIndexResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mproviderWithCtxInterfaceNameToIndexResponse = _bindings.CreateLazyMarshaler(providerWithCtxInterfaceNameToIndexResponse{})

func (msg *providerWithCtxInterfaceNameToIndexResponse) Marshaler() _bindings.Marshaler {
	return _mproviderWithCtxInterfaceNameToIndexResponse
}

type providerWithCtxInterfaceNameToFlagsRequest struct {
	_    struct{} `fidl:"s" fidl_size_v1:"16" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Name string   `fidl_offset_v1:"0" fidl_offset_v2:"0" fidl_bounds:"15"`
}

var _mproviderWithCtxInterfaceNameToFlagsRequest = _bindings.CreateLazyMarshaler(providerWithCtxInterfaceNameToFlagsRequest{})

func (msg *providerWithCtxInterfaceNameToFlagsRequest) Marshaler() _bindings.Marshaler {
	return _mproviderWithCtxInterfaceNameToFlagsRequest
}

type providerWithCtxInterfaceNameToFlagsResponse struct {
	_      struct{}                           `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result ProviderInterfaceNameToFlagsResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mproviderWithCtxInterfaceNameToFlagsResponse = _bindings.CreateLazyMarshaler(providerWithCtxInterfaceNameToFlagsResponse{})

func (msg *providerWithCtxInterfaceNameToFlagsResponse) Marshaler() _bindings.Marshaler {
	return _mproviderWithCtxInterfaceNameToFlagsResponse
}

type providerWithCtxGetInterfaceAddressesResponse struct {
	_          struct{}             `fidl:"s" fidl_size_v1:"16" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Interfaces []InterfaceAddresses `fidl_offset_v1:"0" fidl_offset_v2:"0" fidl_bounds:""`
}

var _mproviderWithCtxGetInterfaceAddressesResponse = _bindings.CreateLazyMarshaler(providerWithCtxGetInterfaceAddressesResponse{})

func (msg *providerWithCtxGetInterfaceAddressesResponse) Marshaler() _bindings.Marshaler {
	return _mproviderWithCtxGetInterfaceAddressesResponse
}

type I_baseSocketBindResultTag uint64

const (
	BaseSocketBindResultResponse = 1 // 0x00000001
	BaseSocketBindResultErr      = 2 // 0x00000002
)

type BaseSocketBindResult struct {
	I_baseSocketBindResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                  BaseSocketBindResponse `fidl_ordinal:"1"`
	Err                       fuchsiaposix.Errno     `fidl_ordinal:"2"`
}

func (_m *BaseSocketBindResult) reset() {
	switch _m.I_baseSocketBindResultTag {
	case 1:
		var _zeroed BaseSocketBindResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseSocketBindResult) Which() I_baseSocketBindResultTag {
	return _m.I_baseSocketBindResultTag
}

func (_m *BaseSocketBindResult) Ordinal() uint64 {
	return uint64(_m.I_baseSocketBindResultTag)
}

func (_m *BaseSocketBindResult) SetResponse(response BaseSocketBindResponse) {
	_m.reset()
	_m.I_baseSocketBindResultTag = BaseSocketBindResultResponse
	_m.Response = response
}

func BaseSocketBindResultWithResponse(response BaseSocketBindResponse) BaseSocketBindResult {
	var _u BaseSocketBindResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseSocketBindResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseSocketBindResultTag = BaseSocketBindResultErr
	_m.Err = err
}

func BaseSocketBindResultWithErr(err fuchsiaposix.Errno) BaseSocketBindResult {
	var _u BaseSocketBindResult
	_u.SetErr(err)
	return _u
}

type I_baseSocketConnectResultTag uint64

const (
	BaseSocketConnectResultResponse = 1 // 0x00000001
	BaseSocketConnectResultErr      = 2 // 0x00000002
)

type BaseSocketConnectResult struct {
	I_baseSocketConnectResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                     BaseSocketConnectResponse `fidl_ordinal:"1"`
	Err                          fuchsiaposix.Errno        `fidl_ordinal:"2"`
}

func (_m *BaseSocketConnectResult) reset() {
	switch _m.I_baseSocketConnectResultTag {
	case 1:
		var _zeroed BaseSocketConnectResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseSocketConnectResult) Which() I_baseSocketConnectResultTag {
	return _m.I_baseSocketConnectResultTag
}

func (_m *BaseSocketConnectResult) Ordinal() uint64 {
	return uint64(_m.I_baseSocketConnectResultTag)
}

func (_m *BaseSocketConnectResult) SetResponse(response BaseSocketConnectResponse) {
	_m.reset()
	_m.I_baseSocketConnectResultTag = BaseSocketConnectResultResponse
	_m.Response = response
}

func BaseSocketConnectResultWithResponse(response BaseSocketConnectResponse) BaseSocketConnectResult {
	var _u BaseSocketConnectResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseSocketConnectResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseSocketConnectResultTag = BaseSocketConnectResultErr
	_m.Err = err
}

func BaseSocketConnectResultWithErr(err fuchsiaposix.Errno) BaseSocketConnectResult {
	var _u BaseSocketConnectResult
	_u.SetErr(err)
	return _u
}

type I_baseSocketDisconnectResultTag uint64

const (
	BaseSocketDisconnectResultResponse = 1 // 0x00000001
	BaseSocketDisconnectResultErr      = 2 // 0x00000002
)

type BaseSocketDisconnectResult struct {
	I_baseSocketDisconnectResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                        BaseSocketDisconnectResponse `fidl_ordinal:"1"`
	Err                             fuchsiaposix.Errno           `fidl_ordinal:"2"`
}

func (_m *BaseSocketDisconnectResult) reset() {
	switch _m.I_baseSocketDisconnectResultTag {
	case 1:
		var _zeroed BaseSocketDisconnectResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseSocketDisconnectResult) Which() I_baseSocketDisconnectResultTag {
	return _m.I_baseSocketDisconnectResultTag
}

func (_m *BaseSocketDisconnectResult) Ordinal() uint64 {
	return uint64(_m.I_baseSocketDisconnectResultTag)
}

func (_m *BaseSocketDisconnectResult) SetResponse(response BaseSocketDisconnectResponse) {
	_m.reset()
	_m.I_baseSocketDisconnectResultTag = BaseSocketDisconnectResultResponse
	_m.Response = response
}

func BaseSocketDisconnectResultWithResponse(response BaseSocketDisconnectResponse) BaseSocketDisconnectResult {
	var _u BaseSocketDisconnectResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseSocketDisconnectResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseSocketDisconnectResultTag = BaseSocketDisconnectResultErr
	_m.Err = err
}

func BaseSocketDisconnectResultWithErr(err fuchsiaposix.Errno) BaseSocketDisconnectResult {
	var _u BaseSocketDisconnectResult
	_u.SetErr(err)
	return _u
}

type I_baseSocketGetSockNameResultTag uint64

const (
	BaseSocketGetSockNameResultResponse = 1 // 0x00000001
	BaseSocketGetSockNameResultErr      = 2 // 0x00000002
)

type BaseSocketGetSockNameResult struct {
	I_baseSocketGetSockNameResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                         BaseSocketGetSockNameResponse `fidl_ordinal:"1"`
	Err                              fuchsiaposix.Errno            `fidl_ordinal:"2"`
}

func (_m *BaseSocketGetSockNameResult) reset() {
	switch _m.I_baseSocketGetSockNameResultTag {
	case 1:
		var _zeroed BaseSocketGetSockNameResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseSocketGetSockNameResult) Which() I_baseSocketGetSockNameResultTag {
	return _m.I_baseSocketGetSockNameResultTag
}

func (_m *BaseSocketGetSockNameResult) Ordinal() uint64 {
	return uint64(_m.I_baseSocketGetSockNameResultTag)
}

func (_m *BaseSocketGetSockNameResult) SetResponse(response BaseSocketGetSockNameResponse) {
	_m.reset()
	_m.I_baseSocketGetSockNameResultTag = BaseSocketGetSockNameResultResponse
	_m.Response = response
}

func BaseSocketGetSockNameResultWithResponse(response BaseSocketGetSockNameResponse) BaseSocketGetSockNameResult {
	var _u BaseSocketGetSockNameResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseSocketGetSockNameResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseSocketGetSockNameResultTag = BaseSocketGetSockNameResultErr
	_m.Err = err
}

func BaseSocketGetSockNameResultWithErr(err fuchsiaposix.Errno) BaseSocketGetSockNameResult {
	var _u BaseSocketGetSockNameResult
	_u.SetErr(err)
	return _u
}

type I_baseSocketGetPeerNameResultTag uint64

const (
	BaseSocketGetPeerNameResultResponse = 1 // 0x00000001
	BaseSocketGetPeerNameResultErr      = 2 // 0x00000002
)

type BaseSocketGetPeerNameResult struct {
	I_baseSocketGetPeerNameResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                         BaseSocketGetPeerNameResponse `fidl_ordinal:"1"`
	Err                              fuchsiaposix.Errno            `fidl_ordinal:"2"`
}

func (_m *BaseSocketGetPeerNameResult) reset() {
	switch _m.I_baseSocketGetPeerNameResultTag {
	case 1:
		var _zeroed BaseSocketGetPeerNameResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseSocketGetPeerNameResult) Which() I_baseSocketGetPeerNameResultTag {
	return _m.I_baseSocketGetPeerNameResultTag
}

func (_m *BaseSocketGetPeerNameResult) Ordinal() uint64 {
	return uint64(_m.I_baseSocketGetPeerNameResultTag)
}

func (_m *BaseSocketGetPeerNameResult) SetResponse(response BaseSocketGetPeerNameResponse) {
	_m.reset()
	_m.I_baseSocketGetPeerNameResultTag = BaseSocketGetPeerNameResultResponse
	_m.Response = response
}

func BaseSocketGetPeerNameResultWithResponse(response BaseSocketGetPeerNameResponse) BaseSocketGetPeerNameResult {
	var _u BaseSocketGetPeerNameResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseSocketGetPeerNameResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseSocketGetPeerNameResultTag = BaseSocketGetPeerNameResultErr
	_m.Err = err
}

func BaseSocketGetPeerNameResultWithErr(err fuchsiaposix.Errno) BaseSocketGetPeerNameResult {
	var _u BaseSocketGetPeerNameResult
	_u.SetErr(err)
	return _u
}

type I_baseSocketShutdownResultTag uint64

const (
	BaseSocketShutdownResultResponse = 1 // 0x00000001
	BaseSocketShutdownResultErr      = 2 // 0x00000002
)

type BaseSocketShutdownResult struct {
	I_baseSocketShutdownResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                      BaseSocketShutdownResponse `fidl_ordinal:"1"`
	Err                           fuchsiaposix.Errno         `fidl_ordinal:"2"`
}

func (_m *BaseSocketShutdownResult) reset() {
	switch _m.I_baseSocketShutdownResultTag {
	case 1:
		var _zeroed BaseSocketShutdownResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseSocketShutdownResult) Which() I_baseSocketShutdownResultTag {
	return _m.I_baseSocketShutdownResultTag
}

func (_m *BaseSocketShutdownResult) Ordinal() uint64 {
	return uint64(_m.I_baseSocketShutdownResultTag)
}

func (_m *BaseSocketShutdownResult) SetResponse(response BaseSocketShutdownResponse) {
	_m.reset()
	_m.I_baseSocketShutdownResultTag = BaseSocketShutdownResultResponse
	_m.Response = response
}

func BaseSocketShutdownResultWithResponse(response BaseSocketShutdownResponse) BaseSocketShutdownResult {
	var _u BaseSocketShutdownResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseSocketShutdownResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseSocketShutdownResultTag = BaseSocketShutdownResultErr
	_m.Err = err
}

func BaseSocketShutdownResultWithErr(err fuchsiaposix.Errno) BaseSocketShutdownResult {
	var _u BaseSocketShutdownResult
	_u.SetErr(err)
	return _u
}

type I_baseSocketShutdown2ResultTag uint64

const (
	BaseSocketShutdown2ResultResponse = 1 // 0x00000001
	BaseSocketShutdown2ResultErr      = 2 // 0x00000002
)

type BaseSocketShutdown2Result struct {
	I_baseSocketShutdown2ResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                       BaseSocketShutdown2Response `fidl_ordinal:"1"`
	Err                            fuchsiaposix.Errno          `fidl_ordinal:"2"`
}

func (_m *BaseSocketShutdown2Result) reset() {
	switch _m.I_baseSocketShutdown2ResultTag {
	case 1:
		var _zeroed BaseSocketShutdown2Response
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseSocketShutdown2Result) Which() I_baseSocketShutdown2ResultTag {
	return _m.I_baseSocketShutdown2ResultTag
}

func (_m *BaseSocketShutdown2Result) Ordinal() uint64 {
	return uint64(_m.I_baseSocketShutdown2ResultTag)
}

func (_m *BaseSocketShutdown2Result) SetResponse(response BaseSocketShutdown2Response) {
	_m.reset()
	_m.I_baseSocketShutdown2ResultTag = BaseSocketShutdown2ResultResponse
	_m.Response = response
}

func BaseSocketShutdown2ResultWithResponse(response BaseSocketShutdown2Response) BaseSocketShutdown2Result {
	var _u BaseSocketShutdown2Result
	_u.SetResponse(response)
	return _u
}

func (_m *BaseSocketShutdown2Result) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseSocketShutdown2ResultTag = BaseSocketShutdown2ResultErr
	_m.Err = err
}

func BaseSocketShutdown2ResultWithErr(err fuchsiaposix.Errno) BaseSocketShutdown2Result {
	var _u BaseSocketShutdown2Result
	_u.SetErr(err)
	return _u
}

type I_baseSocketSetReuseAddressResultTag uint64

const (
	BaseSocketSetReuseAddressResultResponse = 1 // 0x00000001
	BaseSocketSetReuseAddressResultErr      = 2 // 0x00000002
)

type BaseSocketSetReuseAddressResult struct {
	I_baseSocketSetReuseAddressResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                             BaseSocketSetReuseAddressResponse `fidl_ordinal:"1"`
	Err                                  fuchsiaposix.Errno                `fidl_ordinal:"2"`
}

func (_m *BaseSocketSetReuseAddressResult) reset() {
	switch _m.I_baseSocketSetReuseAddressResultTag {
	case 1:
		var _zeroed BaseSocketSetReuseAddressResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseSocketSetReuseAddressResult) Which() I_baseSocketSetReuseAddressResultTag {
	return _m.I_baseSocketSetReuseAddressResultTag
}

func (_m *BaseSocketSetReuseAddressResult) Ordinal() uint64 {
	return uint64(_m.I_baseSocketSetReuseAddressResultTag)
}

func (_m *BaseSocketSetReuseAddressResult) SetResponse(response BaseSocketSetReuseAddressResponse) {
	_m.reset()
	_m.I_baseSocketSetReuseAddressResultTag = BaseSocketSetReuseAddressResultResponse
	_m.Response = response
}

func BaseSocketSetReuseAddressResultWithResponse(response BaseSocketSetReuseAddressResponse) BaseSocketSetReuseAddressResult {
	var _u BaseSocketSetReuseAddressResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseSocketSetReuseAddressResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseSocketSetReuseAddressResultTag = BaseSocketSetReuseAddressResultErr
	_m.Err = err
}

func BaseSocketSetReuseAddressResultWithErr(err fuchsiaposix.Errno) BaseSocketSetReuseAddressResult {
	var _u BaseSocketSetReuseAddressResult
	_u.SetErr(err)
	return _u
}

type I_baseSocketGetReuseAddressResultTag uint64

const (
	BaseSocketGetReuseAddressResultResponse = 1 // 0x00000001
	BaseSocketGetReuseAddressResultErr      = 2 // 0x00000002
)

type BaseSocketGetReuseAddressResult struct {
	I_baseSocketGetReuseAddressResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                             BaseSocketGetReuseAddressResponse `fidl_ordinal:"1"`
	Err                                  fuchsiaposix.Errno                `fidl_ordinal:"2"`
}

func (_m *BaseSocketGetReuseAddressResult) reset() {
	switch _m.I_baseSocketGetReuseAddressResultTag {
	case 1:
		var _zeroed BaseSocketGetReuseAddressResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseSocketGetReuseAddressResult) Which() I_baseSocketGetReuseAddressResultTag {
	return _m.I_baseSocketGetReuseAddressResultTag
}

func (_m *BaseSocketGetReuseAddressResult) Ordinal() uint64 {
	return uint64(_m.I_baseSocketGetReuseAddressResultTag)
}

func (_m *BaseSocketGetReuseAddressResult) SetResponse(response BaseSocketGetReuseAddressResponse) {
	_m.reset()
	_m.I_baseSocketGetReuseAddressResultTag = BaseSocketGetReuseAddressResultResponse
	_m.Response = response
}

func BaseSocketGetReuseAddressResultWithResponse(response BaseSocketGetReuseAddressResponse) BaseSocketGetReuseAddressResult {
	var _u BaseSocketGetReuseAddressResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseSocketGetReuseAddressResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseSocketGetReuseAddressResultTag = BaseSocketGetReuseAddressResultErr
	_m.Err = err
}

func BaseSocketGetReuseAddressResultWithErr(err fuchsiaposix.Errno) BaseSocketGetReuseAddressResult {
	var _u BaseSocketGetReuseAddressResult
	_u.SetErr(err)
	return _u
}

type I_baseSocketGetErrorResultTag uint64

const (
	BaseSocketGetErrorResultResponse = 1 // 0x00000001
	BaseSocketGetErrorResultErr      = 2 // 0x00000002
)

type BaseSocketGetErrorResult struct {
	I_baseSocketGetErrorResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                      BaseSocketGetErrorResponse `fidl_ordinal:"1"`
	Err                           fuchsiaposix.Errno         `fidl_ordinal:"2"`
}

func (_m *BaseSocketGetErrorResult) reset() {
	switch _m.I_baseSocketGetErrorResultTag {
	case 1:
		var _zeroed BaseSocketGetErrorResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseSocketGetErrorResult) Which() I_baseSocketGetErrorResultTag {
	return _m.I_baseSocketGetErrorResultTag
}

func (_m *BaseSocketGetErrorResult) Ordinal() uint64 {
	return uint64(_m.I_baseSocketGetErrorResultTag)
}

func (_m *BaseSocketGetErrorResult) SetResponse(response BaseSocketGetErrorResponse) {
	_m.reset()
	_m.I_baseSocketGetErrorResultTag = BaseSocketGetErrorResultResponse
	_m.Response = response
}

func BaseSocketGetErrorResultWithResponse(response BaseSocketGetErrorResponse) BaseSocketGetErrorResult {
	var _u BaseSocketGetErrorResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseSocketGetErrorResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseSocketGetErrorResultTag = BaseSocketGetErrorResultErr
	_m.Err = err
}

func BaseSocketGetErrorResultWithErr(err fuchsiaposix.Errno) BaseSocketGetErrorResult {
	var _u BaseSocketGetErrorResult
	_u.SetErr(err)
	return _u
}

type I_baseSocketSetBroadcastResultTag uint64

const (
	BaseSocketSetBroadcastResultResponse = 1 // 0x00000001
	BaseSocketSetBroadcastResultErr      = 2 // 0x00000002
)

type BaseSocketSetBroadcastResult struct {
	I_baseSocketSetBroadcastResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                          BaseSocketSetBroadcastResponse `fidl_ordinal:"1"`
	Err                               fuchsiaposix.Errno             `fidl_ordinal:"2"`
}

func (_m *BaseSocketSetBroadcastResult) reset() {
	switch _m.I_baseSocketSetBroadcastResultTag {
	case 1:
		var _zeroed BaseSocketSetBroadcastResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseSocketSetBroadcastResult) Which() I_baseSocketSetBroadcastResultTag {
	return _m.I_baseSocketSetBroadcastResultTag
}

func (_m *BaseSocketSetBroadcastResult) Ordinal() uint64 {
	return uint64(_m.I_baseSocketSetBroadcastResultTag)
}

func (_m *BaseSocketSetBroadcastResult) SetResponse(response BaseSocketSetBroadcastResponse) {
	_m.reset()
	_m.I_baseSocketSetBroadcastResultTag = BaseSocketSetBroadcastResultResponse
	_m.Response = response
}

func BaseSocketSetBroadcastResultWithResponse(response BaseSocketSetBroadcastResponse) BaseSocketSetBroadcastResult {
	var _u BaseSocketSetBroadcastResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseSocketSetBroadcastResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseSocketSetBroadcastResultTag = BaseSocketSetBroadcastResultErr
	_m.Err = err
}

func BaseSocketSetBroadcastResultWithErr(err fuchsiaposix.Errno) BaseSocketSetBroadcastResult {
	var _u BaseSocketSetBroadcastResult
	_u.SetErr(err)
	return _u
}

type I_baseSocketGetBroadcastResultTag uint64

const (
	BaseSocketGetBroadcastResultResponse = 1 // 0x00000001
	BaseSocketGetBroadcastResultErr      = 2 // 0x00000002
)

type BaseSocketGetBroadcastResult struct {
	I_baseSocketGetBroadcastResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                          BaseSocketGetBroadcastResponse `fidl_ordinal:"1"`
	Err                               fuchsiaposix.Errno             `fidl_ordinal:"2"`
}

func (_m *BaseSocketGetBroadcastResult) reset() {
	switch _m.I_baseSocketGetBroadcastResultTag {
	case 1:
		var _zeroed BaseSocketGetBroadcastResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseSocketGetBroadcastResult) Which() I_baseSocketGetBroadcastResultTag {
	return _m.I_baseSocketGetBroadcastResultTag
}

func (_m *BaseSocketGetBroadcastResult) Ordinal() uint64 {
	return uint64(_m.I_baseSocketGetBroadcastResultTag)
}

func (_m *BaseSocketGetBroadcastResult) SetResponse(response BaseSocketGetBroadcastResponse) {
	_m.reset()
	_m.I_baseSocketGetBroadcastResultTag = BaseSocketGetBroadcastResultResponse
	_m.Response = response
}

func BaseSocketGetBroadcastResultWithResponse(response BaseSocketGetBroadcastResponse) BaseSocketGetBroadcastResult {
	var _u BaseSocketGetBroadcastResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseSocketGetBroadcastResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseSocketGetBroadcastResultTag = BaseSocketGetBroadcastResultErr
	_m.Err = err
}

func BaseSocketGetBroadcastResultWithErr(err fuchsiaposix.Errno) BaseSocketGetBroadcastResult {
	var _u BaseSocketGetBroadcastResult
	_u.SetErr(err)
	return _u
}

type I_baseSocketSetSendBufferResultTag uint64

const (
	BaseSocketSetSendBufferResultResponse = 1 // 0x00000001
	BaseSocketSetSendBufferResultErr      = 2 // 0x00000002
)

type BaseSocketSetSendBufferResult struct {
	I_baseSocketSetSendBufferResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                           BaseSocketSetSendBufferResponse `fidl_ordinal:"1"`
	Err                                fuchsiaposix.Errno              `fidl_ordinal:"2"`
}

func (_m *BaseSocketSetSendBufferResult) reset() {
	switch _m.I_baseSocketSetSendBufferResultTag {
	case 1:
		var _zeroed BaseSocketSetSendBufferResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseSocketSetSendBufferResult) Which() I_baseSocketSetSendBufferResultTag {
	return _m.I_baseSocketSetSendBufferResultTag
}

func (_m *BaseSocketSetSendBufferResult) Ordinal() uint64 {
	return uint64(_m.I_baseSocketSetSendBufferResultTag)
}

func (_m *BaseSocketSetSendBufferResult) SetResponse(response BaseSocketSetSendBufferResponse) {
	_m.reset()
	_m.I_baseSocketSetSendBufferResultTag = BaseSocketSetSendBufferResultResponse
	_m.Response = response
}

func BaseSocketSetSendBufferResultWithResponse(response BaseSocketSetSendBufferResponse) BaseSocketSetSendBufferResult {
	var _u BaseSocketSetSendBufferResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseSocketSetSendBufferResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseSocketSetSendBufferResultTag = BaseSocketSetSendBufferResultErr
	_m.Err = err
}

func BaseSocketSetSendBufferResultWithErr(err fuchsiaposix.Errno) BaseSocketSetSendBufferResult {
	var _u BaseSocketSetSendBufferResult
	_u.SetErr(err)
	return _u
}

type I_baseSocketGetSendBufferResultTag uint64

const (
	BaseSocketGetSendBufferResultResponse = 1 // 0x00000001
	BaseSocketGetSendBufferResultErr      = 2 // 0x00000002
)

type BaseSocketGetSendBufferResult struct {
	I_baseSocketGetSendBufferResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                           BaseSocketGetSendBufferResponse `fidl_ordinal:"1"`
	Err                                fuchsiaposix.Errno              `fidl_ordinal:"2"`
}

func (_m *BaseSocketGetSendBufferResult) reset() {
	switch _m.I_baseSocketGetSendBufferResultTag {
	case 1:
		var _zeroed BaseSocketGetSendBufferResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseSocketGetSendBufferResult) Which() I_baseSocketGetSendBufferResultTag {
	return _m.I_baseSocketGetSendBufferResultTag
}

func (_m *BaseSocketGetSendBufferResult) Ordinal() uint64 {
	return uint64(_m.I_baseSocketGetSendBufferResultTag)
}

func (_m *BaseSocketGetSendBufferResult) SetResponse(response BaseSocketGetSendBufferResponse) {
	_m.reset()
	_m.I_baseSocketGetSendBufferResultTag = BaseSocketGetSendBufferResultResponse
	_m.Response = response
}

func BaseSocketGetSendBufferResultWithResponse(response BaseSocketGetSendBufferResponse) BaseSocketGetSendBufferResult {
	var _u BaseSocketGetSendBufferResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseSocketGetSendBufferResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseSocketGetSendBufferResultTag = BaseSocketGetSendBufferResultErr
	_m.Err = err
}

func BaseSocketGetSendBufferResultWithErr(err fuchsiaposix.Errno) BaseSocketGetSendBufferResult {
	var _u BaseSocketGetSendBufferResult
	_u.SetErr(err)
	return _u
}

type I_baseSocketSetReceiveBufferResultTag uint64

const (
	BaseSocketSetReceiveBufferResultResponse = 1 // 0x00000001
	BaseSocketSetReceiveBufferResultErr      = 2 // 0x00000002
)

type BaseSocketSetReceiveBufferResult struct {
	I_baseSocketSetReceiveBufferResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                              BaseSocketSetReceiveBufferResponse `fidl_ordinal:"1"`
	Err                                   fuchsiaposix.Errno                 `fidl_ordinal:"2"`
}

func (_m *BaseSocketSetReceiveBufferResult) reset() {
	switch _m.I_baseSocketSetReceiveBufferResultTag {
	case 1:
		var _zeroed BaseSocketSetReceiveBufferResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseSocketSetReceiveBufferResult) Which() I_baseSocketSetReceiveBufferResultTag {
	return _m.I_baseSocketSetReceiveBufferResultTag
}

func (_m *BaseSocketSetReceiveBufferResult) Ordinal() uint64 {
	return uint64(_m.I_baseSocketSetReceiveBufferResultTag)
}

func (_m *BaseSocketSetReceiveBufferResult) SetResponse(response BaseSocketSetReceiveBufferResponse) {
	_m.reset()
	_m.I_baseSocketSetReceiveBufferResultTag = BaseSocketSetReceiveBufferResultResponse
	_m.Response = response
}

func BaseSocketSetReceiveBufferResultWithResponse(response BaseSocketSetReceiveBufferResponse) BaseSocketSetReceiveBufferResult {
	var _u BaseSocketSetReceiveBufferResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseSocketSetReceiveBufferResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseSocketSetReceiveBufferResultTag = BaseSocketSetReceiveBufferResultErr
	_m.Err = err
}

func BaseSocketSetReceiveBufferResultWithErr(err fuchsiaposix.Errno) BaseSocketSetReceiveBufferResult {
	var _u BaseSocketSetReceiveBufferResult
	_u.SetErr(err)
	return _u
}

type I_baseSocketGetReceiveBufferResultTag uint64

const (
	BaseSocketGetReceiveBufferResultResponse = 1 // 0x00000001
	BaseSocketGetReceiveBufferResultErr      = 2 // 0x00000002
)

type BaseSocketGetReceiveBufferResult struct {
	I_baseSocketGetReceiveBufferResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                              BaseSocketGetReceiveBufferResponse `fidl_ordinal:"1"`
	Err                                   fuchsiaposix.Errno                 `fidl_ordinal:"2"`
}

func (_m *BaseSocketGetReceiveBufferResult) reset() {
	switch _m.I_baseSocketGetReceiveBufferResultTag {
	case 1:
		var _zeroed BaseSocketGetReceiveBufferResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseSocketGetReceiveBufferResult) Which() I_baseSocketGetReceiveBufferResultTag {
	return _m.I_baseSocketGetReceiveBufferResultTag
}

func (_m *BaseSocketGetReceiveBufferResult) Ordinal() uint64 {
	return uint64(_m.I_baseSocketGetReceiveBufferResultTag)
}

func (_m *BaseSocketGetReceiveBufferResult) SetResponse(response BaseSocketGetReceiveBufferResponse) {
	_m.reset()
	_m.I_baseSocketGetReceiveBufferResultTag = BaseSocketGetReceiveBufferResultResponse
	_m.Response = response
}

func BaseSocketGetReceiveBufferResultWithResponse(response BaseSocketGetReceiveBufferResponse) BaseSocketGetReceiveBufferResult {
	var _u BaseSocketGetReceiveBufferResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseSocketGetReceiveBufferResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseSocketGetReceiveBufferResultTag = BaseSocketGetReceiveBufferResultErr
	_m.Err = err
}

func BaseSocketGetReceiveBufferResultWithErr(err fuchsiaposix.Errno) BaseSocketGetReceiveBufferResult {
	var _u BaseSocketGetReceiveBufferResult
	_u.SetErr(err)
	return _u
}

type I_baseSocketSetKeepAliveResultTag uint64

const (
	BaseSocketSetKeepAliveResultResponse = 1 // 0x00000001
	BaseSocketSetKeepAliveResultErr      = 2 // 0x00000002
)

type BaseSocketSetKeepAliveResult struct {
	I_baseSocketSetKeepAliveResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                          BaseSocketSetKeepAliveResponse `fidl_ordinal:"1"`
	Err                               fuchsiaposix.Errno             `fidl_ordinal:"2"`
}

func (_m *BaseSocketSetKeepAliveResult) reset() {
	switch _m.I_baseSocketSetKeepAliveResultTag {
	case 1:
		var _zeroed BaseSocketSetKeepAliveResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseSocketSetKeepAliveResult) Which() I_baseSocketSetKeepAliveResultTag {
	return _m.I_baseSocketSetKeepAliveResultTag
}

func (_m *BaseSocketSetKeepAliveResult) Ordinal() uint64 {
	return uint64(_m.I_baseSocketSetKeepAliveResultTag)
}

func (_m *BaseSocketSetKeepAliveResult) SetResponse(response BaseSocketSetKeepAliveResponse) {
	_m.reset()
	_m.I_baseSocketSetKeepAliveResultTag = BaseSocketSetKeepAliveResultResponse
	_m.Response = response
}

func BaseSocketSetKeepAliveResultWithResponse(response BaseSocketSetKeepAliveResponse) BaseSocketSetKeepAliveResult {
	var _u BaseSocketSetKeepAliveResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseSocketSetKeepAliveResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseSocketSetKeepAliveResultTag = BaseSocketSetKeepAliveResultErr
	_m.Err = err
}

func BaseSocketSetKeepAliveResultWithErr(err fuchsiaposix.Errno) BaseSocketSetKeepAliveResult {
	var _u BaseSocketSetKeepAliveResult
	_u.SetErr(err)
	return _u
}

type I_baseSocketGetKeepAliveResultTag uint64

const (
	BaseSocketGetKeepAliveResultResponse = 1 // 0x00000001
	BaseSocketGetKeepAliveResultErr      = 2 // 0x00000002
)

type BaseSocketGetKeepAliveResult struct {
	I_baseSocketGetKeepAliveResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                          BaseSocketGetKeepAliveResponse `fidl_ordinal:"1"`
	Err                               fuchsiaposix.Errno             `fidl_ordinal:"2"`
}

func (_m *BaseSocketGetKeepAliveResult) reset() {
	switch _m.I_baseSocketGetKeepAliveResultTag {
	case 1:
		var _zeroed BaseSocketGetKeepAliveResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseSocketGetKeepAliveResult) Which() I_baseSocketGetKeepAliveResultTag {
	return _m.I_baseSocketGetKeepAliveResultTag
}

func (_m *BaseSocketGetKeepAliveResult) Ordinal() uint64 {
	return uint64(_m.I_baseSocketGetKeepAliveResultTag)
}

func (_m *BaseSocketGetKeepAliveResult) SetResponse(response BaseSocketGetKeepAliveResponse) {
	_m.reset()
	_m.I_baseSocketGetKeepAliveResultTag = BaseSocketGetKeepAliveResultResponse
	_m.Response = response
}

func BaseSocketGetKeepAliveResultWithResponse(response BaseSocketGetKeepAliveResponse) BaseSocketGetKeepAliveResult {
	var _u BaseSocketGetKeepAliveResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseSocketGetKeepAliveResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseSocketGetKeepAliveResultTag = BaseSocketGetKeepAliveResultErr
	_m.Err = err
}

func BaseSocketGetKeepAliveResultWithErr(err fuchsiaposix.Errno) BaseSocketGetKeepAliveResult {
	var _u BaseSocketGetKeepAliveResult
	_u.SetErr(err)
	return _u
}

type I_baseSocketSetOutOfBandInlineResultTag uint64

const (
	BaseSocketSetOutOfBandInlineResultResponse = 1 // 0x00000001
	BaseSocketSetOutOfBandInlineResultErr      = 2 // 0x00000002
)

type BaseSocketSetOutOfBandInlineResult struct {
	I_baseSocketSetOutOfBandInlineResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                BaseSocketSetOutOfBandInlineResponse `fidl_ordinal:"1"`
	Err                                     fuchsiaposix.Errno                   `fidl_ordinal:"2"`
}

func (_m *BaseSocketSetOutOfBandInlineResult) reset() {
	switch _m.I_baseSocketSetOutOfBandInlineResultTag {
	case 1:
		var _zeroed BaseSocketSetOutOfBandInlineResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseSocketSetOutOfBandInlineResult) Which() I_baseSocketSetOutOfBandInlineResultTag {
	return _m.I_baseSocketSetOutOfBandInlineResultTag
}

func (_m *BaseSocketSetOutOfBandInlineResult) Ordinal() uint64 {
	return uint64(_m.I_baseSocketSetOutOfBandInlineResultTag)
}

func (_m *BaseSocketSetOutOfBandInlineResult) SetResponse(response BaseSocketSetOutOfBandInlineResponse) {
	_m.reset()
	_m.I_baseSocketSetOutOfBandInlineResultTag = BaseSocketSetOutOfBandInlineResultResponse
	_m.Response = response
}

func BaseSocketSetOutOfBandInlineResultWithResponse(response BaseSocketSetOutOfBandInlineResponse) BaseSocketSetOutOfBandInlineResult {
	var _u BaseSocketSetOutOfBandInlineResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseSocketSetOutOfBandInlineResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseSocketSetOutOfBandInlineResultTag = BaseSocketSetOutOfBandInlineResultErr
	_m.Err = err
}

func BaseSocketSetOutOfBandInlineResultWithErr(err fuchsiaposix.Errno) BaseSocketSetOutOfBandInlineResult {
	var _u BaseSocketSetOutOfBandInlineResult
	_u.SetErr(err)
	return _u
}

type I_baseSocketGetOutOfBandInlineResultTag uint64

const (
	BaseSocketGetOutOfBandInlineResultResponse = 1 // 0x00000001
	BaseSocketGetOutOfBandInlineResultErr      = 2 // 0x00000002
)

type BaseSocketGetOutOfBandInlineResult struct {
	I_baseSocketGetOutOfBandInlineResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                BaseSocketGetOutOfBandInlineResponse `fidl_ordinal:"1"`
	Err                                     fuchsiaposix.Errno                   `fidl_ordinal:"2"`
}

func (_m *BaseSocketGetOutOfBandInlineResult) reset() {
	switch _m.I_baseSocketGetOutOfBandInlineResultTag {
	case 1:
		var _zeroed BaseSocketGetOutOfBandInlineResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseSocketGetOutOfBandInlineResult) Which() I_baseSocketGetOutOfBandInlineResultTag {
	return _m.I_baseSocketGetOutOfBandInlineResultTag
}

func (_m *BaseSocketGetOutOfBandInlineResult) Ordinal() uint64 {
	return uint64(_m.I_baseSocketGetOutOfBandInlineResultTag)
}

func (_m *BaseSocketGetOutOfBandInlineResult) SetResponse(response BaseSocketGetOutOfBandInlineResponse) {
	_m.reset()
	_m.I_baseSocketGetOutOfBandInlineResultTag = BaseSocketGetOutOfBandInlineResultResponse
	_m.Response = response
}

func BaseSocketGetOutOfBandInlineResultWithResponse(response BaseSocketGetOutOfBandInlineResponse) BaseSocketGetOutOfBandInlineResult {
	var _u BaseSocketGetOutOfBandInlineResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseSocketGetOutOfBandInlineResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseSocketGetOutOfBandInlineResultTag = BaseSocketGetOutOfBandInlineResultErr
	_m.Err = err
}

func BaseSocketGetOutOfBandInlineResultWithErr(err fuchsiaposix.Errno) BaseSocketGetOutOfBandInlineResult {
	var _u BaseSocketGetOutOfBandInlineResult
	_u.SetErr(err)
	return _u
}

type I_baseSocketSetNoCheckResultTag uint64

const (
	BaseSocketSetNoCheckResultResponse = 1 // 0x00000001
	BaseSocketSetNoCheckResultErr      = 2 // 0x00000002
)

type BaseSocketSetNoCheckResult struct {
	I_baseSocketSetNoCheckResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                        BaseSocketSetNoCheckResponse `fidl_ordinal:"1"`
	Err                             fuchsiaposix.Errno           `fidl_ordinal:"2"`
}

func (_m *BaseSocketSetNoCheckResult) reset() {
	switch _m.I_baseSocketSetNoCheckResultTag {
	case 1:
		var _zeroed BaseSocketSetNoCheckResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseSocketSetNoCheckResult) Which() I_baseSocketSetNoCheckResultTag {
	return _m.I_baseSocketSetNoCheckResultTag
}

func (_m *BaseSocketSetNoCheckResult) Ordinal() uint64 {
	return uint64(_m.I_baseSocketSetNoCheckResultTag)
}

func (_m *BaseSocketSetNoCheckResult) SetResponse(response BaseSocketSetNoCheckResponse) {
	_m.reset()
	_m.I_baseSocketSetNoCheckResultTag = BaseSocketSetNoCheckResultResponse
	_m.Response = response
}

func BaseSocketSetNoCheckResultWithResponse(response BaseSocketSetNoCheckResponse) BaseSocketSetNoCheckResult {
	var _u BaseSocketSetNoCheckResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseSocketSetNoCheckResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseSocketSetNoCheckResultTag = BaseSocketSetNoCheckResultErr
	_m.Err = err
}

func BaseSocketSetNoCheckResultWithErr(err fuchsiaposix.Errno) BaseSocketSetNoCheckResult {
	var _u BaseSocketSetNoCheckResult
	_u.SetErr(err)
	return _u
}

type I_baseSocketGetNoCheckResultTag uint64

const (
	BaseSocketGetNoCheckResultResponse = 1 // 0x00000001
	BaseSocketGetNoCheckResultErr      = 2 // 0x00000002
)

type BaseSocketGetNoCheckResult struct {
	I_baseSocketGetNoCheckResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                        BaseSocketGetNoCheckResponse `fidl_ordinal:"1"`
	Err                             fuchsiaposix.Errno           `fidl_ordinal:"2"`
}

func (_m *BaseSocketGetNoCheckResult) reset() {
	switch _m.I_baseSocketGetNoCheckResultTag {
	case 1:
		var _zeroed BaseSocketGetNoCheckResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseSocketGetNoCheckResult) Which() I_baseSocketGetNoCheckResultTag {
	return _m.I_baseSocketGetNoCheckResultTag
}

func (_m *BaseSocketGetNoCheckResult) Ordinal() uint64 {
	return uint64(_m.I_baseSocketGetNoCheckResultTag)
}

func (_m *BaseSocketGetNoCheckResult) SetResponse(response BaseSocketGetNoCheckResponse) {
	_m.reset()
	_m.I_baseSocketGetNoCheckResultTag = BaseSocketGetNoCheckResultResponse
	_m.Response = response
}

func BaseSocketGetNoCheckResultWithResponse(response BaseSocketGetNoCheckResponse) BaseSocketGetNoCheckResult {
	var _u BaseSocketGetNoCheckResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseSocketGetNoCheckResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseSocketGetNoCheckResultTag = BaseSocketGetNoCheckResultErr
	_m.Err = err
}

func BaseSocketGetNoCheckResultWithErr(err fuchsiaposix.Errno) BaseSocketGetNoCheckResult {
	var _u BaseSocketGetNoCheckResult
	_u.SetErr(err)
	return _u
}

type I_baseSocketSetLingerResultTag uint64

const (
	BaseSocketSetLingerResultResponse = 1 // 0x00000001
	BaseSocketSetLingerResultErr      = 2 // 0x00000002
)

type BaseSocketSetLingerResult struct {
	I_baseSocketSetLingerResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                       BaseSocketSetLingerResponse `fidl_ordinal:"1"`
	Err                            fuchsiaposix.Errno          `fidl_ordinal:"2"`
}

func (_m *BaseSocketSetLingerResult) reset() {
	switch _m.I_baseSocketSetLingerResultTag {
	case 1:
		var _zeroed BaseSocketSetLingerResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseSocketSetLingerResult) Which() I_baseSocketSetLingerResultTag {
	return _m.I_baseSocketSetLingerResultTag
}

func (_m *BaseSocketSetLingerResult) Ordinal() uint64 {
	return uint64(_m.I_baseSocketSetLingerResultTag)
}

func (_m *BaseSocketSetLingerResult) SetResponse(response BaseSocketSetLingerResponse) {
	_m.reset()
	_m.I_baseSocketSetLingerResultTag = BaseSocketSetLingerResultResponse
	_m.Response = response
}

func BaseSocketSetLingerResultWithResponse(response BaseSocketSetLingerResponse) BaseSocketSetLingerResult {
	var _u BaseSocketSetLingerResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseSocketSetLingerResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseSocketSetLingerResultTag = BaseSocketSetLingerResultErr
	_m.Err = err
}

func BaseSocketSetLingerResultWithErr(err fuchsiaposix.Errno) BaseSocketSetLingerResult {
	var _u BaseSocketSetLingerResult
	_u.SetErr(err)
	return _u
}

type I_baseSocketGetLingerResultTag uint64

const (
	BaseSocketGetLingerResultResponse = 1 // 0x00000001
	BaseSocketGetLingerResultErr      = 2 // 0x00000002
)

type BaseSocketGetLingerResult struct {
	I_baseSocketGetLingerResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                       BaseSocketGetLingerResponse `fidl_ordinal:"1"`
	Err                            fuchsiaposix.Errno          `fidl_ordinal:"2"`
}

func (_m *BaseSocketGetLingerResult) reset() {
	switch _m.I_baseSocketGetLingerResultTag {
	case 1:
		var _zeroed BaseSocketGetLingerResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseSocketGetLingerResult) Which() I_baseSocketGetLingerResultTag {
	return _m.I_baseSocketGetLingerResultTag
}

func (_m *BaseSocketGetLingerResult) Ordinal() uint64 {
	return uint64(_m.I_baseSocketGetLingerResultTag)
}

func (_m *BaseSocketGetLingerResult) SetResponse(response BaseSocketGetLingerResponse) {
	_m.reset()
	_m.I_baseSocketGetLingerResultTag = BaseSocketGetLingerResultResponse
	_m.Response = response
}

func BaseSocketGetLingerResultWithResponse(response BaseSocketGetLingerResponse) BaseSocketGetLingerResult {
	var _u BaseSocketGetLingerResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseSocketGetLingerResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseSocketGetLingerResultTag = BaseSocketGetLingerResultErr
	_m.Err = err
}

func BaseSocketGetLingerResultWithErr(err fuchsiaposix.Errno) BaseSocketGetLingerResult {
	var _u BaseSocketGetLingerResult
	_u.SetErr(err)
	return _u
}

type I_baseSocketSetReusePortResultTag uint64

const (
	BaseSocketSetReusePortResultResponse = 1 // 0x00000001
	BaseSocketSetReusePortResultErr      = 2 // 0x00000002
)

type BaseSocketSetReusePortResult struct {
	I_baseSocketSetReusePortResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                          BaseSocketSetReusePortResponse `fidl_ordinal:"1"`
	Err                               fuchsiaposix.Errno             `fidl_ordinal:"2"`
}

func (_m *BaseSocketSetReusePortResult) reset() {
	switch _m.I_baseSocketSetReusePortResultTag {
	case 1:
		var _zeroed BaseSocketSetReusePortResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseSocketSetReusePortResult) Which() I_baseSocketSetReusePortResultTag {
	return _m.I_baseSocketSetReusePortResultTag
}

func (_m *BaseSocketSetReusePortResult) Ordinal() uint64 {
	return uint64(_m.I_baseSocketSetReusePortResultTag)
}

func (_m *BaseSocketSetReusePortResult) SetResponse(response BaseSocketSetReusePortResponse) {
	_m.reset()
	_m.I_baseSocketSetReusePortResultTag = BaseSocketSetReusePortResultResponse
	_m.Response = response
}

func BaseSocketSetReusePortResultWithResponse(response BaseSocketSetReusePortResponse) BaseSocketSetReusePortResult {
	var _u BaseSocketSetReusePortResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseSocketSetReusePortResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseSocketSetReusePortResultTag = BaseSocketSetReusePortResultErr
	_m.Err = err
}

func BaseSocketSetReusePortResultWithErr(err fuchsiaposix.Errno) BaseSocketSetReusePortResult {
	var _u BaseSocketSetReusePortResult
	_u.SetErr(err)
	return _u
}

type I_baseSocketGetReusePortResultTag uint64

const (
	BaseSocketGetReusePortResultResponse = 1 // 0x00000001
	BaseSocketGetReusePortResultErr      = 2 // 0x00000002
)

type BaseSocketGetReusePortResult struct {
	I_baseSocketGetReusePortResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                          BaseSocketGetReusePortResponse `fidl_ordinal:"1"`
	Err                               fuchsiaposix.Errno             `fidl_ordinal:"2"`
}

func (_m *BaseSocketGetReusePortResult) reset() {
	switch _m.I_baseSocketGetReusePortResultTag {
	case 1:
		var _zeroed BaseSocketGetReusePortResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseSocketGetReusePortResult) Which() I_baseSocketGetReusePortResultTag {
	return _m.I_baseSocketGetReusePortResultTag
}

func (_m *BaseSocketGetReusePortResult) Ordinal() uint64 {
	return uint64(_m.I_baseSocketGetReusePortResultTag)
}

func (_m *BaseSocketGetReusePortResult) SetResponse(response BaseSocketGetReusePortResponse) {
	_m.reset()
	_m.I_baseSocketGetReusePortResultTag = BaseSocketGetReusePortResultResponse
	_m.Response = response
}

func BaseSocketGetReusePortResultWithResponse(response BaseSocketGetReusePortResponse) BaseSocketGetReusePortResult {
	var _u BaseSocketGetReusePortResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseSocketGetReusePortResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseSocketGetReusePortResultTag = BaseSocketGetReusePortResultErr
	_m.Err = err
}

func BaseSocketGetReusePortResultWithErr(err fuchsiaposix.Errno) BaseSocketGetReusePortResult {
	var _u BaseSocketGetReusePortResult
	_u.SetErr(err)
	return _u
}

type I_baseSocketGetAcceptConnResultTag uint64

const (
	BaseSocketGetAcceptConnResultResponse = 1 // 0x00000001
	BaseSocketGetAcceptConnResultErr      = 2 // 0x00000002
)

type BaseSocketGetAcceptConnResult struct {
	I_baseSocketGetAcceptConnResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                           BaseSocketGetAcceptConnResponse `fidl_ordinal:"1"`
	Err                                fuchsiaposix.Errno              `fidl_ordinal:"2"`
}

func (_m *BaseSocketGetAcceptConnResult) reset() {
	switch _m.I_baseSocketGetAcceptConnResultTag {
	case 1:
		var _zeroed BaseSocketGetAcceptConnResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseSocketGetAcceptConnResult) Which() I_baseSocketGetAcceptConnResultTag {
	return _m.I_baseSocketGetAcceptConnResultTag
}

func (_m *BaseSocketGetAcceptConnResult) Ordinal() uint64 {
	return uint64(_m.I_baseSocketGetAcceptConnResultTag)
}

func (_m *BaseSocketGetAcceptConnResult) SetResponse(response BaseSocketGetAcceptConnResponse) {
	_m.reset()
	_m.I_baseSocketGetAcceptConnResultTag = BaseSocketGetAcceptConnResultResponse
	_m.Response = response
}

func BaseSocketGetAcceptConnResultWithResponse(response BaseSocketGetAcceptConnResponse) BaseSocketGetAcceptConnResult {
	var _u BaseSocketGetAcceptConnResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseSocketGetAcceptConnResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseSocketGetAcceptConnResultTag = BaseSocketGetAcceptConnResultErr
	_m.Err = err
}

func BaseSocketGetAcceptConnResultWithErr(err fuchsiaposix.Errno) BaseSocketGetAcceptConnResult {
	var _u BaseSocketGetAcceptConnResult
	_u.SetErr(err)
	return _u
}

type I_baseSocketSetBindToDeviceResultTag uint64

const (
	BaseSocketSetBindToDeviceResultResponse = 1 // 0x00000001
	BaseSocketSetBindToDeviceResultErr      = 2 // 0x00000002
)

type BaseSocketSetBindToDeviceResult struct {
	I_baseSocketSetBindToDeviceResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                             BaseSocketSetBindToDeviceResponse `fidl_ordinal:"1"`
	Err                                  fuchsiaposix.Errno                `fidl_ordinal:"2"`
}

func (_m *BaseSocketSetBindToDeviceResult) reset() {
	switch _m.I_baseSocketSetBindToDeviceResultTag {
	case 1:
		var _zeroed BaseSocketSetBindToDeviceResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseSocketSetBindToDeviceResult) Which() I_baseSocketSetBindToDeviceResultTag {
	return _m.I_baseSocketSetBindToDeviceResultTag
}

func (_m *BaseSocketSetBindToDeviceResult) Ordinal() uint64 {
	return uint64(_m.I_baseSocketSetBindToDeviceResultTag)
}

func (_m *BaseSocketSetBindToDeviceResult) SetResponse(response BaseSocketSetBindToDeviceResponse) {
	_m.reset()
	_m.I_baseSocketSetBindToDeviceResultTag = BaseSocketSetBindToDeviceResultResponse
	_m.Response = response
}

func BaseSocketSetBindToDeviceResultWithResponse(response BaseSocketSetBindToDeviceResponse) BaseSocketSetBindToDeviceResult {
	var _u BaseSocketSetBindToDeviceResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseSocketSetBindToDeviceResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseSocketSetBindToDeviceResultTag = BaseSocketSetBindToDeviceResultErr
	_m.Err = err
}

func BaseSocketSetBindToDeviceResultWithErr(err fuchsiaposix.Errno) BaseSocketSetBindToDeviceResult {
	var _u BaseSocketSetBindToDeviceResult
	_u.SetErr(err)
	return _u
}

type I_baseSocketGetBindToDeviceResultTag uint64

const (
	BaseSocketGetBindToDeviceResultResponse = 1 // 0x00000001
	BaseSocketGetBindToDeviceResultErr      = 2 // 0x00000002
)

type BaseSocketGetBindToDeviceResult struct {
	I_baseSocketGetBindToDeviceResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                             BaseSocketGetBindToDeviceResponse `fidl_ordinal:"1"`
	Err                                  fuchsiaposix.Errno                `fidl_ordinal:"2"`
}

func (_m *BaseSocketGetBindToDeviceResult) reset() {
	switch _m.I_baseSocketGetBindToDeviceResultTag {
	case 1:
		var _zeroed BaseSocketGetBindToDeviceResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseSocketGetBindToDeviceResult) Which() I_baseSocketGetBindToDeviceResultTag {
	return _m.I_baseSocketGetBindToDeviceResultTag
}

func (_m *BaseSocketGetBindToDeviceResult) Ordinal() uint64 {
	return uint64(_m.I_baseSocketGetBindToDeviceResultTag)
}

func (_m *BaseSocketGetBindToDeviceResult) SetResponse(response BaseSocketGetBindToDeviceResponse) {
	_m.reset()
	_m.I_baseSocketGetBindToDeviceResultTag = BaseSocketGetBindToDeviceResultResponse
	_m.Response = response
}

func BaseSocketGetBindToDeviceResultWithResponse(response BaseSocketGetBindToDeviceResponse) BaseSocketGetBindToDeviceResult {
	var _u BaseSocketGetBindToDeviceResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseSocketGetBindToDeviceResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseSocketGetBindToDeviceResultTag = BaseSocketGetBindToDeviceResultErr
	_m.Err = err
}

func BaseSocketGetBindToDeviceResultWithErr(err fuchsiaposix.Errno) BaseSocketGetBindToDeviceResult {
	var _u BaseSocketGetBindToDeviceResult
	_u.SetErr(err)
	return _u
}

type I_baseSocketSetTimestampResultTag uint64

const (
	BaseSocketSetTimestampResultResponse = 1 // 0x00000001
	BaseSocketSetTimestampResultErr      = 2 // 0x00000002
)

type BaseSocketSetTimestampResult struct {
	I_baseSocketSetTimestampResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                          BaseSocketSetTimestampResponse `fidl_ordinal:"1"`
	Err                               fuchsiaposix.Errno             `fidl_ordinal:"2"`
}

func (_m *BaseSocketSetTimestampResult) reset() {
	switch _m.I_baseSocketSetTimestampResultTag {
	case 1:
		var _zeroed BaseSocketSetTimestampResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseSocketSetTimestampResult) Which() I_baseSocketSetTimestampResultTag {
	return _m.I_baseSocketSetTimestampResultTag
}

func (_m *BaseSocketSetTimestampResult) Ordinal() uint64 {
	return uint64(_m.I_baseSocketSetTimestampResultTag)
}

func (_m *BaseSocketSetTimestampResult) SetResponse(response BaseSocketSetTimestampResponse) {
	_m.reset()
	_m.I_baseSocketSetTimestampResultTag = BaseSocketSetTimestampResultResponse
	_m.Response = response
}

func BaseSocketSetTimestampResultWithResponse(response BaseSocketSetTimestampResponse) BaseSocketSetTimestampResult {
	var _u BaseSocketSetTimestampResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseSocketSetTimestampResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseSocketSetTimestampResultTag = BaseSocketSetTimestampResultErr
	_m.Err = err
}

func BaseSocketSetTimestampResultWithErr(err fuchsiaposix.Errno) BaseSocketSetTimestampResult {
	var _u BaseSocketSetTimestampResult
	_u.SetErr(err)
	return _u
}

type I_baseSocketGetTimestampResultTag uint64

const (
	BaseSocketGetTimestampResultResponse = 1 // 0x00000001
	BaseSocketGetTimestampResultErr      = 2 // 0x00000002
)

type BaseSocketGetTimestampResult struct {
	I_baseSocketGetTimestampResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                          BaseSocketGetTimestampResponse `fidl_ordinal:"1"`
	Err                               fuchsiaposix.Errno             `fidl_ordinal:"2"`
}

func (_m *BaseSocketGetTimestampResult) reset() {
	switch _m.I_baseSocketGetTimestampResultTag {
	case 1:
		var _zeroed BaseSocketGetTimestampResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseSocketGetTimestampResult) Which() I_baseSocketGetTimestampResultTag {
	return _m.I_baseSocketGetTimestampResultTag
}

func (_m *BaseSocketGetTimestampResult) Ordinal() uint64 {
	return uint64(_m.I_baseSocketGetTimestampResultTag)
}

func (_m *BaseSocketGetTimestampResult) SetResponse(response BaseSocketGetTimestampResponse) {
	_m.reset()
	_m.I_baseSocketGetTimestampResultTag = BaseSocketGetTimestampResultResponse
	_m.Response = response
}

func BaseSocketGetTimestampResultWithResponse(response BaseSocketGetTimestampResponse) BaseSocketGetTimestampResult {
	var _u BaseSocketGetTimestampResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseSocketGetTimestampResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseSocketGetTimestampResultTag = BaseSocketGetTimestampResultErr
	_m.Err = err
}

func BaseSocketGetTimestampResultWithErr(err fuchsiaposix.Errno) BaseSocketGetTimestampResult {
	var _u BaseSocketGetTimestampResult
	_u.SetErr(err)
	return _u
}

type I_baseSocketSetIpTypeOfServiceResultTag uint64

const (
	BaseSocketSetIpTypeOfServiceResultResponse = 1 // 0x00000001
	BaseSocketSetIpTypeOfServiceResultErr      = 2 // 0x00000002
)

type BaseSocketSetIpTypeOfServiceResult struct {
	I_baseSocketSetIpTypeOfServiceResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                BaseSocketSetIpTypeOfServiceResponse `fidl_ordinal:"1"`
	Err                                     fuchsiaposix.Errno                   `fidl_ordinal:"2"`
}

func (_m *BaseSocketSetIpTypeOfServiceResult) reset() {
	switch _m.I_baseSocketSetIpTypeOfServiceResultTag {
	case 1:
		var _zeroed BaseSocketSetIpTypeOfServiceResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseSocketSetIpTypeOfServiceResult) Which() I_baseSocketSetIpTypeOfServiceResultTag {
	return _m.I_baseSocketSetIpTypeOfServiceResultTag
}

func (_m *BaseSocketSetIpTypeOfServiceResult) Ordinal() uint64 {
	return uint64(_m.I_baseSocketSetIpTypeOfServiceResultTag)
}

func (_m *BaseSocketSetIpTypeOfServiceResult) SetResponse(response BaseSocketSetIpTypeOfServiceResponse) {
	_m.reset()
	_m.I_baseSocketSetIpTypeOfServiceResultTag = BaseSocketSetIpTypeOfServiceResultResponse
	_m.Response = response
}

func BaseSocketSetIpTypeOfServiceResultWithResponse(response BaseSocketSetIpTypeOfServiceResponse) BaseSocketSetIpTypeOfServiceResult {
	var _u BaseSocketSetIpTypeOfServiceResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseSocketSetIpTypeOfServiceResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseSocketSetIpTypeOfServiceResultTag = BaseSocketSetIpTypeOfServiceResultErr
	_m.Err = err
}

func BaseSocketSetIpTypeOfServiceResultWithErr(err fuchsiaposix.Errno) BaseSocketSetIpTypeOfServiceResult {
	var _u BaseSocketSetIpTypeOfServiceResult
	_u.SetErr(err)
	return _u
}

type I_baseSocketGetIpTypeOfServiceResultTag uint64

const (
	BaseSocketGetIpTypeOfServiceResultResponse = 1 // 0x00000001
	BaseSocketGetIpTypeOfServiceResultErr      = 2 // 0x00000002
)

type BaseSocketGetIpTypeOfServiceResult struct {
	I_baseSocketGetIpTypeOfServiceResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                BaseSocketGetIpTypeOfServiceResponse `fidl_ordinal:"1"`
	Err                                     fuchsiaposix.Errno                   `fidl_ordinal:"2"`
}

func (_m *BaseSocketGetIpTypeOfServiceResult) reset() {
	switch _m.I_baseSocketGetIpTypeOfServiceResultTag {
	case 1:
		var _zeroed BaseSocketGetIpTypeOfServiceResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseSocketGetIpTypeOfServiceResult) Which() I_baseSocketGetIpTypeOfServiceResultTag {
	return _m.I_baseSocketGetIpTypeOfServiceResultTag
}

func (_m *BaseSocketGetIpTypeOfServiceResult) Ordinal() uint64 {
	return uint64(_m.I_baseSocketGetIpTypeOfServiceResultTag)
}

func (_m *BaseSocketGetIpTypeOfServiceResult) SetResponse(response BaseSocketGetIpTypeOfServiceResponse) {
	_m.reset()
	_m.I_baseSocketGetIpTypeOfServiceResultTag = BaseSocketGetIpTypeOfServiceResultResponse
	_m.Response = response
}

func BaseSocketGetIpTypeOfServiceResultWithResponse(response BaseSocketGetIpTypeOfServiceResponse) BaseSocketGetIpTypeOfServiceResult {
	var _u BaseSocketGetIpTypeOfServiceResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseSocketGetIpTypeOfServiceResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseSocketGetIpTypeOfServiceResultTag = BaseSocketGetIpTypeOfServiceResultErr
	_m.Err = err
}

func BaseSocketGetIpTypeOfServiceResultWithErr(err fuchsiaposix.Errno) BaseSocketGetIpTypeOfServiceResult {
	var _u BaseSocketGetIpTypeOfServiceResult
	_u.SetErr(err)
	return _u
}

type I_baseSocketSetIpTtlResultTag uint64

const (
	BaseSocketSetIpTtlResultResponse = 1 // 0x00000001
	BaseSocketSetIpTtlResultErr      = 2 // 0x00000002
)

type BaseSocketSetIpTtlResult struct {
	I_baseSocketSetIpTtlResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                      BaseSocketSetIpTtlResponse `fidl_ordinal:"1"`
	Err                           fuchsiaposix.Errno         `fidl_ordinal:"2"`
}

func (_m *BaseSocketSetIpTtlResult) reset() {
	switch _m.I_baseSocketSetIpTtlResultTag {
	case 1:
		var _zeroed BaseSocketSetIpTtlResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseSocketSetIpTtlResult) Which() I_baseSocketSetIpTtlResultTag {
	return _m.I_baseSocketSetIpTtlResultTag
}

func (_m *BaseSocketSetIpTtlResult) Ordinal() uint64 {
	return uint64(_m.I_baseSocketSetIpTtlResultTag)
}

func (_m *BaseSocketSetIpTtlResult) SetResponse(response BaseSocketSetIpTtlResponse) {
	_m.reset()
	_m.I_baseSocketSetIpTtlResultTag = BaseSocketSetIpTtlResultResponse
	_m.Response = response
}

func BaseSocketSetIpTtlResultWithResponse(response BaseSocketSetIpTtlResponse) BaseSocketSetIpTtlResult {
	var _u BaseSocketSetIpTtlResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseSocketSetIpTtlResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseSocketSetIpTtlResultTag = BaseSocketSetIpTtlResultErr
	_m.Err = err
}

func BaseSocketSetIpTtlResultWithErr(err fuchsiaposix.Errno) BaseSocketSetIpTtlResult {
	var _u BaseSocketSetIpTtlResult
	_u.SetErr(err)
	return _u
}

type I_baseSocketGetIpTtlResultTag uint64

const (
	BaseSocketGetIpTtlResultResponse = 1 // 0x00000001
	BaseSocketGetIpTtlResultErr      = 2 // 0x00000002
)

type BaseSocketGetIpTtlResult struct {
	I_baseSocketGetIpTtlResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                      BaseSocketGetIpTtlResponse `fidl_ordinal:"1"`
	Err                           fuchsiaposix.Errno         `fidl_ordinal:"2"`
}

func (_m *BaseSocketGetIpTtlResult) reset() {
	switch _m.I_baseSocketGetIpTtlResultTag {
	case 1:
		var _zeroed BaseSocketGetIpTtlResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseSocketGetIpTtlResult) Which() I_baseSocketGetIpTtlResultTag {
	return _m.I_baseSocketGetIpTtlResultTag
}

func (_m *BaseSocketGetIpTtlResult) Ordinal() uint64 {
	return uint64(_m.I_baseSocketGetIpTtlResultTag)
}

func (_m *BaseSocketGetIpTtlResult) SetResponse(response BaseSocketGetIpTtlResponse) {
	_m.reset()
	_m.I_baseSocketGetIpTtlResultTag = BaseSocketGetIpTtlResultResponse
	_m.Response = response
}

func BaseSocketGetIpTtlResultWithResponse(response BaseSocketGetIpTtlResponse) BaseSocketGetIpTtlResult {
	var _u BaseSocketGetIpTtlResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseSocketGetIpTtlResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseSocketGetIpTtlResultTag = BaseSocketGetIpTtlResultErr
	_m.Err = err
}

func BaseSocketGetIpTtlResultWithErr(err fuchsiaposix.Errno) BaseSocketGetIpTtlResult {
	var _u BaseSocketGetIpTtlResult
	_u.SetErr(err)
	return _u
}

type I_baseSocketSetIpPacketInfoResultTag uint64

const (
	BaseSocketSetIpPacketInfoResultResponse = 1 // 0x00000001
	BaseSocketSetIpPacketInfoResultErr      = 2 // 0x00000002
)

type BaseSocketSetIpPacketInfoResult struct {
	I_baseSocketSetIpPacketInfoResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                             BaseSocketSetIpPacketInfoResponse `fidl_ordinal:"1"`
	Err                                  fuchsiaposix.Errno                `fidl_ordinal:"2"`
}

func (_m *BaseSocketSetIpPacketInfoResult) reset() {
	switch _m.I_baseSocketSetIpPacketInfoResultTag {
	case 1:
		var _zeroed BaseSocketSetIpPacketInfoResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseSocketSetIpPacketInfoResult) Which() I_baseSocketSetIpPacketInfoResultTag {
	return _m.I_baseSocketSetIpPacketInfoResultTag
}

func (_m *BaseSocketSetIpPacketInfoResult) Ordinal() uint64 {
	return uint64(_m.I_baseSocketSetIpPacketInfoResultTag)
}

func (_m *BaseSocketSetIpPacketInfoResult) SetResponse(response BaseSocketSetIpPacketInfoResponse) {
	_m.reset()
	_m.I_baseSocketSetIpPacketInfoResultTag = BaseSocketSetIpPacketInfoResultResponse
	_m.Response = response
}

func BaseSocketSetIpPacketInfoResultWithResponse(response BaseSocketSetIpPacketInfoResponse) BaseSocketSetIpPacketInfoResult {
	var _u BaseSocketSetIpPacketInfoResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseSocketSetIpPacketInfoResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseSocketSetIpPacketInfoResultTag = BaseSocketSetIpPacketInfoResultErr
	_m.Err = err
}

func BaseSocketSetIpPacketInfoResultWithErr(err fuchsiaposix.Errno) BaseSocketSetIpPacketInfoResult {
	var _u BaseSocketSetIpPacketInfoResult
	_u.SetErr(err)
	return _u
}

type I_baseSocketGetIpPacketInfoResultTag uint64

const (
	BaseSocketGetIpPacketInfoResultResponse = 1 // 0x00000001
	BaseSocketGetIpPacketInfoResultErr      = 2 // 0x00000002
)

type BaseSocketGetIpPacketInfoResult struct {
	I_baseSocketGetIpPacketInfoResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                             BaseSocketGetIpPacketInfoResponse `fidl_ordinal:"1"`
	Err                                  fuchsiaposix.Errno                `fidl_ordinal:"2"`
}

func (_m *BaseSocketGetIpPacketInfoResult) reset() {
	switch _m.I_baseSocketGetIpPacketInfoResultTag {
	case 1:
		var _zeroed BaseSocketGetIpPacketInfoResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseSocketGetIpPacketInfoResult) Which() I_baseSocketGetIpPacketInfoResultTag {
	return _m.I_baseSocketGetIpPacketInfoResultTag
}

func (_m *BaseSocketGetIpPacketInfoResult) Ordinal() uint64 {
	return uint64(_m.I_baseSocketGetIpPacketInfoResultTag)
}

func (_m *BaseSocketGetIpPacketInfoResult) SetResponse(response BaseSocketGetIpPacketInfoResponse) {
	_m.reset()
	_m.I_baseSocketGetIpPacketInfoResultTag = BaseSocketGetIpPacketInfoResultResponse
	_m.Response = response
}

func BaseSocketGetIpPacketInfoResultWithResponse(response BaseSocketGetIpPacketInfoResponse) BaseSocketGetIpPacketInfoResult {
	var _u BaseSocketGetIpPacketInfoResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseSocketGetIpPacketInfoResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseSocketGetIpPacketInfoResultTag = BaseSocketGetIpPacketInfoResultErr
	_m.Err = err
}

func BaseSocketGetIpPacketInfoResultWithErr(err fuchsiaposix.Errno) BaseSocketGetIpPacketInfoResult {
	var _u BaseSocketGetIpPacketInfoResult
	_u.SetErr(err)
	return _u
}

type I_baseSocketSetIpReceiveTypeOfServiceResultTag uint64

const (
	BaseSocketSetIpReceiveTypeOfServiceResultResponse = 1 // 0x00000001
	BaseSocketSetIpReceiveTypeOfServiceResultErr      = 2 // 0x00000002
)

type BaseSocketSetIpReceiveTypeOfServiceResult struct {
	I_baseSocketSetIpReceiveTypeOfServiceResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                       BaseSocketSetIpReceiveTypeOfServiceResponse `fidl_ordinal:"1"`
	Err                                            fuchsiaposix.Errno                          `fidl_ordinal:"2"`
}

func (_m *BaseSocketSetIpReceiveTypeOfServiceResult) reset() {
	switch _m.I_baseSocketSetIpReceiveTypeOfServiceResultTag {
	case 1:
		var _zeroed BaseSocketSetIpReceiveTypeOfServiceResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseSocketSetIpReceiveTypeOfServiceResult) Which() I_baseSocketSetIpReceiveTypeOfServiceResultTag {
	return _m.I_baseSocketSetIpReceiveTypeOfServiceResultTag
}

func (_m *BaseSocketSetIpReceiveTypeOfServiceResult) Ordinal() uint64 {
	return uint64(_m.I_baseSocketSetIpReceiveTypeOfServiceResultTag)
}

func (_m *BaseSocketSetIpReceiveTypeOfServiceResult) SetResponse(response BaseSocketSetIpReceiveTypeOfServiceResponse) {
	_m.reset()
	_m.I_baseSocketSetIpReceiveTypeOfServiceResultTag = BaseSocketSetIpReceiveTypeOfServiceResultResponse
	_m.Response = response
}

func BaseSocketSetIpReceiveTypeOfServiceResultWithResponse(response BaseSocketSetIpReceiveTypeOfServiceResponse) BaseSocketSetIpReceiveTypeOfServiceResult {
	var _u BaseSocketSetIpReceiveTypeOfServiceResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseSocketSetIpReceiveTypeOfServiceResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseSocketSetIpReceiveTypeOfServiceResultTag = BaseSocketSetIpReceiveTypeOfServiceResultErr
	_m.Err = err
}

func BaseSocketSetIpReceiveTypeOfServiceResultWithErr(err fuchsiaposix.Errno) BaseSocketSetIpReceiveTypeOfServiceResult {
	var _u BaseSocketSetIpReceiveTypeOfServiceResult
	_u.SetErr(err)
	return _u
}

type I_baseSocketGetIpReceiveTypeOfServiceResultTag uint64

const (
	BaseSocketGetIpReceiveTypeOfServiceResultResponse = 1 // 0x00000001
	BaseSocketGetIpReceiveTypeOfServiceResultErr      = 2 // 0x00000002
)

type BaseSocketGetIpReceiveTypeOfServiceResult struct {
	I_baseSocketGetIpReceiveTypeOfServiceResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                       BaseSocketGetIpReceiveTypeOfServiceResponse `fidl_ordinal:"1"`
	Err                                            fuchsiaposix.Errno                          `fidl_ordinal:"2"`
}

func (_m *BaseSocketGetIpReceiveTypeOfServiceResult) reset() {
	switch _m.I_baseSocketGetIpReceiveTypeOfServiceResultTag {
	case 1:
		var _zeroed BaseSocketGetIpReceiveTypeOfServiceResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseSocketGetIpReceiveTypeOfServiceResult) Which() I_baseSocketGetIpReceiveTypeOfServiceResultTag {
	return _m.I_baseSocketGetIpReceiveTypeOfServiceResultTag
}

func (_m *BaseSocketGetIpReceiveTypeOfServiceResult) Ordinal() uint64 {
	return uint64(_m.I_baseSocketGetIpReceiveTypeOfServiceResultTag)
}

func (_m *BaseSocketGetIpReceiveTypeOfServiceResult) SetResponse(response BaseSocketGetIpReceiveTypeOfServiceResponse) {
	_m.reset()
	_m.I_baseSocketGetIpReceiveTypeOfServiceResultTag = BaseSocketGetIpReceiveTypeOfServiceResultResponse
	_m.Response = response
}

func BaseSocketGetIpReceiveTypeOfServiceResultWithResponse(response BaseSocketGetIpReceiveTypeOfServiceResponse) BaseSocketGetIpReceiveTypeOfServiceResult {
	var _u BaseSocketGetIpReceiveTypeOfServiceResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseSocketGetIpReceiveTypeOfServiceResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseSocketGetIpReceiveTypeOfServiceResultTag = BaseSocketGetIpReceiveTypeOfServiceResultErr
	_m.Err = err
}

func BaseSocketGetIpReceiveTypeOfServiceResultWithErr(err fuchsiaposix.Errno) BaseSocketGetIpReceiveTypeOfServiceResult {
	var _u BaseSocketGetIpReceiveTypeOfServiceResult
	_u.SetErr(err)
	return _u
}

type I_baseSocketSetIpMulticastInterfaceResultTag uint64

const (
	BaseSocketSetIpMulticastInterfaceResultResponse = 1 // 0x00000001
	BaseSocketSetIpMulticastInterfaceResultErr      = 2 // 0x00000002
)

type BaseSocketSetIpMulticastInterfaceResult struct {
	I_baseSocketSetIpMulticastInterfaceResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                     BaseSocketSetIpMulticastInterfaceResponse `fidl_ordinal:"1"`
	Err                                          fuchsiaposix.Errno                        `fidl_ordinal:"2"`
}

func (_m *BaseSocketSetIpMulticastInterfaceResult) reset() {
	switch _m.I_baseSocketSetIpMulticastInterfaceResultTag {
	case 1:
		var _zeroed BaseSocketSetIpMulticastInterfaceResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseSocketSetIpMulticastInterfaceResult) Which() I_baseSocketSetIpMulticastInterfaceResultTag {
	return _m.I_baseSocketSetIpMulticastInterfaceResultTag
}

func (_m *BaseSocketSetIpMulticastInterfaceResult) Ordinal() uint64 {
	return uint64(_m.I_baseSocketSetIpMulticastInterfaceResultTag)
}

func (_m *BaseSocketSetIpMulticastInterfaceResult) SetResponse(response BaseSocketSetIpMulticastInterfaceResponse) {
	_m.reset()
	_m.I_baseSocketSetIpMulticastInterfaceResultTag = BaseSocketSetIpMulticastInterfaceResultResponse
	_m.Response = response
}

func BaseSocketSetIpMulticastInterfaceResultWithResponse(response BaseSocketSetIpMulticastInterfaceResponse) BaseSocketSetIpMulticastInterfaceResult {
	var _u BaseSocketSetIpMulticastInterfaceResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseSocketSetIpMulticastInterfaceResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseSocketSetIpMulticastInterfaceResultTag = BaseSocketSetIpMulticastInterfaceResultErr
	_m.Err = err
}

func BaseSocketSetIpMulticastInterfaceResultWithErr(err fuchsiaposix.Errno) BaseSocketSetIpMulticastInterfaceResult {
	var _u BaseSocketSetIpMulticastInterfaceResult
	_u.SetErr(err)
	return _u
}

type I_baseSocketGetIpMulticastInterfaceResultTag uint64

const (
	BaseSocketGetIpMulticastInterfaceResultResponse = 1 // 0x00000001
	BaseSocketGetIpMulticastInterfaceResultErr      = 2 // 0x00000002
)

type BaseSocketGetIpMulticastInterfaceResult struct {
	I_baseSocketGetIpMulticastInterfaceResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                     BaseSocketGetIpMulticastInterfaceResponse `fidl_ordinal:"1"`
	Err                                          fuchsiaposix.Errno                        `fidl_ordinal:"2"`
}

func (_m *BaseSocketGetIpMulticastInterfaceResult) reset() {
	switch _m.I_baseSocketGetIpMulticastInterfaceResultTag {
	case 1:
		var _zeroed BaseSocketGetIpMulticastInterfaceResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseSocketGetIpMulticastInterfaceResult) Which() I_baseSocketGetIpMulticastInterfaceResultTag {
	return _m.I_baseSocketGetIpMulticastInterfaceResultTag
}

func (_m *BaseSocketGetIpMulticastInterfaceResult) Ordinal() uint64 {
	return uint64(_m.I_baseSocketGetIpMulticastInterfaceResultTag)
}

func (_m *BaseSocketGetIpMulticastInterfaceResult) SetResponse(response BaseSocketGetIpMulticastInterfaceResponse) {
	_m.reset()
	_m.I_baseSocketGetIpMulticastInterfaceResultTag = BaseSocketGetIpMulticastInterfaceResultResponse
	_m.Response = response
}

func BaseSocketGetIpMulticastInterfaceResultWithResponse(response BaseSocketGetIpMulticastInterfaceResponse) BaseSocketGetIpMulticastInterfaceResult {
	var _u BaseSocketGetIpMulticastInterfaceResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseSocketGetIpMulticastInterfaceResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseSocketGetIpMulticastInterfaceResultTag = BaseSocketGetIpMulticastInterfaceResultErr
	_m.Err = err
}

func BaseSocketGetIpMulticastInterfaceResultWithErr(err fuchsiaposix.Errno) BaseSocketGetIpMulticastInterfaceResult {
	var _u BaseSocketGetIpMulticastInterfaceResult
	_u.SetErr(err)
	return _u
}

type I_baseSocketSetIpMulticastTtlResultTag uint64

const (
	BaseSocketSetIpMulticastTtlResultResponse = 1 // 0x00000001
	BaseSocketSetIpMulticastTtlResultErr      = 2 // 0x00000002
)

type BaseSocketSetIpMulticastTtlResult struct {
	I_baseSocketSetIpMulticastTtlResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                               BaseSocketSetIpMulticastTtlResponse `fidl_ordinal:"1"`
	Err                                    fuchsiaposix.Errno                  `fidl_ordinal:"2"`
}

func (_m *BaseSocketSetIpMulticastTtlResult) reset() {
	switch _m.I_baseSocketSetIpMulticastTtlResultTag {
	case 1:
		var _zeroed BaseSocketSetIpMulticastTtlResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseSocketSetIpMulticastTtlResult) Which() I_baseSocketSetIpMulticastTtlResultTag {
	return _m.I_baseSocketSetIpMulticastTtlResultTag
}

func (_m *BaseSocketSetIpMulticastTtlResult) Ordinal() uint64 {
	return uint64(_m.I_baseSocketSetIpMulticastTtlResultTag)
}

func (_m *BaseSocketSetIpMulticastTtlResult) SetResponse(response BaseSocketSetIpMulticastTtlResponse) {
	_m.reset()
	_m.I_baseSocketSetIpMulticastTtlResultTag = BaseSocketSetIpMulticastTtlResultResponse
	_m.Response = response
}

func BaseSocketSetIpMulticastTtlResultWithResponse(response BaseSocketSetIpMulticastTtlResponse) BaseSocketSetIpMulticastTtlResult {
	var _u BaseSocketSetIpMulticastTtlResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseSocketSetIpMulticastTtlResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseSocketSetIpMulticastTtlResultTag = BaseSocketSetIpMulticastTtlResultErr
	_m.Err = err
}

func BaseSocketSetIpMulticastTtlResultWithErr(err fuchsiaposix.Errno) BaseSocketSetIpMulticastTtlResult {
	var _u BaseSocketSetIpMulticastTtlResult
	_u.SetErr(err)
	return _u
}

type I_baseSocketGetIpMulticastTtlResultTag uint64

const (
	BaseSocketGetIpMulticastTtlResultResponse = 1 // 0x00000001
	BaseSocketGetIpMulticastTtlResultErr      = 2 // 0x00000002
)

type BaseSocketGetIpMulticastTtlResult struct {
	I_baseSocketGetIpMulticastTtlResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                               BaseSocketGetIpMulticastTtlResponse `fidl_ordinal:"1"`
	Err                                    fuchsiaposix.Errno                  `fidl_ordinal:"2"`
}

func (_m *BaseSocketGetIpMulticastTtlResult) reset() {
	switch _m.I_baseSocketGetIpMulticastTtlResultTag {
	case 1:
		var _zeroed BaseSocketGetIpMulticastTtlResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseSocketGetIpMulticastTtlResult) Which() I_baseSocketGetIpMulticastTtlResultTag {
	return _m.I_baseSocketGetIpMulticastTtlResultTag
}

func (_m *BaseSocketGetIpMulticastTtlResult) Ordinal() uint64 {
	return uint64(_m.I_baseSocketGetIpMulticastTtlResultTag)
}

func (_m *BaseSocketGetIpMulticastTtlResult) SetResponse(response BaseSocketGetIpMulticastTtlResponse) {
	_m.reset()
	_m.I_baseSocketGetIpMulticastTtlResultTag = BaseSocketGetIpMulticastTtlResultResponse
	_m.Response = response
}

func BaseSocketGetIpMulticastTtlResultWithResponse(response BaseSocketGetIpMulticastTtlResponse) BaseSocketGetIpMulticastTtlResult {
	var _u BaseSocketGetIpMulticastTtlResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseSocketGetIpMulticastTtlResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseSocketGetIpMulticastTtlResultTag = BaseSocketGetIpMulticastTtlResultErr
	_m.Err = err
}

func BaseSocketGetIpMulticastTtlResultWithErr(err fuchsiaposix.Errno) BaseSocketGetIpMulticastTtlResult {
	var _u BaseSocketGetIpMulticastTtlResult
	_u.SetErr(err)
	return _u
}

type I_baseSocketSetIpMulticastLoopbackResultTag uint64

const (
	BaseSocketSetIpMulticastLoopbackResultResponse = 1 // 0x00000001
	BaseSocketSetIpMulticastLoopbackResultErr      = 2 // 0x00000002
)

type BaseSocketSetIpMulticastLoopbackResult struct {
	I_baseSocketSetIpMulticastLoopbackResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                    BaseSocketSetIpMulticastLoopbackResponse `fidl_ordinal:"1"`
	Err                                         fuchsiaposix.Errno                       `fidl_ordinal:"2"`
}

func (_m *BaseSocketSetIpMulticastLoopbackResult) reset() {
	switch _m.I_baseSocketSetIpMulticastLoopbackResultTag {
	case 1:
		var _zeroed BaseSocketSetIpMulticastLoopbackResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseSocketSetIpMulticastLoopbackResult) Which() I_baseSocketSetIpMulticastLoopbackResultTag {
	return _m.I_baseSocketSetIpMulticastLoopbackResultTag
}

func (_m *BaseSocketSetIpMulticastLoopbackResult) Ordinal() uint64 {
	return uint64(_m.I_baseSocketSetIpMulticastLoopbackResultTag)
}

func (_m *BaseSocketSetIpMulticastLoopbackResult) SetResponse(response BaseSocketSetIpMulticastLoopbackResponse) {
	_m.reset()
	_m.I_baseSocketSetIpMulticastLoopbackResultTag = BaseSocketSetIpMulticastLoopbackResultResponse
	_m.Response = response
}

func BaseSocketSetIpMulticastLoopbackResultWithResponse(response BaseSocketSetIpMulticastLoopbackResponse) BaseSocketSetIpMulticastLoopbackResult {
	var _u BaseSocketSetIpMulticastLoopbackResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseSocketSetIpMulticastLoopbackResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseSocketSetIpMulticastLoopbackResultTag = BaseSocketSetIpMulticastLoopbackResultErr
	_m.Err = err
}

func BaseSocketSetIpMulticastLoopbackResultWithErr(err fuchsiaposix.Errno) BaseSocketSetIpMulticastLoopbackResult {
	var _u BaseSocketSetIpMulticastLoopbackResult
	_u.SetErr(err)
	return _u
}

type I_baseSocketGetIpMulticastLoopbackResultTag uint64

const (
	BaseSocketGetIpMulticastLoopbackResultResponse = 1 // 0x00000001
	BaseSocketGetIpMulticastLoopbackResultErr      = 2 // 0x00000002
)

type BaseSocketGetIpMulticastLoopbackResult struct {
	I_baseSocketGetIpMulticastLoopbackResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                    BaseSocketGetIpMulticastLoopbackResponse `fidl_ordinal:"1"`
	Err                                         fuchsiaposix.Errno                       `fidl_ordinal:"2"`
}

func (_m *BaseSocketGetIpMulticastLoopbackResult) reset() {
	switch _m.I_baseSocketGetIpMulticastLoopbackResultTag {
	case 1:
		var _zeroed BaseSocketGetIpMulticastLoopbackResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseSocketGetIpMulticastLoopbackResult) Which() I_baseSocketGetIpMulticastLoopbackResultTag {
	return _m.I_baseSocketGetIpMulticastLoopbackResultTag
}

func (_m *BaseSocketGetIpMulticastLoopbackResult) Ordinal() uint64 {
	return uint64(_m.I_baseSocketGetIpMulticastLoopbackResultTag)
}

func (_m *BaseSocketGetIpMulticastLoopbackResult) SetResponse(response BaseSocketGetIpMulticastLoopbackResponse) {
	_m.reset()
	_m.I_baseSocketGetIpMulticastLoopbackResultTag = BaseSocketGetIpMulticastLoopbackResultResponse
	_m.Response = response
}

func BaseSocketGetIpMulticastLoopbackResultWithResponse(response BaseSocketGetIpMulticastLoopbackResponse) BaseSocketGetIpMulticastLoopbackResult {
	var _u BaseSocketGetIpMulticastLoopbackResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseSocketGetIpMulticastLoopbackResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseSocketGetIpMulticastLoopbackResultTag = BaseSocketGetIpMulticastLoopbackResultErr
	_m.Err = err
}

func BaseSocketGetIpMulticastLoopbackResultWithErr(err fuchsiaposix.Errno) BaseSocketGetIpMulticastLoopbackResult {
	var _u BaseSocketGetIpMulticastLoopbackResult
	_u.SetErr(err)
	return _u
}

type I_baseSocketAddIpMembershipResultTag uint64

const (
	BaseSocketAddIpMembershipResultResponse = 1 // 0x00000001
	BaseSocketAddIpMembershipResultErr      = 2 // 0x00000002
)

type BaseSocketAddIpMembershipResult struct {
	I_baseSocketAddIpMembershipResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                             BaseSocketAddIpMembershipResponse `fidl_ordinal:"1"`
	Err                                  fuchsiaposix.Errno                `fidl_ordinal:"2"`
}

func (_m *BaseSocketAddIpMembershipResult) reset() {
	switch _m.I_baseSocketAddIpMembershipResultTag {
	case 1:
		var _zeroed BaseSocketAddIpMembershipResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseSocketAddIpMembershipResult) Which() I_baseSocketAddIpMembershipResultTag {
	return _m.I_baseSocketAddIpMembershipResultTag
}

func (_m *BaseSocketAddIpMembershipResult) Ordinal() uint64 {
	return uint64(_m.I_baseSocketAddIpMembershipResultTag)
}

func (_m *BaseSocketAddIpMembershipResult) SetResponse(response BaseSocketAddIpMembershipResponse) {
	_m.reset()
	_m.I_baseSocketAddIpMembershipResultTag = BaseSocketAddIpMembershipResultResponse
	_m.Response = response
}

func BaseSocketAddIpMembershipResultWithResponse(response BaseSocketAddIpMembershipResponse) BaseSocketAddIpMembershipResult {
	var _u BaseSocketAddIpMembershipResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseSocketAddIpMembershipResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseSocketAddIpMembershipResultTag = BaseSocketAddIpMembershipResultErr
	_m.Err = err
}

func BaseSocketAddIpMembershipResultWithErr(err fuchsiaposix.Errno) BaseSocketAddIpMembershipResult {
	var _u BaseSocketAddIpMembershipResult
	_u.SetErr(err)
	return _u
}

type I_baseSocketDropIpMembershipResultTag uint64

const (
	BaseSocketDropIpMembershipResultResponse = 1 // 0x00000001
	BaseSocketDropIpMembershipResultErr      = 2 // 0x00000002
)

type BaseSocketDropIpMembershipResult struct {
	I_baseSocketDropIpMembershipResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                              BaseSocketDropIpMembershipResponse `fidl_ordinal:"1"`
	Err                                   fuchsiaposix.Errno                 `fidl_ordinal:"2"`
}

func (_m *BaseSocketDropIpMembershipResult) reset() {
	switch _m.I_baseSocketDropIpMembershipResultTag {
	case 1:
		var _zeroed BaseSocketDropIpMembershipResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseSocketDropIpMembershipResult) Which() I_baseSocketDropIpMembershipResultTag {
	return _m.I_baseSocketDropIpMembershipResultTag
}

func (_m *BaseSocketDropIpMembershipResult) Ordinal() uint64 {
	return uint64(_m.I_baseSocketDropIpMembershipResultTag)
}

func (_m *BaseSocketDropIpMembershipResult) SetResponse(response BaseSocketDropIpMembershipResponse) {
	_m.reset()
	_m.I_baseSocketDropIpMembershipResultTag = BaseSocketDropIpMembershipResultResponse
	_m.Response = response
}

func BaseSocketDropIpMembershipResultWithResponse(response BaseSocketDropIpMembershipResponse) BaseSocketDropIpMembershipResult {
	var _u BaseSocketDropIpMembershipResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseSocketDropIpMembershipResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseSocketDropIpMembershipResultTag = BaseSocketDropIpMembershipResultErr
	_m.Err = err
}

func BaseSocketDropIpMembershipResultWithErr(err fuchsiaposix.Errno) BaseSocketDropIpMembershipResult {
	var _u BaseSocketDropIpMembershipResult
	_u.SetErr(err)
	return _u
}

type I_baseSocketAddIpv6MembershipResultTag uint64

const (
	BaseSocketAddIpv6MembershipResultResponse = 1 // 0x00000001
	BaseSocketAddIpv6MembershipResultErr      = 2 // 0x00000002
)

type BaseSocketAddIpv6MembershipResult struct {
	I_baseSocketAddIpv6MembershipResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                               BaseSocketAddIpv6MembershipResponse `fidl_ordinal:"1"`
	Err                                    fuchsiaposix.Errno                  `fidl_ordinal:"2"`
}

func (_m *BaseSocketAddIpv6MembershipResult) reset() {
	switch _m.I_baseSocketAddIpv6MembershipResultTag {
	case 1:
		var _zeroed BaseSocketAddIpv6MembershipResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseSocketAddIpv6MembershipResult) Which() I_baseSocketAddIpv6MembershipResultTag {
	return _m.I_baseSocketAddIpv6MembershipResultTag
}

func (_m *BaseSocketAddIpv6MembershipResult) Ordinal() uint64 {
	return uint64(_m.I_baseSocketAddIpv6MembershipResultTag)
}

func (_m *BaseSocketAddIpv6MembershipResult) SetResponse(response BaseSocketAddIpv6MembershipResponse) {
	_m.reset()
	_m.I_baseSocketAddIpv6MembershipResultTag = BaseSocketAddIpv6MembershipResultResponse
	_m.Response = response
}

func BaseSocketAddIpv6MembershipResultWithResponse(response BaseSocketAddIpv6MembershipResponse) BaseSocketAddIpv6MembershipResult {
	var _u BaseSocketAddIpv6MembershipResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseSocketAddIpv6MembershipResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseSocketAddIpv6MembershipResultTag = BaseSocketAddIpv6MembershipResultErr
	_m.Err = err
}

func BaseSocketAddIpv6MembershipResultWithErr(err fuchsiaposix.Errno) BaseSocketAddIpv6MembershipResult {
	var _u BaseSocketAddIpv6MembershipResult
	_u.SetErr(err)
	return _u
}

type I_baseSocketDropIpv6MembershipResultTag uint64

const (
	BaseSocketDropIpv6MembershipResultResponse = 1 // 0x00000001
	BaseSocketDropIpv6MembershipResultErr      = 2 // 0x00000002
)

type BaseSocketDropIpv6MembershipResult struct {
	I_baseSocketDropIpv6MembershipResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                BaseSocketDropIpv6MembershipResponse `fidl_ordinal:"1"`
	Err                                     fuchsiaposix.Errno                   `fidl_ordinal:"2"`
}

func (_m *BaseSocketDropIpv6MembershipResult) reset() {
	switch _m.I_baseSocketDropIpv6MembershipResultTag {
	case 1:
		var _zeroed BaseSocketDropIpv6MembershipResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseSocketDropIpv6MembershipResult) Which() I_baseSocketDropIpv6MembershipResultTag {
	return _m.I_baseSocketDropIpv6MembershipResultTag
}

func (_m *BaseSocketDropIpv6MembershipResult) Ordinal() uint64 {
	return uint64(_m.I_baseSocketDropIpv6MembershipResultTag)
}

func (_m *BaseSocketDropIpv6MembershipResult) SetResponse(response BaseSocketDropIpv6MembershipResponse) {
	_m.reset()
	_m.I_baseSocketDropIpv6MembershipResultTag = BaseSocketDropIpv6MembershipResultResponse
	_m.Response = response
}

func BaseSocketDropIpv6MembershipResultWithResponse(response BaseSocketDropIpv6MembershipResponse) BaseSocketDropIpv6MembershipResult {
	var _u BaseSocketDropIpv6MembershipResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseSocketDropIpv6MembershipResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseSocketDropIpv6MembershipResultTag = BaseSocketDropIpv6MembershipResultErr
	_m.Err = err
}

func BaseSocketDropIpv6MembershipResultWithErr(err fuchsiaposix.Errno) BaseSocketDropIpv6MembershipResult {
	var _u BaseSocketDropIpv6MembershipResult
	_u.SetErr(err)
	return _u
}

type I_baseSocketSetIpv6MulticastInterfaceResultTag uint64

const (
	BaseSocketSetIpv6MulticastInterfaceResultResponse = 1 // 0x00000001
	BaseSocketSetIpv6MulticastInterfaceResultErr      = 2 // 0x00000002
)

type BaseSocketSetIpv6MulticastInterfaceResult struct {
	I_baseSocketSetIpv6MulticastInterfaceResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                       BaseSocketSetIpv6MulticastInterfaceResponse `fidl_ordinal:"1"`
	Err                                            fuchsiaposix.Errno                          `fidl_ordinal:"2"`
}

func (_m *BaseSocketSetIpv6MulticastInterfaceResult) reset() {
	switch _m.I_baseSocketSetIpv6MulticastInterfaceResultTag {
	case 1:
		var _zeroed BaseSocketSetIpv6MulticastInterfaceResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseSocketSetIpv6MulticastInterfaceResult) Which() I_baseSocketSetIpv6MulticastInterfaceResultTag {
	return _m.I_baseSocketSetIpv6MulticastInterfaceResultTag
}

func (_m *BaseSocketSetIpv6MulticastInterfaceResult) Ordinal() uint64 {
	return uint64(_m.I_baseSocketSetIpv6MulticastInterfaceResultTag)
}

func (_m *BaseSocketSetIpv6MulticastInterfaceResult) SetResponse(response BaseSocketSetIpv6MulticastInterfaceResponse) {
	_m.reset()
	_m.I_baseSocketSetIpv6MulticastInterfaceResultTag = BaseSocketSetIpv6MulticastInterfaceResultResponse
	_m.Response = response
}

func BaseSocketSetIpv6MulticastInterfaceResultWithResponse(response BaseSocketSetIpv6MulticastInterfaceResponse) BaseSocketSetIpv6MulticastInterfaceResult {
	var _u BaseSocketSetIpv6MulticastInterfaceResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseSocketSetIpv6MulticastInterfaceResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseSocketSetIpv6MulticastInterfaceResultTag = BaseSocketSetIpv6MulticastInterfaceResultErr
	_m.Err = err
}

func BaseSocketSetIpv6MulticastInterfaceResultWithErr(err fuchsiaposix.Errno) BaseSocketSetIpv6MulticastInterfaceResult {
	var _u BaseSocketSetIpv6MulticastInterfaceResult
	_u.SetErr(err)
	return _u
}

type I_baseSocketGetIpv6MulticastInterfaceResultTag uint64

const (
	BaseSocketGetIpv6MulticastInterfaceResultResponse = 1 // 0x00000001
	BaseSocketGetIpv6MulticastInterfaceResultErr      = 2 // 0x00000002
)

type BaseSocketGetIpv6MulticastInterfaceResult struct {
	I_baseSocketGetIpv6MulticastInterfaceResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                       BaseSocketGetIpv6MulticastInterfaceResponse `fidl_ordinal:"1"`
	Err                                            fuchsiaposix.Errno                          `fidl_ordinal:"2"`
}

func (_m *BaseSocketGetIpv6MulticastInterfaceResult) reset() {
	switch _m.I_baseSocketGetIpv6MulticastInterfaceResultTag {
	case 1:
		var _zeroed BaseSocketGetIpv6MulticastInterfaceResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseSocketGetIpv6MulticastInterfaceResult) Which() I_baseSocketGetIpv6MulticastInterfaceResultTag {
	return _m.I_baseSocketGetIpv6MulticastInterfaceResultTag
}

func (_m *BaseSocketGetIpv6MulticastInterfaceResult) Ordinal() uint64 {
	return uint64(_m.I_baseSocketGetIpv6MulticastInterfaceResultTag)
}

func (_m *BaseSocketGetIpv6MulticastInterfaceResult) SetResponse(response BaseSocketGetIpv6MulticastInterfaceResponse) {
	_m.reset()
	_m.I_baseSocketGetIpv6MulticastInterfaceResultTag = BaseSocketGetIpv6MulticastInterfaceResultResponse
	_m.Response = response
}

func BaseSocketGetIpv6MulticastInterfaceResultWithResponse(response BaseSocketGetIpv6MulticastInterfaceResponse) BaseSocketGetIpv6MulticastInterfaceResult {
	var _u BaseSocketGetIpv6MulticastInterfaceResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseSocketGetIpv6MulticastInterfaceResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseSocketGetIpv6MulticastInterfaceResultTag = BaseSocketGetIpv6MulticastInterfaceResultErr
	_m.Err = err
}

func BaseSocketGetIpv6MulticastInterfaceResultWithErr(err fuchsiaposix.Errno) BaseSocketGetIpv6MulticastInterfaceResult {
	var _u BaseSocketGetIpv6MulticastInterfaceResult
	_u.SetErr(err)
	return _u
}

type I_baseSocketSetIpv6MulticastHopsResultTag uint64

const (
	BaseSocketSetIpv6MulticastHopsResultResponse = 1 // 0x00000001
	BaseSocketSetIpv6MulticastHopsResultErr      = 2 // 0x00000002
)

type BaseSocketSetIpv6MulticastHopsResult struct {
	I_baseSocketSetIpv6MulticastHopsResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                  BaseSocketSetIpv6MulticastHopsResponse `fidl_ordinal:"1"`
	Err                                       fuchsiaposix.Errno                     `fidl_ordinal:"2"`
}

func (_m *BaseSocketSetIpv6MulticastHopsResult) reset() {
	switch _m.I_baseSocketSetIpv6MulticastHopsResultTag {
	case 1:
		var _zeroed BaseSocketSetIpv6MulticastHopsResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseSocketSetIpv6MulticastHopsResult) Which() I_baseSocketSetIpv6MulticastHopsResultTag {
	return _m.I_baseSocketSetIpv6MulticastHopsResultTag
}

func (_m *BaseSocketSetIpv6MulticastHopsResult) Ordinal() uint64 {
	return uint64(_m.I_baseSocketSetIpv6MulticastHopsResultTag)
}

func (_m *BaseSocketSetIpv6MulticastHopsResult) SetResponse(response BaseSocketSetIpv6MulticastHopsResponse) {
	_m.reset()
	_m.I_baseSocketSetIpv6MulticastHopsResultTag = BaseSocketSetIpv6MulticastHopsResultResponse
	_m.Response = response
}

func BaseSocketSetIpv6MulticastHopsResultWithResponse(response BaseSocketSetIpv6MulticastHopsResponse) BaseSocketSetIpv6MulticastHopsResult {
	var _u BaseSocketSetIpv6MulticastHopsResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseSocketSetIpv6MulticastHopsResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseSocketSetIpv6MulticastHopsResultTag = BaseSocketSetIpv6MulticastHopsResultErr
	_m.Err = err
}

func BaseSocketSetIpv6MulticastHopsResultWithErr(err fuchsiaposix.Errno) BaseSocketSetIpv6MulticastHopsResult {
	var _u BaseSocketSetIpv6MulticastHopsResult
	_u.SetErr(err)
	return _u
}

type I_baseSocketGetIpv6MulticastHopsResultTag uint64

const (
	BaseSocketGetIpv6MulticastHopsResultResponse = 1 // 0x00000001
	BaseSocketGetIpv6MulticastHopsResultErr      = 2 // 0x00000002
)

type BaseSocketGetIpv6MulticastHopsResult struct {
	I_baseSocketGetIpv6MulticastHopsResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                  BaseSocketGetIpv6MulticastHopsResponse `fidl_ordinal:"1"`
	Err                                       fuchsiaposix.Errno                     `fidl_ordinal:"2"`
}

func (_m *BaseSocketGetIpv6MulticastHopsResult) reset() {
	switch _m.I_baseSocketGetIpv6MulticastHopsResultTag {
	case 1:
		var _zeroed BaseSocketGetIpv6MulticastHopsResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseSocketGetIpv6MulticastHopsResult) Which() I_baseSocketGetIpv6MulticastHopsResultTag {
	return _m.I_baseSocketGetIpv6MulticastHopsResultTag
}

func (_m *BaseSocketGetIpv6MulticastHopsResult) Ordinal() uint64 {
	return uint64(_m.I_baseSocketGetIpv6MulticastHopsResultTag)
}

func (_m *BaseSocketGetIpv6MulticastHopsResult) SetResponse(response BaseSocketGetIpv6MulticastHopsResponse) {
	_m.reset()
	_m.I_baseSocketGetIpv6MulticastHopsResultTag = BaseSocketGetIpv6MulticastHopsResultResponse
	_m.Response = response
}

func BaseSocketGetIpv6MulticastHopsResultWithResponse(response BaseSocketGetIpv6MulticastHopsResponse) BaseSocketGetIpv6MulticastHopsResult {
	var _u BaseSocketGetIpv6MulticastHopsResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseSocketGetIpv6MulticastHopsResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseSocketGetIpv6MulticastHopsResultTag = BaseSocketGetIpv6MulticastHopsResultErr
	_m.Err = err
}

func BaseSocketGetIpv6MulticastHopsResultWithErr(err fuchsiaposix.Errno) BaseSocketGetIpv6MulticastHopsResult {
	var _u BaseSocketGetIpv6MulticastHopsResult
	_u.SetErr(err)
	return _u
}

type I_baseSocketSetIpv6MulticastLoopbackResultTag uint64

const (
	BaseSocketSetIpv6MulticastLoopbackResultResponse = 1 // 0x00000001
	BaseSocketSetIpv6MulticastLoopbackResultErr      = 2 // 0x00000002
)

type BaseSocketSetIpv6MulticastLoopbackResult struct {
	I_baseSocketSetIpv6MulticastLoopbackResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                      BaseSocketSetIpv6MulticastLoopbackResponse `fidl_ordinal:"1"`
	Err                                           fuchsiaposix.Errno                         `fidl_ordinal:"2"`
}

func (_m *BaseSocketSetIpv6MulticastLoopbackResult) reset() {
	switch _m.I_baseSocketSetIpv6MulticastLoopbackResultTag {
	case 1:
		var _zeroed BaseSocketSetIpv6MulticastLoopbackResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseSocketSetIpv6MulticastLoopbackResult) Which() I_baseSocketSetIpv6MulticastLoopbackResultTag {
	return _m.I_baseSocketSetIpv6MulticastLoopbackResultTag
}

func (_m *BaseSocketSetIpv6MulticastLoopbackResult) Ordinal() uint64 {
	return uint64(_m.I_baseSocketSetIpv6MulticastLoopbackResultTag)
}

func (_m *BaseSocketSetIpv6MulticastLoopbackResult) SetResponse(response BaseSocketSetIpv6MulticastLoopbackResponse) {
	_m.reset()
	_m.I_baseSocketSetIpv6MulticastLoopbackResultTag = BaseSocketSetIpv6MulticastLoopbackResultResponse
	_m.Response = response
}

func BaseSocketSetIpv6MulticastLoopbackResultWithResponse(response BaseSocketSetIpv6MulticastLoopbackResponse) BaseSocketSetIpv6MulticastLoopbackResult {
	var _u BaseSocketSetIpv6MulticastLoopbackResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseSocketSetIpv6MulticastLoopbackResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseSocketSetIpv6MulticastLoopbackResultTag = BaseSocketSetIpv6MulticastLoopbackResultErr
	_m.Err = err
}

func BaseSocketSetIpv6MulticastLoopbackResultWithErr(err fuchsiaposix.Errno) BaseSocketSetIpv6MulticastLoopbackResult {
	var _u BaseSocketSetIpv6MulticastLoopbackResult
	_u.SetErr(err)
	return _u
}

type I_baseSocketGetIpv6MulticastLoopbackResultTag uint64

const (
	BaseSocketGetIpv6MulticastLoopbackResultResponse = 1 // 0x00000001
	BaseSocketGetIpv6MulticastLoopbackResultErr      = 2 // 0x00000002
)

type BaseSocketGetIpv6MulticastLoopbackResult struct {
	I_baseSocketGetIpv6MulticastLoopbackResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                      BaseSocketGetIpv6MulticastLoopbackResponse `fidl_ordinal:"1"`
	Err                                           fuchsiaposix.Errno                         `fidl_ordinal:"2"`
}

func (_m *BaseSocketGetIpv6MulticastLoopbackResult) reset() {
	switch _m.I_baseSocketGetIpv6MulticastLoopbackResultTag {
	case 1:
		var _zeroed BaseSocketGetIpv6MulticastLoopbackResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseSocketGetIpv6MulticastLoopbackResult) Which() I_baseSocketGetIpv6MulticastLoopbackResultTag {
	return _m.I_baseSocketGetIpv6MulticastLoopbackResultTag
}

func (_m *BaseSocketGetIpv6MulticastLoopbackResult) Ordinal() uint64 {
	return uint64(_m.I_baseSocketGetIpv6MulticastLoopbackResultTag)
}

func (_m *BaseSocketGetIpv6MulticastLoopbackResult) SetResponse(response BaseSocketGetIpv6MulticastLoopbackResponse) {
	_m.reset()
	_m.I_baseSocketGetIpv6MulticastLoopbackResultTag = BaseSocketGetIpv6MulticastLoopbackResultResponse
	_m.Response = response
}

func BaseSocketGetIpv6MulticastLoopbackResultWithResponse(response BaseSocketGetIpv6MulticastLoopbackResponse) BaseSocketGetIpv6MulticastLoopbackResult {
	var _u BaseSocketGetIpv6MulticastLoopbackResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseSocketGetIpv6MulticastLoopbackResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseSocketGetIpv6MulticastLoopbackResultTag = BaseSocketGetIpv6MulticastLoopbackResultErr
	_m.Err = err
}

func BaseSocketGetIpv6MulticastLoopbackResultWithErr(err fuchsiaposix.Errno) BaseSocketGetIpv6MulticastLoopbackResult {
	var _u BaseSocketGetIpv6MulticastLoopbackResult
	_u.SetErr(err)
	return _u
}

type I_baseSocketSetIpv6OnlyResultTag uint64

const (
	BaseSocketSetIpv6OnlyResultResponse = 1 // 0x00000001
	BaseSocketSetIpv6OnlyResultErr      = 2 // 0x00000002
)

type BaseSocketSetIpv6OnlyResult struct {
	I_baseSocketSetIpv6OnlyResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                         BaseSocketSetIpv6OnlyResponse `fidl_ordinal:"1"`
	Err                              fuchsiaposix.Errno            `fidl_ordinal:"2"`
}

func (_m *BaseSocketSetIpv6OnlyResult) reset() {
	switch _m.I_baseSocketSetIpv6OnlyResultTag {
	case 1:
		var _zeroed BaseSocketSetIpv6OnlyResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseSocketSetIpv6OnlyResult) Which() I_baseSocketSetIpv6OnlyResultTag {
	return _m.I_baseSocketSetIpv6OnlyResultTag
}

func (_m *BaseSocketSetIpv6OnlyResult) Ordinal() uint64 {
	return uint64(_m.I_baseSocketSetIpv6OnlyResultTag)
}

func (_m *BaseSocketSetIpv6OnlyResult) SetResponse(response BaseSocketSetIpv6OnlyResponse) {
	_m.reset()
	_m.I_baseSocketSetIpv6OnlyResultTag = BaseSocketSetIpv6OnlyResultResponse
	_m.Response = response
}

func BaseSocketSetIpv6OnlyResultWithResponse(response BaseSocketSetIpv6OnlyResponse) BaseSocketSetIpv6OnlyResult {
	var _u BaseSocketSetIpv6OnlyResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseSocketSetIpv6OnlyResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseSocketSetIpv6OnlyResultTag = BaseSocketSetIpv6OnlyResultErr
	_m.Err = err
}

func BaseSocketSetIpv6OnlyResultWithErr(err fuchsiaposix.Errno) BaseSocketSetIpv6OnlyResult {
	var _u BaseSocketSetIpv6OnlyResult
	_u.SetErr(err)
	return _u
}

type I_baseSocketGetIpv6OnlyResultTag uint64

const (
	BaseSocketGetIpv6OnlyResultResponse = 1 // 0x00000001
	BaseSocketGetIpv6OnlyResultErr      = 2 // 0x00000002
)

type BaseSocketGetIpv6OnlyResult struct {
	I_baseSocketGetIpv6OnlyResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                         BaseSocketGetIpv6OnlyResponse `fidl_ordinal:"1"`
	Err                              fuchsiaposix.Errno            `fidl_ordinal:"2"`
}

func (_m *BaseSocketGetIpv6OnlyResult) reset() {
	switch _m.I_baseSocketGetIpv6OnlyResultTag {
	case 1:
		var _zeroed BaseSocketGetIpv6OnlyResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseSocketGetIpv6OnlyResult) Which() I_baseSocketGetIpv6OnlyResultTag {
	return _m.I_baseSocketGetIpv6OnlyResultTag
}

func (_m *BaseSocketGetIpv6OnlyResult) Ordinal() uint64 {
	return uint64(_m.I_baseSocketGetIpv6OnlyResultTag)
}

func (_m *BaseSocketGetIpv6OnlyResult) SetResponse(response BaseSocketGetIpv6OnlyResponse) {
	_m.reset()
	_m.I_baseSocketGetIpv6OnlyResultTag = BaseSocketGetIpv6OnlyResultResponse
	_m.Response = response
}

func BaseSocketGetIpv6OnlyResultWithResponse(response BaseSocketGetIpv6OnlyResponse) BaseSocketGetIpv6OnlyResult {
	var _u BaseSocketGetIpv6OnlyResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseSocketGetIpv6OnlyResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseSocketGetIpv6OnlyResultTag = BaseSocketGetIpv6OnlyResultErr
	_m.Err = err
}

func BaseSocketGetIpv6OnlyResultWithErr(err fuchsiaposix.Errno) BaseSocketGetIpv6OnlyResult {
	var _u BaseSocketGetIpv6OnlyResult
	_u.SetErr(err)
	return _u
}

type I_baseSocketSetIpv6ReceiveTrafficClassResultTag uint64

const (
	BaseSocketSetIpv6ReceiveTrafficClassResultResponse = 1 // 0x00000001
	BaseSocketSetIpv6ReceiveTrafficClassResultErr      = 2 // 0x00000002
)

type BaseSocketSetIpv6ReceiveTrafficClassResult struct {
	I_baseSocketSetIpv6ReceiveTrafficClassResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                        BaseSocketSetIpv6ReceiveTrafficClassResponse `fidl_ordinal:"1"`
	Err                                             fuchsiaposix.Errno                           `fidl_ordinal:"2"`
}

func (_m *BaseSocketSetIpv6ReceiveTrafficClassResult) reset() {
	switch _m.I_baseSocketSetIpv6ReceiveTrafficClassResultTag {
	case 1:
		var _zeroed BaseSocketSetIpv6ReceiveTrafficClassResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseSocketSetIpv6ReceiveTrafficClassResult) Which() I_baseSocketSetIpv6ReceiveTrafficClassResultTag {
	return _m.I_baseSocketSetIpv6ReceiveTrafficClassResultTag
}

func (_m *BaseSocketSetIpv6ReceiveTrafficClassResult) Ordinal() uint64 {
	return uint64(_m.I_baseSocketSetIpv6ReceiveTrafficClassResultTag)
}

func (_m *BaseSocketSetIpv6ReceiveTrafficClassResult) SetResponse(response BaseSocketSetIpv6ReceiveTrafficClassResponse) {
	_m.reset()
	_m.I_baseSocketSetIpv6ReceiveTrafficClassResultTag = BaseSocketSetIpv6ReceiveTrafficClassResultResponse
	_m.Response = response
}

func BaseSocketSetIpv6ReceiveTrafficClassResultWithResponse(response BaseSocketSetIpv6ReceiveTrafficClassResponse) BaseSocketSetIpv6ReceiveTrafficClassResult {
	var _u BaseSocketSetIpv6ReceiveTrafficClassResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseSocketSetIpv6ReceiveTrafficClassResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseSocketSetIpv6ReceiveTrafficClassResultTag = BaseSocketSetIpv6ReceiveTrafficClassResultErr
	_m.Err = err
}

func BaseSocketSetIpv6ReceiveTrafficClassResultWithErr(err fuchsiaposix.Errno) BaseSocketSetIpv6ReceiveTrafficClassResult {
	var _u BaseSocketSetIpv6ReceiveTrafficClassResult
	_u.SetErr(err)
	return _u
}

type I_baseSocketGetIpv6ReceiveTrafficClassResultTag uint64

const (
	BaseSocketGetIpv6ReceiveTrafficClassResultResponse = 1 // 0x00000001
	BaseSocketGetIpv6ReceiveTrafficClassResultErr      = 2 // 0x00000002
)

type BaseSocketGetIpv6ReceiveTrafficClassResult struct {
	I_baseSocketGetIpv6ReceiveTrafficClassResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                        BaseSocketGetIpv6ReceiveTrafficClassResponse `fidl_ordinal:"1"`
	Err                                             fuchsiaposix.Errno                           `fidl_ordinal:"2"`
}

func (_m *BaseSocketGetIpv6ReceiveTrafficClassResult) reset() {
	switch _m.I_baseSocketGetIpv6ReceiveTrafficClassResultTag {
	case 1:
		var _zeroed BaseSocketGetIpv6ReceiveTrafficClassResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseSocketGetIpv6ReceiveTrafficClassResult) Which() I_baseSocketGetIpv6ReceiveTrafficClassResultTag {
	return _m.I_baseSocketGetIpv6ReceiveTrafficClassResultTag
}

func (_m *BaseSocketGetIpv6ReceiveTrafficClassResult) Ordinal() uint64 {
	return uint64(_m.I_baseSocketGetIpv6ReceiveTrafficClassResultTag)
}

func (_m *BaseSocketGetIpv6ReceiveTrafficClassResult) SetResponse(response BaseSocketGetIpv6ReceiveTrafficClassResponse) {
	_m.reset()
	_m.I_baseSocketGetIpv6ReceiveTrafficClassResultTag = BaseSocketGetIpv6ReceiveTrafficClassResultResponse
	_m.Response = response
}

func BaseSocketGetIpv6ReceiveTrafficClassResultWithResponse(response BaseSocketGetIpv6ReceiveTrafficClassResponse) BaseSocketGetIpv6ReceiveTrafficClassResult {
	var _u BaseSocketGetIpv6ReceiveTrafficClassResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseSocketGetIpv6ReceiveTrafficClassResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseSocketGetIpv6ReceiveTrafficClassResultTag = BaseSocketGetIpv6ReceiveTrafficClassResultErr
	_m.Err = err
}

func BaseSocketGetIpv6ReceiveTrafficClassResultWithErr(err fuchsiaposix.Errno) BaseSocketGetIpv6ReceiveTrafficClassResult {
	var _u BaseSocketGetIpv6ReceiveTrafficClassResult
	_u.SetErr(err)
	return _u
}

type I_baseSocketSetIpv6TrafficClassResultTag uint64

const (
	BaseSocketSetIpv6TrafficClassResultResponse = 1 // 0x00000001
	BaseSocketSetIpv6TrafficClassResultErr      = 2 // 0x00000002
)

type BaseSocketSetIpv6TrafficClassResult struct {
	I_baseSocketSetIpv6TrafficClassResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                 BaseSocketSetIpv6TrafficClassResponse `fidl_ordinal:"1"`
	Err                                      fuchsiaposix.Errno                    `fidl_ordinal:"2"`
}

func (_m *BaseSocketSetIpv6TrafficClassResult) reset() {
	switch _m.I_baseSocketSetIpv6TrafficClassResultTag {
	case 1:
		var _zeroed BaseSocketSetIpv6TrafficClassResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseSocketSetIpv6TrafficClassResult) Which() I_baseSocketSetIpv6TrafficClassResultTag {
	return _m.I_baseSocketSetIpv6TrafficClassResultTag
}

func (_m *BaseSocketSetIpv6TrafficClassResult) Ordinal() uint64 {
	return uint64(_m.I_baseSocketSetIpv6TrafficClassResultTag)
}

func (_m *BaseSocketSetIpv6TrafficClassResult) SetResponse(response BaseSocketSetIpv6TrafficClassResponse) {
	_m.reset()
	_m.I_baseSocketSetIpv6TrafficClassResultTag = BaseSocketSetIpv6TrafficClassResultResponse
	_m.Response = response
}

func BaseSocketSetIpv6TrafficClassResultWithResponse(response BaseSocketSetIpv6TrafficClassResponse) BaseSocketSetIpv6TrafficClassResult {
	var _u BaseSocketSetIpv6TrafficClassResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseSocketSetIpv6TrafficClassResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseSocketSetIpv6TrafficClassResultTag = BaseSocketSetIpv6TrafficClassResultErr
	_m.Err = err
}

func BaseSocketSetIpv6TrafficClassResultWithErr(err fuchsiaposix.Errno) BaseSocketSetIpv6TrafficClassResult {
	var _u BaseSocketSetIpv6TrafficClassResult
	_u.SetErr(err)
	return _u
}

type I_baseSocketGetIpv6TrafficClassResultTag uint64

const (
	BaseSocketGetIpv6TrafficClassResultResponse = 1 // 0x00000001
	BaseSocketGetIpv6TrafficClassResultErr      = 2 // 0x00000002
)

type BaseSocketGetIpv6TrafficClassResult struct {
	I_baseSocketGetIpv6TrafficClassResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                 BaseSocketGetIpv6TrafficClassResponse `fidl_ordinal:"1"`
	Err                                      fuchsiaposix.Errno                    `fidl_ordinal:"2"`
}

func (_m *BaseSocketGetIpv6TrafficClassResult) reset() {
	switch _m.I_baseSocketGetIpv6TrafficClassResultTag {
	case 1:
		var _zeroed BaseSocketGetIpv6TrafficClassResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseSocketGetIpv6TrafficClassResult) Which() I_baseSocketGetIpv6TrafficClassResultTag {
	return _m.I_baseSocketGetIpv6TrafficClassResultTag
}

func (_m *BaseSocketGetIpv6TrafficClassResult) Ordinal() uint64 {
	return uint64(_m.I_baseSocketGetIpv6TrafficClassResultTag)
}

func (_m *BaseSocketGetIpv6TrafficClassResult) SetResponse(response BaseSocketGetIpv6TrafficClassResponse) {
	_m.reset()
	_m.I_baseSocketGetIpv6TrafficClassResultTag = BaseSocketGetIpv6TrafficClassResultResponse
	_m.Response = response
}

func BaseSocketGetIpv6TrafficClassResultWithResponse(response BaseSocketGetIpv6TrafficClassResponse) BaseSocketGetIpv6TrafficClassResult {
	var _u BaseSocketGetIpv6TrafficClassResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseSocketGetIpv6TrafficClassResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseSocketGetIpv6TrafficClassResultTag = BaseSocketGetIpv6TrafficClassResultErr
	_m.Err = err
}

func BaseSocketGetIpv6TrafficClassResultWithErr(err fuchsiaposix.Errno) BaseSocketGetIpv6TrafficClassResult {
	var _u BaseSocketGetIpv6TrafficClassResult
	_u.SetErr(err)
	return _u
}

type I_datagramSocketRecvMsgResultTag uint64

const (
	DatagramSocketRecvMsgResultResponse = 1 // 0x00000001
	DatagramSocketRecvMsgResultErr      = 2 // 0x00000002
)

type DatagramSocketRecvMsgResult struct {
	I_datagramSocketRecvMsgResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                         DatagramSocketRecvMsgResponse `fidl_ordinal:"1"`
	Err                              fuchsiaposix.Errno            `fidl_ordinal:"2"`
}

func (_m *DatagramSocketRecvMsgResult) reset() {
	switch _m.I_datagramSocketRecvMsgResultTag {
	case 1:
		var _zeroed DatagramSocketRecvMsgResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *DatagramSocketRecvMsgResult) Which() I_datagramSocketRecvMsgResultTag {
	return _m.I_datagramSocketRecvMsgResultTag
}

func (_m *DatagramSocketRecvMsgResult) Ordinal() uint64 {
	return uint64(_m.I_datagramSocketRecvMsgResultTag)
}

func (_m *DatagramSocketRecvMsgResult) SetResponse(response DatagramSocketRecvMsgResponse) {
	_m.reset()
	_m.I_datagramSocketRecvMsgResultTag = DatagramSocketRecvMsgResultResponse
	_m.Response = response
}

func DatagramSocketRecvMsgResultWithResponse(response DatagramSocketRecvMsgResponse) DatagramSocketRecvMsgResult {
	var _u DatagramSocketRecvMsgResult
	_u.SetResponse(response)
	return _u
}

func (_m *DatagramSocketRecvMsgResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_datagramSocketRecvMsgResultTag = DatagramSocketRecvMsgResultErr
	_m.Err = err
}

func DatagramSocketRecvMsgResultWithErr(err fuchsiaposix.Errno) DatagramSocketRecvMsgResult {
	var _u DatagramSocketRecvMsgResult
	_u.SetErr(err)
	return _u
}

type I_datagramSocketSendMsgResultTag uint64

const (
	DatagramSocketSendMsgResultResponse = 1 // 0x00000001
	DatagramSocketSendMsgResultErr      = 2 // 0x00000002
)

type DatagramSocketSendMsgResult struct {
	I_datagramSocketSendMsgResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                         DatagramSocketSendMsgResponse `fidl_ordinal:"1"`
	Err                              fuchsiaposix.Errno            `fidl_ordinal:"2"`
}

func (_m *DatagramSocketSendMsgResult) reset() {
	switch _m.I_datagramSocketSendMsgResultTag {
	case 1:
		var _zeroed DatagramSocketSendMsgResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *DatagramSocketSendMsgResult) Which() I_datagramSocketSendMsgResultTag {
	return _m.I_datagramSocketSendMsgResultTag
}

func (_m *DatagramSocketSendMsgResult) Ordinal() uint64 {
	return uint64(_m.I_datagramSocketSendMsgResultTag)
}

func (_m *DatagramSocketSendMsgResult) SetResponse(response DatagramSocketSendMsgResponse) {
	_m.reset()
	_m.I_datagramSocketSendMsgResultTag = DatagramSocketSendMsgResultResponse
	_m.Response = response
}

func DatagramSocketSendMsgResultWithResponse(response DatagramSocketSendMsgResponse) DatagramSocketSendMsgResult {
	var _u DatagramSocketSendMsgResult
	_u.SetResponse(response)
	return _u
}

func (_m *DatagramSocketSendMsgResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_datagramSocketSendMsgResultTag = DatagramSocketSendMsgResultErr
	_m.Err = err
}

func DatagramSocketSendMsgResultWithErr(err fuchsiaposix.Errno) DatagramSocketSendMsgResult {
	var _u DatagramSocketSendMsgResult
	_u.SetErr(err)
	return _u
}

type I_datagramSocketGetInfoResultTag uint64

const (
	DatagramSocketGetInfoResultResponse = 1 // 0x00000001
	DatagramSocketGetInfoResultErr      = 2 // 0x00000002
)

type DatagramSocketGetInfoResult struct {
	I_datagramSocketGetInfoResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                         DatagramSocketGetInfoResponse `fidl_ordinal:"1"`
	Err                              fuchsiaposix.Errno            `fidl_ordinal:"2"`
}

func (_m *DatagramSocketGetInfoResult) reset() {
	switch _m.I_datagramSocketGetInfoResultTag {
	case 1:
		var _zeroed DatagramSocketGetInfoResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *DatagramSocketGetInfoResult) Which() I_datagramSocketGetInfoResultTag {
	return _m.I_datagramSocketGetInfoResultTag
}

func (_m *DatagramSocketGetInfoResult) Ordinal() uint64 {
	return uint64(_m.I_datagramSocketGetInfoResultTag)
}

func (_m *DatagramSocketGetInfoResult) SetResponse(response DatagramSocketGetInfoResponse) {
	_m.reset()
	_m.I_datagramSocketGetInfoResultTag = DatagramSocketGetInfoResultResponse
	_m.Response = response
}

func DatagramSocketGetInfoResultWithResponse(response DatagramSocketGetInfoResponse) DatagramSocketGetInfoResult {
	var _u DatagramSocketGetInfoResult
	_u.SetResponse(response)
	return _u
}

func (_m *DatagramSocketGetInfoResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_datagramSocketGetInfoResultTag = DatagramSocketGetInfoResultErr
	_m.Err = err
}

func DatagramSocketGetInfoResultWithErr(err fuchsiaposix.Errno) DatagramSocketGetInfoResult {
	var _u DatagramSocketGetInfoResult
	_u.SetErr(err)
	return _u
}

type I_streamSocketListenResultTag uint64

const (
	StreamSocketListenResultResponse = 1 // 0x00000001
	StreamSocketListenResultErr      = 2 // 0x00000002
)

type StreamSocketListenResult struct {
	I_streamSocketListenResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                      StreamSocketListenResponse `fidl_ordinal:"1"`
	Err                           fuchsiaposix.Errno         `fidl_ordinal:"2"`
}

func (_m *StreamSocketListenResult) reset() {
	switch _m.I_streamSocketListenResultTag {
	case 1:
		var _zeroed StreamSocketListenResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *StreamSocketListenResult) Which() I_streamSocketListenResultTag {
	return _m.I_streamSocketListenResultTag
}

func (_m *StreamSocketListenResult) Ordinal() uint64 {
	return uint64(_m.I_streamSocketListenResultTag)
}

func (_m *StreamSocketListenResult) SetResponse(response StreamSocketListenResponse) {
	_m.reset()
	_m.I_streamSocketListenResultTag = StreamSocketListenResultResponse
	_m.Response = response
}

func StreamSocketListenResultWithResponse(response StreamSocketListenResponse) StreamSocketListenResult {
	var _u StreamSocketListenResult
	_u.SetResponse(response)
	return _u
}

func (_m *StreamSocketListenResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_streamSocketListenResultTag = StreamSocketListenResultErr
	_m.Err = err
}

func StreamSocketListenResultWithErr(err fuchsiaposix.Errno) StreamSocketListenResult {
	var _u StreamSocketListenResult
	_u.SetErr(err)
	return _u
}

type I_streamSocketAcceptResultTag uint64

const (
	StreamSocketAcceptResultResponse = 1 // 0x00000001
	StreamSocketAcceptResultErr      = 2 // 0x00000002
)

type StreamSocketAcceptResult struct {
	I_streamSocketAcceptResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"true"`
	Response                      StreamSocketAcceptResponse `fidl_ordinal:"1"`
	Err                           fuchsiaposix.Errno         `fidl_ordinal:"2"`
}

func (_m *StreamSocketAcceptResult) reset() {
	switch _m.I_streamSocketAcceptResultTag {
	case 1:
		var _zeroed StreamSocketAcceptResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *StreamSocketAcceptResult) Which() I_streamSocketAcceptResultTag {
	return _m.I_streamSocketAcceptResultTag
}

func (_m *StreamSocketAcceptResult) Ordinal() uint64 {
	return uint64(_m.I_streamSocketAcceptResultTag)
}

func (_m *StreamSocketAcceptResult) SetResponse(response StreamSocketAcceptResponse) {
	_m.reset()
	_m.I_streamSocketAcceptResultTag = StreamSocketAcceptResultResponse
	_m.Response = response
}

func StreamSocketAcceptResultWithResponse(response StreamSocketAcceptResponse) StreamSocketAcceptResult {
	var _u StreamSocketAcceptResult
	_u.SetResponse(response)
	return _u
}

func (_m *StreamSocketAcceptResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_streamSocketAcceptResultTag = StreamSocketAcceptResultErr
	_m.Err = err
}

func StreamSocketAcceptResultWithErr(err fuchsiaposix.Errno) StreamSocketAcceptResult {
	var _u StreamSocketAcceptResult
	_u.SetErr(err)
	return _u
}

type I_streamSocketGetInfoResultTag uint64

const (
	StreamSocketGetInfoResultResponse = 1 // 0x00000001
	StreamSocketGetInfoResultErr      = 2 // 0x00000002
)

type StreamSocketGetInfoResult struct {
	I_streamSocketGetInfoResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                       StreamSocketGetInfoResponse `fidl_ordinal:"1"`
	Err                            fuchsiaposix.Errno          `fidl_ordinal:"2"`
}

func (_m *StreamSocketGetInfoResult) reset() {
	switch _m.I_streamSocketGetInfoResultTag {
	case 1:
		var _zeroed StreamSocketGetInfoResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *StreamSocketGetInfoResult) Which() I_streamSocketGetInfoResultTag {
	return _m.I_streamSocketGetInfoResultTag
}

func (_m *StreamSocketGetInfoResult) Ordinal() uint64 {
	return uint64(_m.I_streamSocketGetInfoResultTag)
}

func (_m *StreamSocketGetInfoResult) SetResponse(response StreamSocketGetInfoResponse) {
	_m.reset()
	_m.I_streamSocketGetInfoResultTag = StreamSocketGetInfoResultResponse
	_m.Response = response
}

func StreamSocketGetInfoResultWithResponse(response StreamSocketGetInfoResponse) StreamSocketGetInfoResult {
	var _u StreamSocketGetInfoResult
	_u.SetResponse(response)
	return _u
}

func (_m *StreamSocketGetInfoResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_streamSocketGetInfoResultTag = StreamSocketGetInfoResultErr
	_m.Err = err
}

func StreamSocketGetInfoResultWithErr(err fuchsiaposix.Errno) StreamSocketGetInfoResult {
	var _u StreamSocketGetInfoResult
	_u.SetErr(err)
	return _u
}

type I_streamSocketSetTcpNoDelayResultTag uint64

const (
	StreamSocketSetTcpNoDelayResultResponse = 1 // 0x00000001
	StreamSocketSetTcpNoDelayResultErr      = 2 // 0x00000002
)

type StreamSocketSetTcpNoDelayResult struct {
	I_streamSocketSetTcpNoDelayResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                             StreamSocketSetTcpNoDelayResponse `fidl_ordinal:"1"`
	Err                                  fuchsiaposix.Errno                `fidl_ordinal:"2"`
}

func (_m *StreamSocketSetTcpNoDelayResult) reset() {
	switch _m.I_streamSocketSetTcpNoDelayResultTag {
	case 1:
		var _zeroed StreamSocketSetTcpNoDelayResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *StreamSocketSetTcpNoDelayResult) Which() I_streamSocketSetTcpNoDelayResultTag {
	return _m.I_streamSocketSetTcpNoDelayResultTag
}

func (_m *StreamSocketSetTcpNoDelayResult) Ordinal() uint64 {
	return uint64(_m.I_streamSocketSetTcpNoDelayResultTag)
}

func (_m *StreamSocketSetTcpNoDelayResult) SetResponse(response StreamSocketSetTcpNoDelayResponse) {
	_m.reset()
	_m.I_streamSocketSetTcpNoDelayResultTag = StreamSocketSetTcpNoDelayResultResponse
	_m.Response = response
}

func StreamSocketSetTcpNoDelayResultWithResponse(response StreamSocketSetTcpNoDelayResponse) StreamSocketSetTcpNoDelayResult {
	var _u StreamSocketSetTcpNoDelayResult
	_u.SetResponse(response)
	return _u
}

func (_m *StreamSocketSetTcpNoDelayResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_streamSocketSetTcpNoDelayResultTag = StreamSocketSetTcpNoDelayResultErr
	_m.Err = err
}

func StreamSocketSetTcpNoDelayResultWithErr(err fuchsiaposix.Errno) StreamSocketSetTcpNoDelayResult {
	var _u StreamSocketSetTcpNoDelayResult
	_u.SetErr(err)
	return _u
}

type I_streamSocketGetTcpNoDelayResultTag uint64

const (
	StreamSocketGetTcpNoDelayResultResponse = 1 // 0x00000001
	StreamSocketGetTcpNoDelayResultErr      = 2 // 0x00000002
)

type StreamSocketGetTcpNoDelayResult struct {
	I_streamSocketGetTcpNoDelayResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                             StreamSocketGetTcpNoDelayResponse `fidl_ordinal:"1"`
	Err                                  fuchsiaposix.Errno                `fidl_ordinal:"2"`
}

func (_m *StreamSocketGetTcpNoDelayResult) reset() {
	switch _m.I_streamSocketGetTcpNoDelayResultTag {
	case 1:
		var _zeroed StreamSocketGetTcpNoDelayResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *StreamSocketGetTcpNoDelayResult) Which() I_streamSocketGetTcpNoDelayResultTag {
	return _m.I_streamSocketGetTcpNoDelayResultTag
}

func (_m *StreamSocketGetTcpNoDelayResult) Ordinal() uint64 {
	return uint64(_m.I_streamSocketGetTcpNoDelayResultTag)
}

func (_m *StreamSocketGetTcpNoDelayResult) SetResponse(response StreamSocketGetTcpNoDelayResponse) {
	_m.reset()
	_m.I_streamSocketGetTcpNoDelayResultTag = StreamSocketGetTcpNoDelayResultResponse
	_m.Response = response
}

func StreamSocketGetTcpNoDelayResultWithResponse(response StreamSocketGetTcpNoDelayResponse) StreamSocketGetTcpNoDelayResult {
	var _u StreamSocketGetTcpNoDelayResult
	_u.SetResponse(response)
	return _u
}

func (_m *StreamSocketGetTcpNoDelayResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_streamSocketGetTcpNoDelayResultTag = StreamSocketGetTcpNoDelayResultErr
	_m.Err = err
}

func StreamSocketGetTcpNoDelayResultWithErr(err fuchsiaposix.Errno) StreamSocketGetTcpNoDelayResult {
	var _u StreamSocketGetTcpNoDelayResult
	_u.SetErr(err)
	return _u
}

type I_streamSocketSetTcpMaxSegmentResultTag uint64

const (
	StreamSocketSetTcpMaxSegmentResultResponse = 1 // 0x00000001
	StreamSocketSetTcpMaxSegmentResultErr      = 2 // 0x00000002
)

type StreamSocketSetTcpMaxSegmentResult struct {
	I_streamSocketSetTcpMaxSegmentResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                StreamSocketSetTcpMaxSegmentResponse `fidl_ordinal:"1"`
	Err                                     fuchsiaposix.Errno                   `fidl_ordinal:"2"`
}

func (_m *StreamSocketSetTcpMaxSegmentResult) reset() {
	switch _m.I_streamSocketSetTcpMaxSegmentResultTag {
	case 1:
		var _zeroed StreamSocketSetTcpMaxSegmentResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *StreamSocketSetTcpMaxSegmentResult) Which() I_streamSocketSetTcpMaxSegmentResultTag {
	return _m.I_streamSocketSetTcpMaxSegmentResultTag
}

func (_m *StreamSocketSetTcpMaxSegmentResult) Ordinal() uint64 {
	return uint64(_m.I_streamSocketSetTcpMaxSegmentResultTag)
}

func (_m *StreamSocketSetTcpMaxSegmentResult) SetResponse(response StreamSocketSetTcpMaxSegmentResponse) {
	_m.reset()
	_m.I_streamSocketSetTcpMaxSegmentResultTag = StreamSocketSetTcpMaxSegmentResultResponse
	_m.Response = response
}

func StreamSocketSetTcpMaxSegmentResultWithResponse(response StreamSocketSetTcpMaxSegmentResponse) StreamSocketSetTcpMaxSegmentResult {
	var _u StreamSocketSetTcpMaxSegmentResult
	_u.SetResponse(response)
	return _u
}

func (_m *StreamSocketSetTcpMaxSegmentResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_streamSocketSetTcpMaxSegmentResultTag = StreamSocketSetTcpMaxSegmentResultErr
	_m.Err = err
}

func StreamSocketSetTcpMaxSegmentResultWithErr(err fuchsiaposix.Errno) StreamSocketSetTcpMaxSegmentResult {
	var _u StreamSocketSetTcpMaxSegmentResult
	_u.SetErr(err)
	return _u
}

type I_streamSocketGetTcpMaxSegmentResultTag uint64

const (
	StreamSocketGetTcpMaxSegmentResultResponse = 1 // 0x00000001
	StreamSocketGetTcpMaxSegmentResultErr      = 2 // 0x00000002
)

type StreamSocketGetTcpMaxSegmentResult struct {
	I_streamSocketGetTcpMaxSegmentResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                StreamSocketGetTcpMaxSegmentResponse `fidl_ordinal:"1"`
	Err                                     fuchsiaposix.Errno                   `fidl_ordinal:"2"`
}

func (_m *StreamSocketGetTcpMaxSegmentResult) reset() {
	switch _m.I_streamSocketGetTcpMaxSegmentResultTag {
	case 1:
		var _zeroed StreamSocketGetTcpMaxSegmentResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *StreamSocketGetTcpMaxSegmentResult) Which() I_streamSocketGetTcpMaxSegmentResultTag {
	return _m.I_streamSocketGetTcpMaxSegmentResultTag
}

func (_m *StreamSocketGetTcpMaxSegmentResult) Ordinal() uint64 {
	return uint64(_m.I_streamSocketGetTcpMaxSegmentResultTag)
}

func (_m *StreamSocketGetTcpMaxSegmentResult) SetResponse(response StreamSocketGetTcpMaxSegmentResponse) {
	_m.reset()
	_m.I_streamSocketGetTcpMaxSegmentResultTag = StreamSocketGetTcpMaxSegmentResultResponse
	_m.Response = response
}

func StreamSocketGetTcpMaxSegmentResultWithResponse(response StreamSocketGetTcpMaxSegmentResponse) StreamSocketGetTcpMaxSegmentResult {
	var _u StreamSocketGetTcpMaxSegmentResult
	_u.SetResponse(response)
	return _u
}

func (_m *StreamSocketGetTcpMaxSegmentResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_streamSocketGetTcpMaxSegmentResultTag = StreamSocketGetTcpMaxSegmentResultErr
	_m.Err = err
}

func StreamSocketGetTcpMaxSegmentResultWithErr(err fuchsiaposix.Errno) StreamSocketGetTcpMaxSegmentResult {
	var _u StreamSocketGetTcpMaxSegmentResult
	_u.SetErr(err)
	return _u
}

type I_streamSocketSetTcpCorkResultTag uint64

const (
	StreamSocketSetTcpCorkResultResponse = 1 // 0x00000001
	StreamSocketSetTcpCorkResultErr      = 2 // 0x00000002
)

type StreamSocketSetTcpCorkResult struct {
	I_streamSocketSetTcpCorkResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                          StreamSocketSetTcpCorkResponse `fidl_ordinal:"1"`
	Err                               fuchsiaposix.Errno             `fidl_ordinal:"2"`
}

func (_m *StreamSocketSetTcpCorkResult) reset() {
	switch _m.I_streamSocketSetTcpCorkResultTag {
	case 1:
		var _zeroed StreamSocketSetTcpCorkResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *StreamSocketSetTcpCorkResult) Which() I_streamSocketSetTcpCorkResultTag {
	return _m.I_streamSocketSetTcpCorkResultTag
}

func (_m *StreamSocketSetTcpCorkResult) Ordinal() uint64 {
	return uint64(_m.I_streamSocketSetTcpCorkResultTag)
}

func (_m *StreamSocketSetTcpCorkResult) SetResponse(response StreamSocketSetTcpCorkResponse) {
	_m.reset()
	_m.I_streamSocketSetTcpCorkResultTag = StreamSocketSetTcpCorkResultResponse
	_m.Response = response
}

func StreamSocketSetTcpCorkResultWithResponse(response StreamSocketSetTcpCorkResponse) StreamSocketSetTcpCorkResult {
	var _u StreamSocketSetTcpCorkResult
	_u.SetResponse(response)
	return _u
}

func (_m *StreamSocketSetTcpCorkResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_streamSocketSetTcpCorkResultTag = StreamSocketSetTcpCorkResultErr
	_m.Err = err
}

func StreamSocketSetTcpCorkResultWithErr(err fuchsiaposix.Errno) StreamSocketSetTcpCorkResult {
	var _u StreamSocketSetTcpCorkResult
	_u.SetErr(err)
	return _u
}

type I_streamSocketGetTcpCorkResultTag uint64

const (
	StreamSocketGetTcpCorkResultResponse = 1 // 0x00000001
	StreamSocketGetTcpCorkResultErr      = 2 // 0x00000002
)

type StreamSocketGetTcpCorkResult struct {
	I_streamSocketGetTcpCorkResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                          StreamSocketGetTcpCorkResponse `fidl_ordinal:"1"`
	Err                               fuchsiaposix.Errno             `fidl_ordinal:"2"`
}

func (_m *StreamSocketGetTcpCorkResult) reset() {
	switch _m.I_streamSocketGetTcpCorkResultTag {
	case 1:
		var _zeroed StreamSocketGetTcpCorkResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *StreamSocketGetTcpCorkResult) Which() I_streamSocketGetTcpCorkResultTag {
	return _m.I_streamSocketGetTcpCorkResultTag
}

func (_m *StreamSocketGetTcpCorkResult) Ordinal() uint64 {
	return uint64(_m.I_streamSocketGetTcpCorkResultTag)
}

func (_m *StreamSocketGetTcpCorkResult) SetResponse(response StreamSocketGetTcpCorkResponse) {
	_m.reset()
	_m.I_streamSocketGetTcpCorkResultTag = StreamSocketGetTcpCorkResultResponse
	_m.Response = response
}

func StreamSocketGetTcpCorkResultWithResponse(response StreamSocketGetTcpCorkResponse) StreamSocketGetTcpCorkResult {
	var _u StreamSocketGetTcpCorkResult
	_u.SetResponse(response)
	return _u
}

func (_m *StreamSocketGetTcpCorkResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_streamSocketGetTcpCorkResultTag = StreamSocketGetTcpCorkResultErr
	_m.Err = err
}

func StreamSocketGetTcpCorkResultWithErr(err fuchsiaposix.Errno) StreamSocketGetTcpCorkResult {
	var _u StreamSocketGetTcpCorkResult
	_u.SetErr(err)
	return _u
}

type I_streamSocketSetTcpKeepAliveIdleResultTag uint64

const (
	StreamSocketSetTcpKeepAliveIdleResultResponse = 1 // 0x00000001
	StreamSocketSetTcpKeepAliveIdleResultErr      = 2 // 0x00000002
)

type StreamSocketSetTcpKeepAliveIdleResult struct {
	I_streamSocketSetTcpKeepAliveIdleResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                   StreamSocketSetTcpKeepAliveIdleResponse `fidl_ordinal:"1"`
	Err                                        fuchsiaposix.Errno                      `fidl_ordinal:"2"`
}

func (_m *StreamSocketSetTcpKeepAliveIdleResult) reset() {
	switch _m.I_streamSocketSetTcpKeepAliveIdleResultTag {
	case 1:
		var _zeroed StreamSocketSetTcpKeepAliveIdleResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *StreamSocketSetTcpKeepAliveIdleResult) Which() I_streamSocketSetTcpKeepAliveIdleResultTag {
	return _m.I_streamSocketSetTcpKeepAliveIdleResultTag
}

func (_m *StreamSocketSetTcpKeepAliveIdleResult) Ordinal() uint64 {
	return uint64(_m.I_streamSocketSetTcpKeepAliveIdleResultTag)
}

func (_m *StreamSocketSetTcpKeepAliveIdleResult) SetResponse(response StreamSocketSetTcpKeepAliveIdleResponse) {
	_m.reset()
	_m.I_streamSocketSetTcpKeepAliveIdleResultTag = StreamSocketSetTcpKeepAliveIdleResultResponse
	_m.Response = response
}

func StreamSocketSetTcpKeepAliveIdleResultWithResponse(response StreamSocketSetTcpKeepAliveIdleResponse) StreamSocketSetTcpKeepAliveIdleResult {
	var _u StreamSocketSetTcpKeepAliveIdleResult
	_u.SetResponse(response)
	return _u
}

func (_m *StreamSocketSetTcpKeepAliveIdleResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_streamSocketSetTcpKeepAliveIdleResultTag = StreamSocketSetTcpKeepAliveIdleResultErr
	_m.Err = err
}

func StreamSocketSetTcpKeepAliveIdleResultWithErr(err fuchsiaposix.Errno) StreamSocketSetTcpKeepAliveIdleResult {
	var _u StreamSocketSetTcpKeepAliveIdleResult
	_u.SetErr(err)
	return _u
}

type I_streamSocketGetTcpKeepAliveIdleResultTag uint64

const (
	StreamSocketGetTcpKeepAliveIdleResultResponse = 1 // 0x00000001
	StreamSocketGetTcpKeepAliveIdleResultErr      = 2 // 0x00000002
)

type StreamSocketGetTcpKeepAliveIdleResult struct {
	I_streamSocketGetTcpKeepAliveIdleResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                   StreamSocketGetTcpKeepAliveIdleResponse `fidl_ordinal:"1"`
	Err                                        fuchsiaposix.Errno                      `fidl_ordinal:"2"`
}

func (_m *StreamSocketGetTcpKeepAliveIdleResult) reset() {
	switch _m.I_streamSocketGetTcpKeepAliveIdleResultTag {
	case 1:
		var _zeroed StreamSocketGetTcpKeepAliveIdleResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *StreamSocketGetTcpKeepAliveIdleResult) Which() I_streamSocketGetTcpKeepAliveIdleResultTag {
	return _m.I_streamSocketGetTcpKeepAliveIdleResultTag
}

func (_m *StreamSocketGetTcpKeepAliveIdleResult) Ordinal() uint64 {
	return uint64(_m.I_streamSocketGetTcpKeepAliveIdleResultTag)
}

func (_m *StreamSocketGetTcpKeepAliveIdleResult) SetResponse(response StreamSocketGetTcpKeepAliveIdleResponse) {
	_m.reset()
	_m.I_streamSocketGetTcpKeepAliveIdleResultTag = StreamSocketGetTcpKeepAliveIdleResultResponse
	_m.Response = response
}

func StreamSocketGetTcpKeepAliveIdleResultWithResponse(response StreamSocketGetTcpKeepAliveIdleResponse) StreamSocketGetTcpKeepAliveIdleResult {
	var _u StreamSocketGetTcpKeepAliveIdleResult
	_u.SetResponse(response)
	return _u
}

func (_m *StreamSocketGetTcpKeepAliveIdleResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_streamSocketGetTcpKeepAliveIdleResultTag = StreamSocketGetTcpKeepAliveIdleResultErr
	_m.Err = err
}

func StreamSocketGetTcpKeepAliveIdleResultWithErr(err fuchsiaposix.Errno) StreamSocketGetTcpKeepAliveIdleResult {
	var _u StreamSocketGetTcpKeepAliveIdleResult
	_u.SetErr(err)
	return _u
}

type I_streamSocketSetTcpKeepAliveIntervalResultTag uint64

const (
	StreamSocketSetTcpKeepAliveIntervalResultResponse = 1 // 0x00000001
	StreamSocketSetTcpKeepAliveIntervalResultErr      = 2 // 0x00000002
)

type StreamSocketSetTcpKeepAliveIntervalResult struct {
	I_streamSocketSetTcpKeepAliveIntervalResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                       StreamSocketSetTcpKeepAliveIntervalResponse `fidl_ordinal:"1"`
	Err                                            fuchsiaposix.Errno                          `fidl_ordinal:"2"`
}

func (_m *StreamSocketSetTcpKeepAliveIntervalResult) reset() {
	switch _m.I_streamSocketSetTcpKeepAliveIntervalResultTag {
	case 1:
		var _zeroed StreamSocketSetTcpKeepAliveIntervalResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *StreamSocketSetTcpKeepAliveIntervalResult) Which() I_streamSocketSetTcpKeepAliveIntervalResultTag {
	return _m.I_streamSocketSetTcpKeepAliveIntervalResultTag
}

func (_m *StreamSocketSetTcpKeepAliveIntervalResult) Ordinal() uint64 {
	return uint64(_m.I_streamSocketSetTcpKeepAliveIntervalResultTag)
}

func (_m *StreamSocketSetTcpKeepAliveIntervalResult) SetResponse(response StreamSocketSetTcpKeepAliveIntervalResponse) {
	_m.reset()
	_m.I_streamSocketSetTcpKeepAliveIntervalResultTag = StreamSocketSetTcpKeepAliveIntervalResultResponse
	_m.Response = response
}

func StreamSocketSetTcpKeepAliveIntervalResultWithResponse(response StreamSocketSetTcpKeepAliveIntervalResponse) StreamSocketSetTcpKeepAliveIntervalResult {
	var _u StreamSocketSetTcpKeepAliveIntervalResult
	_u.SetResponse(response)
	return _u
}

func (_m *StreamSocketSetTcpKeepAliveIntervalResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_streamSocketSetTcpKeepAliveIntervalResultTag = StreamSocketSetTcpKeepAliveIntervalResultErr
	_m.Err = err
}

func StreamSocketSetTcpKeepAliveIntervalResultWithErr(err fuchsiaposix.Errno) StreamSocketSetTcpKeepAliveIntervalResult {
	var _u StreamSocketSetTcpKeepAliveIntervalResult
	_u.SetErr(err)
	return _u
}

type I_streamSocketGetTcpKeepAliveIntervalResultTag uint64

const (
	StreamSocketGetTcpKeepAliveIntervalResultResponse = 1 // 0x00000001
	StreamSocketGetTcpKeepAliveIntervalResultErr      = 2 // 0x00000002
)

type StreamSocketGetTcpKeepAliveIntervalResult struct {
	I_streamSocketGetTcpKeepAliveIntervalResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                       StreamSocketGetTcpKeepAliveIntervalResponse `fidl_ordinal:"1"`
	Err                                            fuchsiaposix.Errno                          `fidl_ordinal:"2"`
}

func (_m *StreamSocketGetTcpKeepAliveIntervalResult) reset() {
	switch _m.I_streamSocketGetTcpKeepAliveIntervalResultTag {
	case 1:
		var _zeroed StreamSocketGetTcpKeepAliveIntervalResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *StreamSocketGetTcpKeepAliveIntervalResult) Which() I_streamSocketGetTcpKeepAliveIntervalResultTag {
	return _m.I_streamSocketGetTcpKeepAliveIntervalResultTag
}

func (_m *StreamSocketGetTcpKeepAliveIntervalResult) Ordinal() uint64 {
	return uint64(_m.I_streamSocketGetTcpKeepAliveIntervalResultTag)
}

func (_m *StreamSocketGetTcpKeepAliveIntervalResult) SetResponse(response StreamSocketGetTcpKeepAliveIntervalResponse) {
	_m.reset()
	_m.I_streamSocketGetTcpKeepAliveIntervalResultTag = StreamSocketGetTcpKeepAliveIntervalResultResponse
	_m.Response = response
}

func StreamSocketGetTcpKeepAliveIntervalResultWithResponse(response StreamSocketGetTcpKeepAliveIntervalResponse) StreamSocketGetTcpKeepAliveIntervalResult {
	var _u StreamSocketGetTcpKeepAliveIntervalResult
	_u.SetResponse(response)
	return _u
}

func (_m *StreamSocketGetTcpKeepAliveIntervalResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_streamSocketGetTcpKeepAliveIntervalResultTag = StreamSocketGetTcpKeepAliveIntervalResultErr
	_m.Err = err
}

func StreamSocketGetTcpKeepAliveIntervalResultWithErr(err fuchsiaposix.Errno) StreamSocketGetTcpKeepAliveIntervalResult {
	var _u StreamSocketGetTcpKeepAliveIntervalResult
	_u.SetErr(err)
	return _u
}

type I_streamSocketSetTcpKeepAliveCountResultTag uint64

const (
	StreamSocketSetTcpKeepAliveCountResultResponse = 1 // 0x00000001
	StreamSocketSetTcpKeepAliveCountResultErr      = 2 // 0x00000002
)

type StreamSocketSetTcpKeepAliveCountResult struct {
	I_streamSocketSetTcpKeepAliveCountResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                    StreamSocketSetTcpKeepAliveCountResponse `fidl_ordinal:"1"`
	Err                                         fuchsiaposix.Errno                       `fidl_ordinal:"2"`
}

func (_m *StreamSocketSetTcpKeepAliveCountResult) reset() {
	switch _m.I_streamSocketSetTcpKeepAliveCountResultTag {
	case 1:
		var _zeroed StreamSocketSetTcpKeepAliveCountResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *StreamSocketSetTcpKeepAliveCountResult) Which() I_streamSocketSetTcpKeepAliveCountResultTag {
	return _m.I_streamSocketSetTcpKeepAliveCountResultTag
}

func (_m *StreamSocketSetTcpKeepAliveCountResult) Ordinal() uint64 {
	return uint64(_m.I_streamSocketSetTcpKeepAliveCountResultTag)
}

func (_m *StreamSocketSetTcpKeepAliveCountResult) SetResponse(response StreamSocketSetTcpKeepAliveCountResponse) {
	_m.reset()
	_m.I_streamSocketSetTcpKeepAliveCountResultTag = StreamSocketSetTcpKeepAliveCountResultResponse
	_m.Response = response
}

func StreamSocketSetTcpKeepAliveCountResultWithResponse(response StreamSocketSetTcpKeepAliveCountResponse) StreamSocketSetTcpKeepAliveCountResult {
	var _u StreamSocketSetTcpKeepAliveCountResult
	_u.SetResponse(response)
	return _u
}

func (_m *StreamSocketSetTcpKeepAliveCountResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_streamSocketSetTcpKeepAliveCountResultTag = StreamSocketSetTcpKeepAliveCountResultErr
	_m.Err = err
}

func StreamSocketSetTcpKeepAliveCountResultWithErr(err fuchsiaposix.Errno) StreamSocketSetTcpKeepAliveCountResult {
	var _u StreamSocketSetTcpKeepAliveCountResult
	_u.SetErr(err)
	return _u
}

type I_streamSocketGetTcpKeepAliveCountResultTag uint64

const (
	StreamSocketGetTcpKeepAliveCountResultResponse = 1 // 0x00000001
	StreamSocketGetTcpKeepAliveCountResultErr      = 2 // 0x00000002
)

type StreamSocketGetTcpKeepAliveCountResult struct {
	I_streamSocketGetTcpKeepAliveCountResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                    StreamSocketGetTcpKeepAliveCountResponse `fidl_ordinal:"1"`
	Err                                         fuchsiaposix.Errno                       `fidl_ordinal:"2"`
}

func (_m *StreamSocketGetTcpKeepAliveCountResult) reset() {
	switch _m.I_streamSocketGetTcpKeepAliveCountResultTag {
	case 1:
		var _zeroed StreamSocketGetTcpKeepAliveCountResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *StreamSocketGetTcpKeepAliveCountResult) Which() I_streamSocketGetTcpKeepAliveCountResultTag {
	return _m.I_streamSocketGetTcpKeepAliveCountResultTag
}

func (_m *StreamSocketGetTcpKeepAliveCountResult) Ordinal() uint64 {
	return uint64(_m.I_streamSocketGetTcpKeepAliveCountResultTag)
}

func (_m *StreamSocketGetTcpKeepAliveCountResult) SetResponse(response StreamSocketGetTcpKeepAliveCountResponse) {
	_m.reset()
	_m.I_streamSocketGetTcpKeepAliveCountResultTag = StreamSocketGetTcpKeepAliveCountResultResponse
	_m.Response = response
}

func StreamSocketGetTcpKeepAliveCountResultWithResponse(response StreamSocketGetTcpKeepAliveCountResponse) StreamSocketGetTcpKeepAliveCountResult {
	var _u StreamSocketGetTcpKeepAliveCountResult
	_u.SetResponse(response)
	return _u
}

func (_m *StreamSocketGetTcpKeepAliveCountResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_streamSocketGetTcpKeepAliveCountResultTag = StreamSocketGetTcpKeepAliveCountResultErr
	_m.Err = err
}

func StreamSocketGetTcpKeepAliveCountResultWithErr(err fuchsiaposix.Errno) StreamSocketGetTcpKeepAliveCountResult {
	var _u StreamSocketGetTcpKeepAliveCountResult
	_u.SetErr(err)
	return _u
}

type I_streamSocketSetTcpSynCountResultTag uint64

const (
	StreamSocketSetTcpSynCountResultResponse = 1 // 0x00000001
	StreamSocketSetTcpSynCountResultErr      = 2 // 0x00000002
)

type StreamSocketSetTcpSynCountResult struct {
	I_streamSocketSetTcpSynCountResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                              StreamSocketSetTcpSynCountResponse `fidl_ordinal:"1"`
	Err                                   fuchsiaposix.Errno                 `fidl_ordinal:"2"`
}

func (_m *StreamSocketSetTcpSynCountResult) reset() {
	switch _m.I_streamSocketSetTcpSynCountResultTag {
	case 1:
		var _zeroed StreamSocketSetTcpSynCountResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *StreamSocketSetTcpSynCountResult) Which() I_streamSocketSetTcpSynCountResultTag {
	return _m.I_streamSocketSetTcpSynCountResultTag
}

func (_m *StreamSocketSetTcpSynCountResult) Ordinal() uint64 {
	return uint64(_m.I_streamSocketSetTcpSynCountResultTag)
}

func (_m *StreamSocketSetTcpSynCountResult) SetResponse(response StreamSocketSetTcpSynCountResponse) {
	_m.reset()
	_m.I_streamSocketSetTcpSynCountResultTag = StreamSocketSetTcpSynCountResultResponse
	_m.Response = response
}

func StreamSocketSetTcpSynCountResultWithResponse(response StreamSocketSetTcpSynCountResponse) StreamSocketSetTcpSynCountResult {
	var _u StreamSocketSetTcpSynCountResult
	_u.SetResponse(response)
	return _u
}

func (_m *StreamSocketSetTcpSynCountResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_streamSocketSetTcpSynCountResultTag = StreamSocketSetTcpSynCountResultErr
	_m.Err = err
}

func StreamSocketSetTcpSynCountResultWithErr(err fuchsiaposix.Errno) StreamSocketSetTcpSynCountResult {
	var _u StreamSocketSetTcpSynCountResult
	_u.SetErr(err)
	return _u
}

type I_streamSocketGetTcpSynCountResultTag uint64

const (
	StreamSocketGetTcpSynCountResultResponse = 1 // 0x00000001
	StreamSocketGetTcpSynCountResultErr      = 2 // 0x00000002
)

type StreamSocketGetTcpSynCountResult struct {
	I_streamSocketGetTcpSynCountResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                              StreamSocketGetTcpSynCountResponse `fidl_ordinal:"1"`
	Err                                   fuchsiaposix.Errno                 `fidl_ordinal:"2"`
}

func (_m *StreamSocketGetTcpSynCountResult) reset() {
	switch _m.I_streamSocketGetTcpSynCountResultTag {
	case 1:
		var _zeroed StreamSocketGetTcpSynCountResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *StreamSocketGetTcpSynCountResult) Which() I_streamSocketGetTcpSynCountResultTag {
	return _m.I_streamSocketGetTcpSynCountResultTag
}

func (_m *StreamSocketGetTcpSynCountResult) Ordinal() uint64 {
	return uint64(_m.I_streamSocketGetTcpSynCountResultTag)
}

func (_m *StreamSocketGetTcpSynCountResult) SetResponse(response StreamSocketGetTcpSynCountResponse) {
	_m.reset()
	_m.I_streamSocketGetTcpSynCountResultTag = StreamSocketGetTcpSynCountResultResponse
	_m.Response = response
}

func StreamSocketGetTcpSynCountResultWithResponse(response StreamSocketGetTcpSynCountResponse) StreamSocketGetTcpSynCountResult {
	var _u StreamSocketGetTcpSynCountResult
	_u.SetResponse(response)
	return _u
}

func (_m *StreamSocketGetTcpSynCountResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_streamSocketGetTcpSynCountResultTag = StreamSocketGetTcpSynCountResultErr
	_m.Err = err
}

func StreamSocketGetTcpSynCountResultWithErr(err fuchsiaposix.Errno) StreamSocketGetTcpSynCountResult {
	var _u StreamSocketGetTcpSynCountResult
	_u.SetErr(err)
	return _u
}

type I_streamSocketSetTcpLingerResultTag uint64

const (
	StreamSocketSetTcpLingerResultResponse = 1 // 0x00000001
	StreamSocketSetTcpLingerResultErr      = 2 // 0x00000002
)

type StreamSocketSetTcpLingerResult struct {
	I_streamSocketSetTcpLingerResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                            StreamSocketSetTcpLingerResponse `fidl_ordinal:"1"`
	Err                                 fuchsiaposix.Errno               `fidl_ordinal:"2"`
}

func (_m *StreamSocketSetTcpLingerResult) reset() {
	switch _m.I_streamSocketSetTcpLingerResultTag {
	case 1:
		var _zeroed StreamSocketSetTcpLingerResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *StreamSocketSetTcpLingerResult) Which() I_streamSocketSetTcpLingerResultTag {
	return _m.I_streamSocketSetTcpLingerResultTag
}

func (_m *StreamSocketSetTcpLingerResult) Ordinal() uint64 {
	return uint64(_m.I_streamSocketSetTcpLingerResultTag)
}

func (_m *StreamSocketSetTcpLingerResult) SetResponse(response StreamSocketSetTcpLingerResponse) {
	_m.reset()
	_m.I_streamSocketSetTcpLingerResultTag = StreamSocketSetTcpLingerResultResponse
	_m.Response = response
}

func StreamSocketSetTcpLingerResultWithResponse(response StreamSocketSetTcpLingerResponse) StreamSocketSetTcpLingerResult {
	var _u StreamSocketSetTcpLingerResult
	_u.SetResponse(response)
	return _u
}

func (_m *StreamSocketSetTcpLingerResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_streamSocketSetTcpLingerResultTag = StreamSocketSetTcpLingerResultErr
	_m.Err = err
}

func StreamSocketSetTcpLingerResultWithErr(err fuchsiaposix.Errno) StreamSocketSetTcpLingerResult {
	var _u StreamSocketSetTcpLingerResult
	_u.SetErr(err)
	return _u
}

type I_streamSocketGetTcpLingerResultTag uint64

const (
	StreamSocketGetTcpLingerResultResponse = 1 // 0x00000001
	StreamSocketGetTcpLingerResultErr      = 2 // 0x00000002
)

type StreamSocketGetTcpLingerResult struct {
	I_streamSocketGetTcpLingerResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                            StreamSocketGetTcpLingerResponse `fidl_ordinal:"1"`
	Err                                 fuchsiaposix.Errno               `fidl_ordinal:"2"`
}

func (_m *StreamSocketGetTcpLingerResult) reset() {
	switch _m.I_streamSocketGetTcpLingerResultTag {
	case 1:
		var _zeroed StreamSocketGetTcpLingerResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *StreamSocketGetTcpLingerResult) Which() I_streamSocketGetTcpLingerResultTag {
	return _m.I_streamSocketGetTcpLingerResultTag
}

func (_m *StreamSocketGetTcpLingerResult) Ordinal() uint64 {
	return uint64(_m.I_streamSocketGetTcpLingerResultTag)
}

func (_m *StreamSocketGetTcpLingerResult) SetResponse(response StreamSocketGetTcpLingerResponse) {
	_m.reset()
	_m.I_streamSocketGetTcpLingerResultTag = StreamSocketGetTcpLingerResultResponse
	_m.Response = response
}

func StreamSocketGetTcpLingerResultWithResponse(response StreamSocketGetTcpLingerResponse) StreamSocketGetTcpLingerResult {
	var _u StreamSocketGetTcpLingerResult
	_u.SetResponse(response)
	return _u
}

func (_m *StreamSocketGetTcpLingerResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_streamSocketGetTcpLingerResultTag = StreamSocketGetTcpLingerResultErr
	_m.Err = err
}

func StreamSocketGetTcpLingerResultWithErr(err fuchsiaposix.Errno) StreamSocketGetTcpLingerResult {
	var _u StreamSocketGetTcpLingerResult
	_u.SetErr(err)
	return _u
}

type I_streamSocketSetTcpDeferAcceptResultTag uint64

const (
	StreamSocketSetTcpDeferAcceptResultResponse = 1 // 0x00000001
	StreamSocketSetTcpDeferAcceptResultErr      = 2 // 0x00000002
)

type StreamSocketSetTcpDeferAcceptResult struct {
	I_streamSocketSetTcpDeferAcceptResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                 StreamSocketSetTcpDeferAcceptResponse `fidl_ordinal:"1"`
	Err                                      fuchsiaposix.Errno                    `fidl_ordinal:"2"`
}

func (_m *StreamSocketSetTcpDeferAcceptResult) reset() {
	switch _m.I_streamSocketSetTcpDeferAcceptResultTag {
	case 1:
		var _zeroed StreamSocketSetTcpDeferAcceptResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *StreamSocketSetTcpDeferAcceptResult) Which() I_streamSocketSetTcpDeferAcceptResultTag {
	return _m.I_streamSocketSetTcpDeferAcceptResultTag
}

func (_m *StreamSocketSetTcpDeferAcceptResult) Ordinal() uint64 {
	return uint64(_m.I_streamSocketSetTcpDeferAcceptResultTag)
}

func (_m *StreamSocketSetTcpDeferAcceptResult) SetResponse(response StreamSocketSetTcpDeferAcceptResponse) {
	_m.reset()
	_m.I_streamSocketSetTcpDeferAcceptResultTag = StreamSocketSetTcpDeferAcceptResultResponse
	_m.Response = response
}

func StreamSocketSetTcpDeferAcceptResultWithResponse(response StreamSocketSetTcpDeferAcceptResponse) StreamSocketSetTcpDeferAcceptResult {
	var _u StreamSocketSetTcpDeferAcceptResult
	_u.SetResponse(response)
	return _u
}

func (_m *StreamSocketSetTcpDeferAcceptResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_streamSocketSetTcpDeferAcceptResultTag = StreamSocketSetTcpDeferAcceptResultErr
	_m.Err = err
}

func StreamSocketSetTcpDeferAcceptResultWithErr(err fuchsiaposix.Errno) StreamSocketSetTcpDeferAcceptResult {
	var _u StreamSocketSetTcpDeferAcceptResult
	_u.SetErr(err)
	return _u
}

type I_streamSocketGetTcpDeferAcceptResultTag uint64

const (
	StreamSocketGetTcpDeferAcceptResultResponse = 1 // 0x00000001
	StreamSocketGetTcpDeferAcceptResultErr      = 2 // 0x00000002
)

type StreamSocketGetTcpDeferAcceptResult struct {
	I_streamSocketGetTcpDeferAcceptResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                 StreamSocketGetTcpDeferAcceptResponse `fidl_ordinal:"1"`
	Err                                      fuchsiaposix.Errno                    `fidl_ordinal:"2"`
}

func (_m *StreamSocketGetTcpDeferAcceptResult) reset() {
	switch _m.I_streamSocketGetTcpDeferAcceptResultTag {
	case 1:
		var _zeroed StreamSocketGetTcpDeferAcceptResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *StreamSocketGetTcpDeferAcceptResult) Which() I_streamSocketGetTcpDeferAcceptResultTag {
	return _m.I_streamSocketGetTcpDeferAcceptResultTag
}

func (_m *StreamSocketGetTcpDeferAcceptResult) Ordinal() uint64 {
	return uint64(_m.I_streamSocketGetTcpDeferAcceptResultTag)
}

func (_m *StreamSocketGetTcpDeferAcceptResult) SetResponse(response StreamSocketGetTcpDeferAcceptResponse) {
	_m.reset()
	_m.I_streamSocketGetTcpDeferAcceptResultTag = StreamSocketGetTcpDeferAcceptResultResponse
	_m.Response = response
}

func StreamSocketGetTcpDeferAcceptResultWithResponse(response StreamSocketGetTcpDeferAcceptResponse) StreamSocketGetTcpDeferAcceptResult {
	var _u StreamSocketGetTcpDeferAcceptResult
	_u.SetResponse(response)
	return _u
}

func (_m *StreamSocketGetTcpDeferAcceptResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_streamSocketGetTcpDeferAcceptResultTag = StreamSocketGetTcpDeferAcceptResultErr
	_m.Err = err
}

func StreamSocketGetTcpDeferAcceptResultWithErr(err fuchsiaposix.Errno) StreamSocketGetTcpDeferAcceptResult {
	var _u StreamSocketGetTcpDeferAcceptResult
	_u.SetErr(err)
	return _u
}

type I_streamSocketSetTcpWindowClampResultTag uint64

const (
	StreamSocketSetTcpWindowClampResultResponse = 1 // 0x00000001
	StreamSocketSetTcpWindowClampResultErr      = 2 // 0x00000002
)

type StreamSocketSetTcpWindowClampResult struct {
	I_streamSocketSetTcpWindowClampResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                 StreamSocketSetTcpWindowClampResponse `fidl_ordinal:"1"`
	Err                                      fuchsiaposix.Errno                    `fidl_ordinal:"2"`
}

func (_m *StreamSocketSetTcpWindowClampResult) reset() {
	switch _m.I_streamSocketSetTcpWindowClampResultTag {
	case 1:
		var _zeroed StreamSocketSetTcpWindowClampResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *StreamSocketSetTcpWindowClampResult) Which() I_streamSocketSetTcpWindowClampResultTag {
	return _m.I_streamSocketSetTcpWindowClampResultTag
}

func (_m *StreamSocketSetTcpWindowClampResult) Ordinal() uint64 {
	return uint64(_m.I_streamSocketSetTcpWindowClampResultTag)
}

func (_m *StreamSocketSetTcpWindowClampResult) SetResponse(response StreamSocketSetTcpWindowClampResponse) {
	_m.reset()
	_m.I_streamSocketSetTcpWindowClampResultTag = StreamSocketSetTcpWindowClampResultResponse
	_m.Response = response
}

func StreamSocketSetTcpWindowClampResultWithResponse(response StreamSocketSetTcpWindowClampResponse) StreamSocketSetTcpWindowClampResult {
	var _u StreamSocketSetTcpWindowClampResult
	_u.SetResponse(response)
	return _u
}

func (_m *StreamSocketSetTcpWindowClampResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_streamSocketSetTcpWindowClampResultTag = StreamSocketSetTcpWindowClampResultErr
	_m.Err = err
}

func StreamSocketSetTcpWindowClampResultWithErr(err fuchsiaposix.Errno) StreamSocketSetTcpWindowClampResult {
	var _u StreamSocketSetTcpWindowClampResult
	_u.SetErr(err)
	return _u
}

type I_streamSocketGetTcpWindowClampResultTag uint64

const (
	StreamSocketGetTcpWindowClampResultResponse = 1 // 0x00000001
	StreamSocketGetTcpWindowClampResultErr      = 2 // 0x00000002
)

type StreamSocketGetTcpWindowClampResult struct {
	I_streamSocketGetTcpWindowClampResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                 StreamSocketGetTcpWindowClampResponse `fidl_ordinal:"1"`
	Err                                      fuchsiaposix.Errno                    `fidl_ordinal:"2"`
}

func (_m *StreamSocketGetTcpWindowClampResult) reset() {
	switch _m.I_streamSocketGetTcpWindowClampResultTag {
	case 1:
		var _zeroed StreamSocketGetTcpWindowClampResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *StreamSocketGetTcpWindowClampResult) Which() I_streamSocketGetTcpWindowClampResultTag {
	return _m.I_streamSocketGetTcpWindowClampResultTag
}

func (_m *StreamSocketGetTcpWindowClampResult) Ordinal() uint64 {
	return uint64(_m.I_streamSocketGetTcpWindowClampResultTag)
}

func (_m *StreamSocketGetTcpWindowClampResult) SetResponse(response StreamSocketGetTcpWindowClampResponse) {
	_m.reset()
	_m.I_streamSocketGetTcpWindowClampResultTag = StreamSocketGetTcpWindowClampResultResponse
	_m.Response = response
}

func StreamSocketGetTcpWindowClampResultWithResponse(response StreamSocketGetTcpWindowClampResponse) StreamSocketGetTcpWindowClampResult {
	var _u StreamSocketGetTcpWindowClampResult
	_u.SetResponse(response)
	return _u
}

func (_m *StreamSocketGetTcpWindowClampResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_streamSocketGetTcpWindowClampResultTag = StreamSocketGetTcpWindowClampResultErr
	_m.Err = err
}

func StreamSocketGetTcpWindowClampResultWithErr(err fuchsiaposix.Errno) StreamSocketGetTcpWindowClampResult {
	var _u StreamSocketGetTcpWindowClampResult
	_u.SetErr(err)
	return _u
}

type I_streamSocketGetTcpInfoResultTag uint64

const (
	StreamSocketGetTcpInfoResultResponse = 1 // 0x00000001
	StreamSocketGetTcpInfoResultErr      = 2 // 0x00000002
)

type StreamSocketGetTcpInfoResult struct {
	I_streamSocketGetTcpInfoResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                          StreamSocketGetTcpInfoResponse `fidl_ordinal:"1"`
	Err                               fuchsiaposix.Errno             `fidl_ordinal:"2"`
}

func (_m *StreamSocketGetTcpInfoResult) reset() {
	switch _m.I_streamSocketGetTcpInfoResultTag {
	case 1:
		var _zeroed StreamSocketGetTcpInfoResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *StreamSocketGetTcpInfoResult) Which() I_streamSocketGetTcpInfoResultTag {
	return _m.I_streamSocketGetTcpInfoResultTag
}

func (_m *StreamSocketGetTcpInfoResult) Ordinal() uint64 {
	return uint64(_m.I_streamSocketGetTcpInfoResultTag)
}

func (_m *StreamSocketGetTcpInfoResult) SetResponse(response StreamSocketGetTcpInfoResponse) {
	_m.reset()
	_m.I_streamSocketGetTcpInfoResultTag = StreamSocketGetTcpInfoResultResponse
	_m.Response = response
}

func StreamSocketGetTcpInfoResultWithResponse(response StreamSocketGetTcpInfoResponse) StreamSocketGetTcpInfoResult {
	var _u StreamSocketGetTcpInfoResult
	_u.SetResponse(response)
	return _u
}

func (_m *StreamSocketGetTcpInfoResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_streamSocketGetTcpInfoResultTag = StreamSocketGetTcpInfoResultErr
	_m.Err = err
}

func StreamSocketGetTcpInfoResultWithErr(err fuchsiaposix.Errno) StreamSocketGetTcpInfoResult {
	var _u StreamSocketGetTcpInfoResult
	_u.SetErr(err)
	return _u
}

type I_streamSocketSetTcpQuickAckResultTag uint64

const (
	StreamSocketSetTcpQuickAckResultResponse = 1 // 0x00000001
	StreamSocketSetTcpQuickAckResultErr      = 2 // 0x00000002
)

type StreamSocketSetTcpQuickAckResult struct {
	I_streamSocketSetTcpQuickAckResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                              StreamSocketSetTcpQuickAckResponse `fidl_ordinal:"1"`
	Err                                   fuchsiaposix.Errno                 `fidl_ordinal:"2"`
}

func (_m *StreamSocketSetTcpQuickAckResult) reset() {
	switch _m.I_streamSocketSetTcpQuickAckResultTag {
	case 1:
		var _zeroed StreamSocketSetTcpQuickAckResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *StreamSocketSetTcpQuickAckResult) Which() I_streamSocketSetTcpQuickAckResultTag {
	return _m.I_streamSocketSetTcpQuickAckResultTag
}

func (_m *StreamSocketSetTcpQuickAckResult) Ordinal() uint64 {
	return uint64(_m.I_streamSocketSetTcpQuickAckResultTag)
}

func (_m *StreamSocketSetTcpQuickAckResult) SetResponse(response StreamSocketSetTcpQuickAckResponse) {
	_m.reset()
	_m.I_streamSocketSetTcpQuickAckResultTag = StreamSocketSetTcpQuickAckResultResponse
	_m.Response = response
}

func StreamSocketSetTcpQuickAckResultWithResponse(response StreamSocketSetTcpQuickAckResponse) StreamSocketSetTcpQuickAckResult {
	var _u StreamSocketSetTcpQuickAckResult
	_u.SetResponse(response)
	return _u
}

func (_m *StreamSocketSetTcpQuickAckResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_streamSocketSetTcpQuickAckResultTag = StreamSocketSetTcpQuickAckResultErr
	_m.Err = err
}

func StreamSocketSetTcpQuickAckResultWithErr(err fuchsiaposix.Errno) StreamSocketSetTcpQuickAckResult {
	var _u StreamSocketSetTcpQuickAckResult
	_u.SetErr(err)
	return _u
}

type I_streamSocketGetTcpQuickAckResultTag uint64

const (
	StreamSocketGetTcpQuickAckResultResponse = 1 // 0x00000001
	StreamSocketGetTcpQuickAckResultErr      = 2 // 0x00000002
)

type StreamSocketGetTcpQuickAckResult struct {
	I_streamSocketGetTcpQuickAckResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                              StreamSocketGetTcpQuickAckResponse `fidl_ordinal:"1"`
	Err                                   fuchsiaposix.Errno                 `fidl_ordinal:"2"`
}

func (_m *StreamSocketGetTcpQuickAckResult) reset() {
	switch _m.I_streamSocketGetTcpQuickAckResultTag {
	case 1:
		var _zeroed StreamSocketGetTcpQuickAckResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *StreamSocketGetTcpQuickAckResult) Which() I_streamSocketGetTcpQuickAckResultTag {
	return _m.I_streamSocketGetTcpQuickAckResultTag
}

func (_m *StreamSocketGetTcpQuickAckResult) Ordinal() uint64 {
	return uint64(_m.I_streamSocketGetTcpQuickAckResultTag)
}

func (_m *StreamSocketGetTcpQuickAckResult) SetResponse(response StreamSocketGetTcpQuickAckResponse) {
	_m.reset()
	_m.I_streamSocketGetTcpQuickAckResultTag = StreamSocketGetTcpQuickAckResultResponse
	_m.Response = response
}

func StreamSocketGetTcpQuickAckResultWithResponse(response StreamSocketGetTcpQuickAckResponse) StreamSocketGetTcpQuickAckResult {
	var _u StreamSocketGetTcpQuickAckResult
	_u.SetResponse(response)
	return _u
}

func (_m *StreamSocketGetTcpQuickAckResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_streamSocketGetTcpQuickAckResultTag = StreamSocketGetTcpQuickAckResultErr
	_m.Err = err
}

func StreamSocketGetTcpQuickAckResultWithErr(err fuchsiaposix.Errno) StreamSocketGetTcpQuickAckResult {
	var _u StreamSocketGetTcpQuickAckResult
	_u.SetErr(err)
	return _u
}

type I_streamSocketSetTcpCongestionResultTag uint64

const (
	StreamSocketSetTcpCongestionResultResponse = 1 // 0x00000001
	StreamSocketSetTcpCongestionResultErr      = 2 // 0x00000002
)

type StreamSocketSetTcpCongestionResult struct {
	I_streamSocketSetTcpCongestionResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                StreamSocketSetTcpCongestionResponse `fidl_ordinal:"1"`
	Err                                     fuchsiaposix.Errno                   `fidl_ordinal:"2"`
}

func (_m *StreamSocketSetTcpCongestionResult) reset() {
	switch _m.I_streamSocketSetTcpCongestionResultTag {
	case 1:
		var _zeroed StreamSocketSetTcpCongestionResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *StreamSocketSetTcpCongestionResult) Which() I_streamSocketSetTcpCongestionResultTag {
	return _m.I_streamSocketSetTcpCongestionResultTag
}

func (_m *StreamSocketSetTcpCongestionResult) Ordinal() uint64 {
	return uint64(_m.I_streamSocketSetTcpCongestionResultTag)
}

func (_m *StreamSocketSetTcpCongestionResult) SetResponse(response StreamSocketSetTcpCongestionResponse) {
	_m.reset()
	_m.I_streamSocketSetTcpCongestionResultTag = StreamSocketSetTcpCongestionResultResponse
	_m.Response = response
}

func StreamSocketSetTcpCongestionResultWithResponse(response StreamSocketSetTcpCongestionResponse) StreamSocketSetTcpCongestionResult {
	var _u StreamSocketSetTcpCongestionResult
	_u.SetResponse(response)
	return _u
}

func (_m *StreamSocketSetTcpCongestionResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_streamSocketSetTcpCongestionResultTag = StreamSocketSetTcpCongestionResultErr
	_m.Err = err
}

func StreamSocketSetTcpCongestionResultWithErr(err fuchsiaposix.Errno) StreamSocketSetTcpCongestionResult {
	var _u StreamSocketSetTcpCongestionResult
	_u.SetErr(err)
	return _u
}

type I_streamSocketGetTcpCongestionResultTag uint64

const (
	StreamSocketGetTcpCongestionResultResponse = 1 // 0x00000001
	StreamSocketGetTcpCongestionResultErr      = 2 // 0x00000002
)

type StreamSocketGetTcpCongestionResult struct {
	I_streamSocketGetTcpCongestionResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                StreamSocketGetTcpCongestionResponse `fidl_ordinal:"1"`
	Err                                     fuchsiaposix.Errno                   `fidl_ordinal:"2"`
}

func (_m *StreamSocketGetTcpCongestionResult) reset() {
	switch _m.I_streamSocketGetTcpCongestionResultTag {
	case 1:
		var _zeroed StreamSocketGetTcpCongestionResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *StreamSocketGetTcpCongestionResult) Which() I_streamSocketGetTcpCongestionResultTag {
	return _m.I_streamSocketGetTcpCongestionResultTag
}

func (_m *StreamSocketGetTcpCongestionResult) Ordinal() uint64 {
	return uint64(_m.I_streamSocketGetTcpCongestionResultTag)
}

func (_m *StreamSocketGetTcpCongestionResult) SetResponse(response StreamSocketGetTcpCongestionResponse) {
	_m.reset()
	_m.I_streamSocketGetTcpCongestionResultTag = StreamSocketGetTcpCongestionResultResponse
	_m.Response = response
}

func StreamSocketGetTcpCongestionResultWithResponse(response StreamSocketGetTcpCongestionResponse) StreamSocketGetTcpCongestionResult {
	var _u StreamSocketGetTcpCongestionResult
	_u.SetResponse(response)
	return _u
}

func (_m *StreamSocketGetTcpCongestionResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_streamSocketGetTcpCongestionResultTag = StreamSocketGetTcpCongestionResultErr
	_m.Err = err
}

func StreamSocketGetTcpCongestionResultWithErr(err fuchsiaposix.Errno) StreamSocketGetTcpCongestionResult {
	var _u StreamSocketGetTcpCongestionResult
	_u.SetErr(err)
	return _u
}

type I_streamSocketSetTcpUserTimeoutResultTag uint64

const (
	StreamSocketSetTcpUserTimeoutResultResponse = 1 // 0x00000001
	StreamSocketSetTcpUserTimeoutResultErr      = 2 // 0x00000002
)

type StreamSocketSetTcpUserTimeoutResult struct {
	I_streamSocketSetTcpUserTimeoutResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                 StreamSocketSetTcpUserTimeoutResponse `fidl_ordinal:"1"`
	Err                                      fuchsiaposix.Errno                    `fidl_ordinal:"2"`
}

func (_m *StreamSocketSetTcpUserTimeoutResult) reset() {
	switch _m.I_streamSocketSetTcpUserTimeoutResultTag {
	case 1:
		var _zeroed StreamSocketSetTcpUserTimeoutResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *StreamSocketSetTcpUserTimeoutResult) Which() I_streamSocketSetTcpUserTimeoutResultTag {
	return _m.I_streamSocketSetTcpUserTimeoutResultTag
}

func (_m *StreamSocketSetTcpUserTimeoutResult) Ordinal() uint64 {
	return uint64(_m.I_streamSocketSetTcpUserTimeoutResultTag)
}

func (_m *StreamSocketSetTcpUserTimeoutResult) SetResponse(response StreamSocketSetTcpUserTimeoutResponse) {
	_m.reset()
	_m.I_streamSocketSetTcpUserTimeoutResultTag = StreamSocketSetTcpUserTimeoutResultResponse
	_m.Response = response
}

func StreamSocketSetTcpUserTimeoutResultWithResponse(response StreamSocketSetTcpUserTimeoutResponse) StreamSocketSetTcpUserTimeoutResult {
	var _u StreamSocketSetTcpUserTimeoutResult
	_u.SetResponse(response)
	return _u
}

func (_m *StreamSocketSetTcpUserTimeoutResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_streamSocketSetTcpUserTimeoutResultTag = StreamSocketSetTcpUserTimeoutResultErr
	_m.Err = err
}

func StreamSocketSetTcpUserTimeoutResultWithErr(err fuchsiaposix.Errno) StreamSocketSetTcpUserTimeoutResult {
	var _u StreamSocketSetTcpUserTimeoutResult
	_u.SetErr(err)
	return _u
}

type I_streamSocketGetTcpUserTimeoutResultTag uint64

const (
	StreamSocketGetTcpUserTimeoutResultResponse = 1 // 0x00000001
	StreamSocketGetTcpUserTimeoutResultErr      = 2 // 0x00000002
)

type StreamSocketGetTcpUserTimeoutResult struct {
	I_streamSocketGetTcpUserTimeoutResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                 StreamSocketGetTcpUserTimeoutResponse `fidl_ordinal:"1"`
	Err                                      fuchsiaposix.Errno                    `fidl_ordinal:"2"`
}

func (_m *StreamSocketGetTcpUserTimeoutResult) reset() {
	switch _m.I_streamSocketGetTcpUserTimeoutResultTag {
	case 1:
		var _zeroed StreamSocketGetTcpUserTimeoutResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *StreamSocketGetTcpUserTimeoutResult) Which() I_streamSocketGetTcpUserTimeoutResultTag {
	return _m.I_streamSocketGetTcpUserTimeoutResultTag
}

func (_m *StreamSocketGetTcpUserTimeoutResult) Ordinal() uint64 {
	return uint64(_m.I_streamSocketGetTcpUserTimeoutResultTag)
}

func (_m *StreamSocketGetTcpUserTimeoutResult) SetResponse(response StreamSocketGetTcpUserTimeoutResponse) {
	_m.reset()
	_m.I_streamSocketGetTcpUserTimeoutResultTag = StreamSocketGetTcpUserTimeoutResultResponse
	_m.Response = response
}

func StreamSocketGetTcpUserTimeoutResultWithResponse(response StreamSocketGetTcpUserTimeoutResponse) StreamSocketGetTcpUserTimeoutResult {
	var _u StreamSocketGetTcpUserTimeoutResult
	_u.SetResponse(response)
	return _u
}

func (_m *StreamSocketGetTcpUserTimeoutResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_streamSocketGetTcpUserTimeoutResultTag = StreamSocketGetTcpUserTimeoutResultErr
	_m.Err = err
}

func StreamSocketGetTcpUserTimeoutResultWithErr(err fuchsiaposix.Errno) StreamSocketGetTcpUserTimeoutResult {
	var _u StreamSocketGetTcpUserTimeoutResult
	_u.SetErr(err)
	return _u
}

type I_providerStreamSocketResultTag uint64

const (
	ProviderStreamSocketResultResponse = 1 // 0x00000001
	ProviderStreamSocketResultErr      = 2 // 0x00000002
)

type ProviderStreamSocketResult struct {
	I_providerStreamSocketResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"true"`
	Response                        ProviderStreamSocketResponse `fidl_ordinal:"1"`
	Err                             fuchsiaposix.Errno           `fidl_ordinal:"2"`
}

func (_m *ProviderStreamSocketResult) reset() {
	switch _m.I_providerStreamSocketResultTag {
	case 1:
		var _zeroed ProviderStreamSocketResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *ProviderStreamSocketResult) Which() I_providerStreamSocketResultTag {
	return _m.I_providerStreamSocketResultTag
}

func (_m *ProviderStreamSocketResult) Ordinal() uint64 {
	return uint64(_m.I_providerStreamSocketResultTag)
}

func (_m *ProviderStreamSocketResult) SetResponse(response ProviderStreamSocketResponse) {
	_m.reset()
	_m.I_providerStreamSocketResultTag = ProviderStreamSocketResultResponse
	_m.Response = response
}

func ProviderStreamSocketResultWithResponse(response ProviderStreamSocketResponse) ProviderStreamSocketResult {
	var _u ProviderStreamSocketResult
	_u.SetResponse(response)
	return _u
}

func (_m *ProviderStreamSocketResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_providerStreamSocketResultTag = ProviderStreamSocketResultErr
	_m.Err = err
}

func ProviderStreamSocketResultWithErr(err fuchsiaposix.Errno) ProviderStreamSocketResult {
	var _u ProviderStreamSocketResult
	_u.SetErr(err)
	return _u
}

type I_providerDatagramSocketResultTag uint64

const (
	ProviderDatagramSocketResultResponse = 1 // 0x00000001
	ProviderDatagramSocketResultErr      = 2 // 0x00000002
)

type ProviderDatagramSocketResult struct {
	I_providerDatagramSocketResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"true"`
	Response                          ProviderDatagramSocketResponse `fidl_ordinal:"1"`
	Err                               fuchsiaposix.Errno             `fidl_ordinal:"2"`
}

func (_m *ProviderDatagramSocketResult) reset() {
	switch _m.I_providerDatagramSocketResultTag {
	case 1:
		var _zeroed ProviderDatagramSocketResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *ProviderDatagramSocketResult) Which() I_providerDatagramSocketResultTag {
	return _m.I_providerDatagramSocketResultTag
}

func (_m *ProviderDatagramSocketResult) Ordinal() uint64 {
	return uint64(_m.I_providerDatagramSocketResultTag)
}

func (_m *ProviderDatagramSocketResult) SetResponse(response ProviderDatagramSocketResponse) {
	_m.reset()
	_m.I_providerDatagramSocketResultTag = ProviderDatagramSocketResultResponse
	_m.Response = response
}

func ProviderDatagramSocketResultWithResponse(response ProviderDatagramSocketResponse) ProviderDatagramSocketResult {
	var _u ProviderDatagramSocketResult
	_u.SetResponse(response)
	return _u
}

func (_m *ProviderDatagramSocketResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_providerDatagramSocketResultTag = ProviderDatagramSocketResultErr
	_m.Err = err
}

func ProviderDatagramSocketResultWithErr(err fuchsiaposix.Errno) ProviderDatagramSocketResult {
	var _u ProviderDatagramSocketResult
	_u.SetErr(err)
	return _u
}

type I_providerInterfaceIndexToNameResultTag uint64

const (
	ProviderInterfaceIndexToNameResultResponse = 1 // 0x00000001
	ProviderInterfaceIndexToNameResultErr      = 2 // 0x00000002
)

type ProviderInterfaceIndexToNameResult struct {
	I_providerInterfaceIndexToNameResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                ProviderInterfaceIndexToNameResponse `fidl_ordinal:"1"`
	Err                                     int32                                `fidl_ordinal:"2"`
}

func (_m *ProviderInterfaceIndexToNameResult) reset() {
	switch _m.I_providerInterfaceIndexToNameResultTag {
	case 1:
		var _zeroed ProviderInterfaceIndexToNameResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed int32
		_m.Err = _zeroed
	}
}

func (_m *ProviderInterfaceIndexToNameResult) Which() I_providerInterfaceIndexToNameResultTag {
	return _m.I_providerInterfaceIndexToNameResultTag
}

func (_m *ProviderInterfaceIndexToNameResult) Ordinal() uint64 {
	return uint64(_m.I_providerInterfaceIndexToNameResultTag)
}

func (_m *ProviderInterfaceIndexToNameResult) SetResponse(response ProviderInterfaceIndexToNameResponse) {
	_m.reset()
	_m.I_providerInterfaceIndexToNameResultTag = ProviderInterfaceIndexToNameResultResponse
	_m.Response = response
}

func ProviderInterfaceIndexToNameResultWithResponse(response ProviderInterfaceIndexToNameResponse) ProviderInterfaceIndexToNameResult {
	var _u ProviderInterfaceIndexToNameResult
	_u.SetResponse(response)
	return _u
}

func (_m *ProviderInterfaceIndexToNameResult) SetErr(err int32) {
	_m.reset()
	_m.I_providerInterfaceIndexToNameResultTag = ProviderInterfaceIndexToNameResultErr
	_m.Err = err
}

func ProviderInterfaceIndexToNameResultWithErr(err int32) ProviderInterfaceIndexToNameResult {
	var _u ProviderInterfaceIndexToNameResult
	_u.SetErr(err)
	return _u
}

type I_providerInterfaceNameToIndexResultTag uint64

const (
	ProviderInterfaceNameToIndexResultResponse = 1 // 0x00000001
	ProviderInterfaceNameToIndexResultErr      = 2 // 0x00000002
)

type ProviderInterfaceNameToIndexResult struct {
	I_providerInterfaceNameToIndexResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                ProviderInterfaceNameToIndexResponse `fidl_ordinal:"1"`
	Err                                     int32                                `fidl_ordinal:"2"`
}

func (_m *ProviderInterfaceNameToIndexResult) reset() {
	switch _m.I_providerInterfaceNameToIndexResultTag {
	case 1:
		var _zeroed ProviderInterfaceNameToIndexResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed int32
		_m.Err = _zeroed
	}
}

func (_m *ProviderInterfaceNameToIndexResult) Which() I_providerInterfaceNameToIndexResultTag {
	return _m.I_providerInterfaceNameToIndexResultTag
}

func (_m *ProviderInterfaceNameToIndexResult) Ordinal() uint64 {
	return uint64(_m.I_providerInterfaceNameToIndexResultTag)
}

func (_m *ProviderInterfaceNameToIndexResult) SetResponse(response ProviderInterfaceNameToIndexResponse) {
	_m.reset()
	_m.I_providerInterfaceNameToIndexResultTag = ProviderInterfaceNameToIndexResultResponse
	_m.Response = response
}

func ProviderInterfaceNameToIndexResultWithResponse(response ProviderInterfaceNameToIndexResponse) ProviderInterfaceNameToIndexResult {
	var _u ProviderInterfaceNameToIndexResult
	_u.SetResponse(response)
	return _u
}

func (_m *ProviderInterfaceNameToIndexResult) SetErr(err int32) {
	_m.reset()
	_m.I_providerInterfaceNameToIndexResultTag = ProviderInterfaceNameToIndexResultErr
	_m.Err = err
}

func ProviderInterfaceNameToIndexResultWithErr(err int32) ProviderInterfaceNameToIndexResult {
	var _u ProviderInterfaceNameToIndexResult
	_u.SetErr(err)
	return _u
}

type I_providerInterfaceNameToFlagsResultTag uint64

const (
	ProviderInterfaceNameToFlagsResultResponse = 1 // 0x00000001
	ProviderInterfaceNameToFlagsResultErr      = 2 // 0x00000002
)

type ProviderInterfaceNameToFlagsResult struct {
	I_providerInterfaceNameToFlagsResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                ProviderInterfaceNameToFlagsResponse `fidl_ordinal:"1"`
	Err                                     int32                                `fidl_ordinal:"2"`
}

func (_m *ProviderInterfaceNameToFlagsResult) reset() {
	switch _m.I_providerInterfaceNameToFlagsResultTag {
	case 1:
		var _zeroed ProviderInterfaceNameToFlagsResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed int32
		_m.Err = _zeroed
	}
}

func (_m *ProviderInterfaceNameToFlagsResult) Which() I_providerInterfaceNameToFlagsResultTag {
	return _m.I_providerInterfaceNameToFlagsResultTag
}

func (_m *ProviderInterfaceNameToFlagsResult) Ordinal() uint64 {
	return uint64(_m.I_providerInterfaceNameToFlagsResultTag)
}

func (_m *ProviderInterfaceNameToFlagsResult) SetResponse(response ProviderInterfaceNameToFlagsResponse) {
	_m.reset()
	_m.I_providerInterfaceNameToFlagsResultTag = ProviderInterfaceNameToFlagsResultResponse
	_m.Response = response
}

func ProviderInterfaceNameToFlagsResultWithResponse(response ProviderInterfaceNameToFlagsResponse) ProviderInterfaceNameToFlagsResult {
	var _u ProviderInterfaceNameToFlagsResult
	_u.SetResponse(response)
	return _u
}

func (_m *ProviderInterfaceNameToFlagsResult) SetErr(err int32) {
	_m.reset()
	_m.I_providerInterfaceNameToFlagsResultTag = ProviderInterfaceNameToFlagsResultErr
	_m.Err = err
}

func ProviderInterfaceNameToFlagsResultWithErr(err int32) ProviderInterfaceNameToFlagsResult {
	var _u ProviderInterfaceNameToFlagsResult
	_u.SetErr(err)
	return _u
}

type I_optionalUint8Tag uint64

const (
	OptionalUint8Value = 1 // 0x00000001
	OptionalUint8Unset = 2 // 0x00000002
)

// An optional byte value.
type OptionalUint8 struct {
	I_optionalUint8Tag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Value              uint8 `fidl_ordinal:"1"`
	Unset              Empty `fidl_ordinal:"2"`
}

func (_m *OptionalUint8) reset() {
	switch _m.I_optionalUint8Tag {
	case 1:
		var _zeroed uint8
		_m.Value = _zeroed
	case 2:
		var _zeroed Empty
		_m.Unset = _zeroed
	}
}

func (_m *OptionalUint8) Which() I_optionalUint8Tag {
	return _m.I_optionalUint8Tag
}

func (_m *OptionalUint8) Ordinal() uint64 {
	return uint64(_m.I_optionalUint8Tag)
}

func (_m *OptionalUint8) SetValue(value uint8) {
	_m.reset()
	_m.I_optionalUint8Tag = OptionalUint8Value
	_m.Value = value
}

func OptionalUint8WithValue(value uint8) OptionalUint8 {
	var _u OptionalUint8
	_u.SetValue(value)
	return _u
}

func (_m *OptionalUint8) SetUnset(unset Empty) {
	_m.reset()
	_m.I_optionalUint8Tag = OptionalUint8Unset
	_m.Unset = unset
}

func OptionalUint8WithUnset(unset Empty) OptionalUint8 {
	var _u OptionalUint8
	_u.SetUnset(unset)
	return _u
}

type I_optionalUint32Tag uint64

const (
	OptionalUint32Value = 1 // 0x00000001
	OptionalUint32Unset = 2 // 0x00000002
)

// An optional uint32 value.
type OptionalUint32 struct {
	I_optionalUint32Tag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Value               uint32 `fidl_ordinal:"1"`
	Unset               Empty  `fidl_ordinal:"2"`
}

func (_m *OptionalUint32) reset() {
	switch _m.I_optionalUint32Tag {
	case 1:
		var _zeroed uint32
		_m.Value = _zeroed
	case 2:
		var _zeroed Empty
		_m.Unset = _zeroed
	}
}

func (_m *OptionalUint32) Which() I_optionalUint32Tag {
	return _m.I_optionalUint32Tag
}

func (_m *OptionalUint32) Ordinal() uint64 {
	return uint64(_m.I_optionalUint32Tag)
}

func (_m *OptionalUint32) SetValue(value uint32) {
	_m.reset()
	_m.I_optionalUint32Tag = OptionalUint32Value
	_m.Value = value
}

func OptionalUint32WithValue(value uint32) OptionalUint32 {
	var _u OptionalUint32
	_u.SetValue(value)
	return _u
}

func (_m *OptionalUint32) SetUnset(unset Empty) {
	_m.reset()
	_m.I_optionalUint32Tag = OptionalUint32Unset
	_m.Unset = unset
}

func OptionalUint32WithUnset(unset Empty) OptionalUint32 {
	var _u OptionalUint32
	_u.SetUnset(unset)
	return _u
}

// Ancillary data for sending datagram sockets.
type SendControlData struct {
	_             struct{} `fidl:"t" fidl_size_v1:"16" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	I_unknownData interface{}
}

func (u *SendControlData) HasUnknownData() bool {
	return u.I_unknownData != nil
}

func (u *SendControlData) GetUnknownData() map[uint64]_bindings.UnknownData {
	return u.I_unknownData.(map[uint64]_bindings.UnknownData)
}

// Ancillary data for received datagram sockets.
type RecvControlData struct {
	_             struct{} `fidl:"t" fidl_size_v1:"16" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	I_unknownData interface{}
}

func (u *RecvControlData) HasUnknownData() bool {
	return u.I_unknownData != nil
}

func (u *RecvControlData) GetUnknownData() map[uint64]_bindings.UnknownData {
	return u.I_unknownData.(map[uint64]_bindings.UnknownData)
}

// TCP protocol state.
type TcpInfo struct {
	_                  struct{} `fidl:"t" fidl_size_v1:"16" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	I_unknownData      interface{}
	State              TcpState `fidl_ordinal:"1"`
	StatePresent       bool
	CaState            TcpCongestionControlState `fidl_ordinal:"2"`
	CaStatePresent     bool
	RtoUsec            uint32 `fidl_ordinal:"11"`
	RtoUsecPresent     bool
	RttUsec            uint32 `fidl_ordinal:"26"`
	RttUsecPresent     bool
	RttVarUsec         uint32 `fidl_ordinal:"27"`
	RttVarUsecPresent  bool
	SndSsthresh        uint32 `fidl_ordinal:"28"`
	SndSsthreshPresent bool
	SndCwnd            uint32 `fidl_ordinal:"29"`
	SndCwndPresent     bool
	ReorderSeen        bool `fidl_ordinal:"54"`
	ReorderSeenPresent bool
}

func (u *TcpInfo) SetState(state TcpState) {
	u.State = state
	u.StatePresent = true
}

func (u *TcpInfo) GetState() TcpState {
	return u.State
}

func (u *TcpInfo) GetStateWithDefault(_default TcpState) TcpState {
	if !u.HasState() {
		return _default
	}
	return u.State
}

func (u *TcpInfo) HasState() bool {
	return u.StatePresent
}

func (u *TcpInfo) ClearState() {
	u.StatePresent = false
}

func (u *TcpInfo) SetCaState(caState TcpCongestionControlState) {
	u.CaState = caState
	u.CaStatePresent = true
}

func (u *TcpInfo) GetCaState() TcpCongestionControlState {
	return u.CaState
}

func (u *TcpInfo) GetCaStateWithDefault(_default TcpCongestionControlState) TcpCongestionControlState {
	if !u.HasCaState() {
		return _default
	}
	return u.CaState
}

func (u *TcpInfo) HasCaState() bool {
	return u.CaStatePresent
}

func (u *TcpInfo) ClearCaState() {
	u.CaStatePresent = false
}

func (u *TcpInfo) SetRtoUsec(rtoUsec uint32) {
	u.RtoUsec = rtoUsec
	u.RtoUsecPresent = true
}

func (u *TcpInfo) GetRtoUsec() uint32 {
	return u.RtoUsec
}

func (u *TcpInfo) GetRtoUsecWithDefault(_default uint32) uint32 {
	if !u.HasRtoUsec() {
		return _default
	}
	return u.RtoUsec
}

func (u *TcpInfo) HasRtoUsec() bool {
	return u.RtoUsecPresent
}

func (u *TcpInfo) ClearRtoUsec() {
	u.RtoUsecPresent = false
}

func (u *TcpInfo) SetRttUsec(rttUsec uint32) {
	u.RttUsec = rttUsec
	u.RttUsecPresent = true
}

func (u *TcpInfo) GetRttUsec() uint32 {
	return u.RttUsec
}

func (u *TcpInfo) GetRttUsecWithDefault(_default uint32) uint32 {
	if !u.HasRttUsec() {
		return _default
	}
	return u.RttUsec
}

func (u *TcpInfo) HasRttUsec() bool {
	return u.RttUsecPresent
}

func (u *TcpInfo) ClearRttUsec() {
	u.RttUsecPresent = false
}

func (u *TcpInfo) SetRttVarUsec(rttVarUsec uint32) {
	u.RttVarUsec = rttVarUsec
	u.RttVarUsecPresent = true
}

func (u *TcpInfo) GetRttVarUsec() uint32 {
	return u.RttVarUsec
}

func (u *TcpInfo) GetRttVarUsecWithDefault(_default uint32) uint32 {
	if !u.HasRttVarUsec() {
		return _default
	}
	return u.RttVarUsec
}

func (u *TcpInfo) HasRttVarUsec() bool {
	return u.RttVarUsecPresent
}

func (u *TcpInfo) ClearRttVarUsec() {
	u.RttVarUsecPresent = false
}

func (u *TcpInfo) SetSndSsthresh(sndSsthresh uint32) {
	u.SndSsthresh = sndSsthresh
	u.SndSsthreshPresent = true
}

func (u *TcpInfo) GetSndSsthresh() uint32 {
	return u.SndSsthresh
}

func (u *TcpInfo) GetSndSsthreshWithDefault(_default uint32) uint32 {
	if !u.HasSndSsthresh() {
		return _default
	}
	return u.SndSsthresh
}

func (u *TcpInfo) HasSndSsthresh() bool {
	return u.SndSsthreshPresent
}

func (u *TcpInfo) ClearSndSsthresh() {
	u.SndSsthreshPresent = false
}

func (u *TcpInfo) SetSndCwnd(sndCwnd uint32) {
	u.SndCwnd = sndCwnd
	u.SndCwndPresent = true
}

func (u *TcpInfo) GetSndCwnd() uint32 {
	return u.SndCwnd
}

func (u *TcpInfo) GetSndCwndWithDefault(_default uint32) uint32 {
	if !u.HasSndCwnd() {
		return _default
	}
	return u.SndCwnd
}

func (u *TcpInfo) HasSndCwnd() bool {
	return u.SndCwndPresent
}

func (u *TcpInfo) ClearSndCwnd() {
	u.SndCwndPresent = false
}

func (u *TcpInfo) SetReorderSeen(reorderSeen bool) {
	u.ReorderSeen = reorderSeen
	u.ReorderSeenPresent = true
}

func (u *TcpInfo) GetReorderSeen() bool {
	return u.ReorderSeen
}

func (u *TcpInfo) GetReorderSeenWithDefault(_default bool) bool {
	if !u.HasReorderSeen() {
		return _default
	}
	return u.ReorderSeen
}

func (u *TcpInfo) HasReorderSeen() bool {
	return u.ReorderSeenPresent
}

func (u *TcpInfo) ClearReorderSeen() {
	u.ReorderSeenPresent = false
}

func (u *TcpInfo) HasUnknownData() bool {
	return u.I_unknownData != nil
}

func (u *TcpInfo) GetUnknownData() map[uint64]_bindings.UnknownData {
	return u.I_unknownData.(map[uint64]_bindings.UnknownData)
}

// Holds information about an interface and its addresses.
type InterfaceAddresses struct {
	_             struct{} `fidl:"t" fidl_size_v1:"16" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	I_unknownData interface{}
	// ID of the interface.
	Id        uint64 `fidl_ordinal:"1"`
	IdPresent bool
	// Name of the interface.
	Name        string `fidl_bounds:"15" fidl_ordinal:"2"`
	NamePresent bool
	// Contains the interface flags, as returned by the SIOCGIFFLAGS ioctl
	// operation.
	//
	// TODO(fxbug.dev/64758): remove this once all clients are transitioned to
	// use more strongly-typed `interface_flags`.
	Flags        uint32 `fidl_ordinal:"3"`
	FlagsPresent bool
	// All addresses currently assigned to the interface.
	Addresses        []fuchsianet.Subnet `fidl_bounds:"" fidl_ordinal:"4"`
	AddressesPresent bool
	// Contains the interface flags, as returned by the SIOCGIFFLAGS ioctl
	// operation.
	InterfaceFlags        InterfaceFlags `fidl_ordinal:"5"`
	InterfaceFlagsPresent bool
}

func (u *InterfaceAddresses) SetId(id uint64) {
	u.Id = id
	u.IdPresent = true
}

func (u *InterfaceAddresses) GetId() uint64 {
	return u.Id
}

func (u *InterfaceAddresses) GetIdWithDefault(_default uint64) uint64 {
	if !u.HasId() {
		return _default
	}
	return u.Id
}

func (u *InterfaceAddresses) HasId() bool {
	return u.IdPresent
}

func (u *InterfaceAddresses) ClearId() {
	u.IdPresent = false
}

func (u *InterfaceAddresses) SetName(name string) {
	u.Name = name
	u.NamePresent = true
}

func (u *InterfaceAddresses) GetName() string {
	return u.Name
}

func (u *InterfaceAddresses) GetNameWithDefault(_default string) string {
	if !u.HasName() {
		return _default
	}
	return u.Name
}

func (u *InterfaceAddresses) HasName() bool {
	return u.NamePresent
}

func (u *InterfaceAddresses) ClearName() {
	u.NamePresent = false
}

func (u *InterfaceAddresses) SetFlags(flags uint32) {
	u.Flags = flags
	u.FlagsPresent = true
}

func (u *InterfaceAddresses) GetFlags() uint32 {
	return u.Flags
}

func (u *InterfaceAddresses) GetFlagsWithDefault(_default uint32) uint32 {
	if !u.HasFlags() {
		return _default
	}
	return u.Flags
}

func (u *InterfaceAddresses) HasFlags() bool {
	return u.FlagsPresent
}

func (u *InterfaceAddresses) ClearFlags() {
	u.FlagsPresent = false
}

func (u *InterfaceAddresses) SetAddresses(addresses []fuchsianet.Subnet) {
	u.Addresses = addresses
	u.AddressesPresent = true
}

func (u *InterfaceAddresses) GetAddresses() []fuchsianet.Subnet {
	return u.Addresses
}

func (u *InterfaceAddresses) GetAddressesWithDefault(_default []fuchsianet.Subnet) []fuchsianet.Subnet {
	if !u.HasAddresses() {
		return _default
	}
	return u.Addresses
}

func (u *InterfaceAddresses) HasAddresses() bool {
	return u.AddressesPresent
}

func (u *InterfaceAddresses) ClearAddresses() {
	u.AddressesPresent = false
}

func (u *InterfaceAddresses) SetInterfaceFlags(interfaceFlags InterfaceFlags) {
	u.InterfaceFlags = interfaceFlags
	u.InterfaceFlagsPresent = true
}

func (u *InterfaceAddresses) GetInterfaceFlags() InterfaceFlags {
	return u.InterfaceFlags
}

func (u *InterfaceAddresses) GetInterfaceFlagsWithDefault(_default InterfaceFlags) InterfaceFlags {
	if !u.HasInterfaceFlags() {
		return _default
	}
	return u.InterfaceFlags
}

func (u *InterfaceAddresses) HasInterfaceFlags() bool {
	return u.InterfaceFlagsPresent
}

func (u *InterfaceAddresses) ClearInterfaceFlags() {
	u.InterfaceFlagsPresent = false
}

func (u *InterfaceAddresses) HasUnknownData() bool {
	return u.I_unknownData != nil
}

func (u *InterfaceAddresses) GetUnknownData() map[uint64]_bindings.UnknownData {
	return u.I_unknownData.(map[uint64]_bindings.UnknownData)
}

const (
	BaseSocketCloneOrdinal                      uint64 = 0x5a61678f293ce16f
	BaseSocketCloseOrdinal                      uint64 = 0x5309c5bd1c33dc44
	BaseSocketDescribeOrdinal                   uint64 = 0xffcec215078dea0
	BaseSocketOnOpenOrdinal                     uint64 = 0x7fc7bbb1dbfd1972
	BaseSocketSyncOrdinal                       uint64 = 0x189d88326c18b519
	BaseSocketGetAttrOrdinal                    uint64 = 0x78985e216314dafd
	BaseSocketSetAttrOrdinal                    uint64 = 0x4186c0f40d938f46
	BaseSocketNodeGetFlagsOrdinal               uint64 = 0x5b88fffb8eda3aa1
	BaseSocketNodeSetFlagsOrdinal               uint64 = 0x5295b76c71fde733
	BaseSocketBindOrdinal                       uint64 = 0xf8457e6b05e15bc
	BaseSocketConnectOrdinal                    uint64 = 0x17abeee0b9843bb1
	BaseSocketDisconnectOrdinal                 uint64 = 0x20eaedba2e0f70a4
	BaseSocketGetSockNameOrdinal                uint64 = 0x41a618ef19a91f9d
	BaseSocketGetPeerNameOrdinal                uint64 = 0x4009d08a4beb5e95
	BaseSocketShutdownOrdinal                   uint64 = 0x382080a1d15b2111
	BaseSocketShutdown2Ordinal                  uint64 = 0x57d3458f9754763b
	BaseSocketSetReuseAddressOrdinal            uint64 = 0x1fd74ee8b9a4a876
	BaseSocketGetReuseAddressOrdinal            uint64 = 0x67b7206b8d1bc0a5
	BaseSocketGetErrorOrdinal                   uint64 = 0x5aad39b33e5f6ebb
	BaseSocketSetBroadcastOrdinal               uint64 = 0x6023e081ce3cd947
	BaseSocketGetBroadcastOrdinal               uint64 = 0x68796fc556f9780d
	BaseSocketSetSendBufferOrdinal              uint64 = 0x756eac32d73a7a70
	BaseSocketGetSendBufferOrdinal              uint64 = 0x78a52fd9c7b2410b
	BaseSocketSetReceiveBufferOrdinal           uint64 = 0x6b0cf2f1919c7001
	BaseSocketGetReceiveBufferOrdinal           uint64 = 0x14c1a4b64f709e5c
	BaseSocketSetKeepAliveOrdinal               uint64 = 0x572df8f0b920d2c7
	BaseSocketGetKeepAliveOrdinal               uint64 = 0x2dd29d3215f2c9d2
	BaseSocketSetOutOfBandInlineOrdinal         uint64 = 0x3ecb49968bee439
	BaseSocketGetOutOfBandInlineOrdinal         uint64 = 0x348c1ab3aeca1745
	BaseSocketSetNoCheckOrdinal                 uint64 = 0x6bbf00c53a4c78c2
	BaseSocketGetNoCheckOrdinal                 uint64 = 0x2cd4249286417694
	BaseSocketSetLingerOrdinal                  uint64 = 0x45386351246e998e
	BaseSocketGetLingerOrdinal                  uint64 = 0x48eb20fc5ccb0e45
	BaseSocketSetReusePortOrdinal               uint64 = 0x24dd3e5cb36d9ccb
	BaseSocketGetReusePortOrdinal               uint64 = 0x7a112c1ab54ff828
	BaseSocketGetAcceptConnOrdinal              uint64 = 0x67ce6db6c2ec8966
	BaseSocketSetBindToDeviceOrdinal            uint64 = 0x2118b483f28aafc4
	BaseSocketGetBindToDeviceOrdinal            uint64 = 0x1ab1fbf0ef7906c8
	BaseSocketSetTimestampOrdinal               uint64 = 0x285d6516c263d839
	BaseSocketGetTimestampOrdinal               uint64 = 0x49f2fffbbcc2bd27
	BaseSocketSetIpTypeOfServiceOrdinal         uint64 = 0x559849ba9574834a
	BaseSocketGetIpTypeOfServiceOrdinal         uint64 = 0x2740d6bfa379deb1
	BaseSocketSetIpTtlOrdinal                   uint64 = 0x67395f7176d7918e
	BaseSocketGetIpTtlOrdinal                   uint64 = 0x789d5ddfe26b97ac
	BaseSocketSetIpPacketInfoOrdinal            uint64 = 0x3e02030a2fd13c03
	BaseSocketGetIpPacketInfoOrdinal            uint64 = 0x176f008d5a0dab15
	BaseSocketSetIpReceiveTypeOfServiceOrdinal  uint64 = 0x17148064e563dde5
	BaseSocketGetIpReceiveTypeOfServiceOrdinal  uint64 = 0x26cc26653b0fa460
	BaseSocketSetIpMulticastInterfaceOrdinal    uint64 = 0x6566fdb7061bbcf8
	BaseSocketGetIpMulticastInterfaceOrdinal    uint64 = 0x44415752b16ff024
	BaseSocketSetIpMulticastTtlOrdinal          uint64 = 0x7d1a477776ba00d3
	BaseSocketGetIpMulticastTtlOrdinal          uint64 = 0x17cbd4bd9246fc40
	BaseSocketSetIpMulticastLoopbackOrdinal     uint64 = 0x2a56b32f8f02369
	BaseSocketGetIpMulticastLoopbackOrdinal     uint64 = 0x27b16d7883c08ca8
	BaseSocketAddIpMembershipOrdinal            uint64 = 0x39a4eda6580147a0
	BaseSocketDropIpMembershipOrdinal           uint64 = 0x6d16e8fbaf496254
	BaseSocketAddIpv6MembershipOrdinal          uint64 = 0x231556bfce3194c1
	BaseSocketDropIpv6MembershipOrdinal         uint64 = 0x629c12db293444c0
	BaseSocketSetIpv6MulticastInterfaceOrdinal  uint64 = 0x5d2a568e67b54234
	BaseSocketGetIpv6MulticastInterfaceOrdinal  uint64 = 0x7b8f38fe354f32bc
	BaseSocketSetIpv6MulticastHopsOrdinal       uint64 = 0x2b2167d12c8a495d
	BaseSocketGetIpv6MulticastHopsOrdinal       uint64 = 0x51a3c8257b1a2745
	BaseSocketSetIpv6MulticastLoopbackOrdinal   uint64 = 0x97706949c4163b7
	BaseSocketGetIpv6MulticastLoopbackOrdinal   uint64 = 0x78d6544e48794935
	BaseSocketSetIpv6OnlyOrdinal                uint64 = 0x1d87ce5c02d8bcb2
	BaseSocketGetIpv6OnlyOrdinal                uint64 = 0x25d6755dbe2e9c7e
	BaseSocketSetIpv6ReceiveTrafficClassOrdinal uint64 = 0x53b93b71c9431fe4
	BaseSocketGetIpv6ReceiveTrafficClassOrdinal uint64 = 0x1c8433af11cd4596
	BaseSocketSetIpv6TrafficClassOrdinal        uint64 = 0x32da0ca485fad782
	BaseSocketGetIpv6TrafficClassOrdinal        uint64 = 0x6ca5b9166c8d3cba
)

type BaseSocketWithCtxInterface _bindings.ChannelProxy

// Create another connection to the same remote object.
//
// `flags` may be any of:
//
// - `OPEN_RIGHT_*`
// - `OPEN_FLAG_APPEND`
// - `OPEN_FLAG_NO_REMOTE`
// - `OPEN_FLAG_DESCRIBE`
// - `CLONE_FLAG_SAME_RIGHTS`
//
// All other flags are ignored.
//
// The `OPEN_RIGHT_*` bits in `flags` request corresponding rights over the resulting
// cloned object.
// The cloned object must have rights less than or equal to the original object, otherwise
// returns `ZX_ERR_ACCESS_DENIED`.
// Alternatively, pass `CLONE_FLAG_SAME_RIGHTS` to inherit the rights on the source connection.
// It is invalid to pass any of the `OPEN_RIGHT_*` flags together with
// `CLONE_FLAG_SAME_RIGHTS`.
func (p *BaseSocketWithCtxInterface) Clone(ctx_ _bindings.Context, flags uint32, object fuchsiaio.NodeWithCtxInterfaceRequest) error {
	req_ := &baseSocketWithCtxCloneRequest{
		Flags:  flags,
		Object: object,
	}
	err_ := ((*_bindings.ChannelProxy)(p)).Send(BaseSocketCloneOrdinal, req_)
	return err_
}

// Terminates connection with object.
//
// This method does not require any rights.
func (p *BaseSocketWithCtxInterface) Close(ctx_ _bindings.Context) (int32, error) {
	var req_ _bindings.Message
	resp_ := &baseSocketWithCtxCloseResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketCloseOrdinal, req_, resp_)
	return resp_.S, err_
}

// Returns extra information about the type of the object.
// If the `Describe` operation fails, the connection is closed.
//
// This method does not require any rights.
func (p *BaseSocketWithCtxInterface) Describe(ctx_ _bindings.Context) (fuchsiaio.NodeInfo, error) {
	var req_ _bindings.Message
	resp_ := &baseSocketWithCtxDescribeResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketDescribeOrdinal, req_, resp_)
	return resp_.Info, err_
}

// An event produced eagerly by a FIDL server if requested by `OPEN_FLAG_DESCRIBE`.
//
// Indicates the success or failure of the open operation, and optionally describes the
// object. If the status is `ZX_OK`, `info` contains descriptive information about the object
// (the same as would be returned by `Describe`).
func (p *BaseSocketWithCtxInterface) ExpectOnOpen(ctx_ _bindings.Context) (int32, *fuchsiaio.NodeInfo, error) {
	resp_ := &baseSocketWithCtxOnOpenResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Recv(BaseSocketOnOpenOrdinal, resp_)
	return resp_.S, resp_.Info, err_
}

// Synchronizes updates to the node to the underlying media, if it exists.
//
// This method does not require any rights.
func (p *BaseSocketWithCtxInterface) Sync(ctx_ _bindings.Context) (int32, error) {
	var req_ _bindings.Message
	resp_ := &baseSocketWithCtxSyncResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketSyncOrdinal, req_, resp_)
	return resp_.S, err_
}

// Acquires information about the node.
//
// This method does not require any rights.
func (p *BaseSocketWithCtxInterface) GetAttr(ctx_ _bindings.Context) (int32, fuchsiaio.NodeAttributes, error) {
	var req_ _bindings.Message
	resp_ := &baseSocketWithCtxGetAttrResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketGetAttrOrdinal, req_, resp_)
	return resp_.S, resp_.Attributes, err_
}

// Updates information about the node.
// `flags` may be any of `NODE_ATTRIBUTE_FLAG_*`.
//
// This method requires following rights: `OPEN_RIGHT_WRITABLE`, otherwise returns
// `ZX_ERR_BAD_HANDLE`.
func (p *BaseSocketWithCtxInterface) SetAttr(ctx_ _bindings.Context, flags uint32, attributes fuchsiaio.NodeAttributes) (int32, error) {
	req_ := &baseSocketWithCtxSetAttrRequest{
		Flags:      flags,
		Attributes: attributes,
	}
	resp_ := &baseSocketWithCtxSetAttrResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketSetAttrOrdinal, req_, resp_)
	return resp_.S, err_
}

// Acquires the `Directory.Open` rights and flags used to access this file.
//
// This method does not require any rights.
// This method has the same functionality as GetFlags for File and is
// meant as an in-progress replacement.
func (p *BaseSocketWithCtxInterface) NodeGetFlags(ctx_ _bindings.Context) (int32, uint32, error) {
	var req_ _bindings.Message
	resp_ := &baseSocketWithCtxNodeGetFlagsResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketNodeGetFlagsOrdinal, req_, resp_)
	return resp_.S, resp_.Flags, err_
}

// Changes the `Directory.Open` flags used to access the file.
// Supported flags which can be turned on / off:
// - `OPEN_FLAG_APPEND`
//
// This method does not require any rights.
// This method has the same functionality as SetFlags for File and is
// meant as an in-progress replacement.
func (p *BaseSocketWithCtxInterface) NodeSetFlags(ctx_ _bindings.Context, flags uint32) (int32, error) {
	req_ := &baseSocketWithCtxNodeSetFlagsRequest{
		Flags: flags,
	}
	resp_ := &baseSocketWithCtxNodeSetFlagsResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketNodeSetFlagsOrdinal, req_, resp_)
	return resp_.S, err_
}

// Sets the local address used for the socket.
func (p *BaseSocketWithCtxInterface) Bind(ctx_ _bindings.Context, addr fuchsianet.SocketAddress) (BaseSocketBindResult, error) {
	req_ := &baseSocketWithCtxBindRequest{
		Addr: addr,
	}
	resp_ := &baseSocketWithCtxBindResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketBindOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Initiates a connection to a remote address.
func (p *BaseSocketWithCtxInterface) Connect(ctx_ _bindings.Context, addr fuchsianet.SocketAddress) (BaseSocketConnectResult, error) {
	req_ := &baseSocketWithCtxConnectRequest{
		Addr: addr,
	}
	resp_ := &baseSocketWithCtxConnectResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketConnectOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Clears connection information from this socket.
func (p *BaseSocketWithCtxInterface) Disconnect(ctx_ _bindings.Context) (BaseSocketDisconnectResult, error) {
	var req_ _bindings.Message
	resp_ := &baseSocketWithCtxDisconnectResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketDisconnectOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Retrieves the local socket address.
func (p *BaseSocketWithCtxInterface) GetSockName(ctx_ _bindings.Context) (BaseSocketGetSockNameResult, error) {
	var req_ _bindings.Message
	resp_ := &baseSocketWithCtxGetSockNameResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketGetSockNameOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Retrieves the remote socket address.
func (p *BaseSocketWithCtxInterface) GetPeerName(ctx_ _bindings.Context) (BaseSocketGetPeerNameResult, error) {
	var req_ _bindings.Message
	resp_ := &baseSocketWithCtxGetPeerNameResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketGetPeerNameOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Shuts down part of the socket.
func (p *BaseSocketWithCtxInterface) Shutdown(ctx_ _bindings.Context, mode ShutdownMode) (BaseSocketShutdownResult, error) {
	req_ := &baseSocketWithCtxShutdownRequest{
		Mode: mode,
	}
	resp_ := &baseSocketWithCtxShutdownResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketShutdownOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *BaseSocketWithCtxInterface) Shutdown2(ctx_ _bindings.Context, mode ShutdownMode) (BaseSocketShutdown2Result, error) {
	req_ := &baseSocketWithCtxShutdown2Request{
		Mode: mode,
	}
	resp_ := &baseSocketWithCtxShutdown2Response{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketShutdown2Ordinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_SOCKET` -> `SO_REUSEADDR`.
func (p *BaseSocketWithCtxInterface) SetReuseAddress(ctx_ _bindings.Context, value bool) (BaseSocketSetReuseAddressResult, error) {
	req_ := &baseSocketWithCtxSetReuseAddressRequest{
		Value: value,
	}
	resp_ := &baseSocketWithCtxSetReuseAddressResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketSetReuseAddressOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_SOCKET` -> `SO_REUSEADDR`.
func (p *BaseSocketWithCtxInterface) GetReuseAddress(ctx_ _bindings.Context) (BaseSocketGetReuseAddressResult, error) {
	var req_ _bindings.Message
	resp_ := &baseSocketWithCtxGetReuseAddressResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketGetReuseAddressOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_SOCKET` -> `SO_ERROR`.
// Returns the last error if there is an error set on the socket.
func (p *BaseSocketWithCtxInterface) GetError(ctx_ _bindings.Context) (BaseSocketGetErrorResult, error) {
	var req_ _bindings.Message
	resp_ := &baseSocketWithCtxGetErrorResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketGetErrorOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_SOCKET` -> `SO_BROADCAST`.
func (p *BaseSocketWithCtxInterface) SetBroadcast(ctx_ _bindings.Context, value bool) (BaseSocketSetBroadcastResult, error) {
	req_ := &baseSocketWithCtxSetBroadcastRequest{
		Value: value,
	}
	resp_ := &baseSocketWithCtxSetBroadcastResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketSetBroadcastOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_SOCKET` -> `SO_BROADCAST`.
func (p *BaseSocketWithCtxInterface) GetBroadcast(ctx_ _bindings.Context) (BaseSocketGetBroadcastResult, error) {
	var req_ _bindings.Message
	resp_ := &baseSocketWithCtxGetBroadcastResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketGetBroadcastOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_SOCKET` -> `SO_SNDBUF`.
func (p *BaseSocketWithCtxInterface) SetSendBuffer(ctx_ _bindings.Context, valueBytes uint64) (BaseSocketSetSendBufferResult, error) {
	req_ := &baseSocketWithCtxSetSendBufferRequest{
		ValueBytes: valueBytes,
	}
	resp_ := &baseSocketWithCtxSetSendBufferResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketSetSendBufferOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_SOCKET` -> `SO_SNDBUF`.
func (p *BaseSocketWithCtxInterface) GetSendBuffer(ctx_ _bindings.Context) (BaseSocketGetSendBufferResult, error) {
	var req_ _bindings.Message
	resp_ := &baseSocketWithCtxGetSendBufferResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketGetSendBufferOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_SOCKET` -> `SO_RCVBUF`.
func (p *BaseSocketWithCtxInterface) SetReceiveBuffer(ctx_ _bindings.Context, valueBytes uint64) (BaseSocketSetReceiveBufferResult, error) {
	req_ := &baseSocketWithCtxSetReceiveBufferRequest{
		ValueBytes: valueBytes,
	}
	resp_ := &baseSocketWithCtxSetReceiveBufferResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketSetReceiveBufferOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_SOCKET` -> `SO_RCVBUF`.
func (p *BaseSocketWithCtxInterface) GetReceiveBuffer(ctx_ _bindings.Context) (BaseSocketGetReceiveBufferResult, error) {
	var req_ _bindings.Message
	resp_ := &baseSocketWithCtxGetReceiveBufferResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketGetReceiveBufferOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_SOCKET` -> `SO_KEEPALIVE`.
func (p *BaseSocketWithCtxInterface) SetKeepAlive(ctx_ _bindings.Context, value bool) (BaseSocketSetKeepAliveResult, error) {
	req_ := &baseSocketWithCtxSetKeepAliveRequest{
		Value: value,
	}
	resp_ := &baseSocketWithCtxSetKeepAliveResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketSetKeepAliveOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_SOCKET` -> `SO_KEEPALIVE`.
func (p *BaseSocketWithCtxInterface) GetKeepAlive(ctx_ _bindings.Context) (BaseSocketGetKeepAliveResult, error) {
	var req_ _bindings.Message
	resp_ := &baseSocketWithCtxGetKeepAliveResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketGetKeepAliveOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_SOCKET` -> `SO_OOBINLINE`.
func (p *BaseSocketWithCtxInterface) SetOutOfBandInline(ctx_ _bindings.Context, value bool) (BaseSocketSetOutOfBandInlineResult, error) {
	req_ := &baseSocketWithCtxSetOutOfBandInlineRequest{
		Value: value,
	}
	resp_ := &baseSocketWithCtxSetOutOfBandInlineResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketSetOutOfBandInlineOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_SOCKET` -> `SO_OOBINLINE`.
func (p *BaseSocketWithCtxInterface) GetOutOfBandInline(ctx_ _bindings.Context) (BaseSocketGetOutOfBandInlineResult, error) {
	var req_ _bindings.Message
	resp_ := &baseSocketWithCtxGetOutOfBandInlineResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketGetOutOfBandInlineOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_SOCKET` -> `SO_NO_CHECK`.
func (p *BaseSocketWithCtxInterface) SetNoCheck(ctx_ _bindings.Context, value bool) (BaseSocketSetNoCheckResult, error) {
	req_ := &baseSocketWithCtxSetNoCheckRequest{
		Value: value,
	}
	resp_ := &baseSocketWithCtxSetNoCheckResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketSetNoCheckOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_SOCKET` -> `SO_NO_CHECK`.
func (p *BaseSocketWithCtxInterface) GetNoCheck(ctx_ _bindings.Context) (BaseSocketGetNoCheckResult, error) {
	var req_ _bindings.Message
	resp_ := &baseSocketWithCtxGetNoCheckResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketGetNoCheckOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_SOCKET` -> `SO_LINGER`.
func (p *BaseSocketWithCtxInterface) SetLinger(ctx_ _bindings.Context, linger bool, lengthSecs uint32) (BaseSocketSetLingerResult, error) {
	req_ := &baseSocketWithCtxSetLingerRequest{
		Linger:     linger,
		LengthSecs: lengthSecs,
	}
	resp_ := &baseSocketWithCtxSetLingerResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketSetLingerOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_SOCKET` -> `SO_LINGER`.
func (p *BaseSocketWithCtxInterface) GetLinger(ctx_ _bindings.Context) (BaseSocketGetLingerResult, error) {
	var req_ _bindings.Message
	resp_ := &baseSocketWithCtxGetLingerResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketGetLingerOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_SOCKET` -> `SO_REUSEPORT`.
func (p *BaseSocketWithCtxInterface) SetReusePort(ctx_ _bindings.Context, value bool) (BaseSocketSetReusePortResult, error) {
	req_ := &baseSocketWithCtxSetReusePortRequest{
		Value: value,
	}
	resp_ := &baseSocketWithCtxSetReusePortResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketSetReusePortOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_SOCKET` -> `SO_REUSEPORT`.
func (p *BaseSocketWithCtxInterface) GetReusePort(ctx_ _bindings.Context) (BaseSocketGetReusePortResult, error) {
	var req_ _bindings.Message
	resp_ := &baseSocketWithCtxGetReusePortResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketGetReusePortOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_SOCKET` -> `SO_ACCEPTCONN`.
func (p *BaseSocketWithCtxInterface) GetAcceptConn(ctx_ _bindings.Context) (BaseSocketGetAcceptConnResult, error) {
	var req_ _bindings.Message
	resp_ := &baseSocketWithCtxGetAcceptConnResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketGetAcceptConnOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_SOCKET` -> `SO_BINDTODEVICE`.
func (p *BaseSocketWithCtxInterface) SetBindToDevice(ctx_ _bindings.Context, value string) (BaseSocketSetBindToDeviceResult, error) {
	req_ := &baseSocketWithCtxSetBindToDeviceRequest{
		Value: value,
	}
	resp_ := &baseSocketWithCtxSetBindToDeviceResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketSetBindToDeviceOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_SOCKET` -> `SO_BINDTODEVICE`.
func (p *BaseSocketWithCtxInterface) GetBindToDevice(ctx_ _bindings.Context) (BaseSocketGetBindToDeviceResult, error) {
	var req_ _bindings.Message
	resp_ := &baseSocketWithCtxGetBindToDeviceResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketGetBindToDeviceOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_SOCKET` -> `SO_TIMESTAMP`.
func (p *BaseSocketWithCtxInterface) SetTimestamp(ctx_ _bindings.Context, value bool) (BaseSocketSetTimestampResult, error) {
	req_ := &baseSocketWithCtxSetTimestampRequest{
		Value: value,
	}
	resp_ := &baseSocketWithCtxSetTimestampResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketSetTimestampOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_SOCKET` -> `SO_TIMESTAMP`.
func (p *BaseSocketWithCtxInterface) GetTimestamp(ctx_ _bindings.Context) (BaseSocketGetTimestampResult, error) {
	var req_ _bindings.Message
	resp_ := &baseSocketWithCtxGetTimestampResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketGetTimestampOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_IP` -> `IP_TOS`.
func (p *BaseSocketWithCtxInterface) SetIpTypeOfService(ctx_ _bindings.Context, value uint8) (BaseSocketSetIpTypeOfServiceResult, error) {
	req_ := &baseSocketWithCtxSetIpTypeOfServiceRequest{
		Value: value,
	}
	resp_ := &baseSocketWithCtxSetIpTypeOfServiceResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketSetIpTypeOfServiceOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_IP` -> `IP_TOS`.
func (p *BaseSocketWithCtxInterface) GetIpTypeOfService(ctx_ _bindings.Context) (BaseSocketGetIpTypeOfServiceResult, error) {
	var req_ _bindings.Message
	resp_ := &baseSocketWithCtxGetIpTypeOfServiceResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketGetIpTypeOfServiceOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_IP` -> `IP_TTL`.
func (p *BaseSocketWithCtxInterface) SetIpTtl(ctx_ _bindings.Context, value OptionalUint8) (BaseSocketSetIpTtlResult, error) {
	req_ := &baseSocketWithCtxSetIpTtlRequest{
		Value: value,
	}
	resp_ := &baseSocketWithCtxSetIpTtlResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketSetIpTtlOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_IP` -> `IP_TTL`.
func (p *BaseSocketWithCtxInterface) GetIpTtl(ctx_ _bindings.Context) (BaseSocketGetIpTtlResult, error) {
	var req_ _bindings.Message
	resp_ := &baseSocketWithCtxGetIpTtlResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketGetIpTtlOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_IP` -> `IP_PKTINFO`.
func (p *BaseSocketWithCtxInterface) SetIpPacketInfo(ctx_ _bindings.Context, value bool) (BaseSocketSetIpPacketInfoResult, error) {
	req_ := &baseSocketWithCtxSetIpPacketInfoRequest{
		Value: value,
	}
	resp_ := &baseSocketWithCtxSetIpPacketInfoResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketSetIpPacketInfoOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_IP` -> `IP_PKTINFO`.
func (p *BaseSocketWithCtxInterface) GetIpPacketInfo(ctx_ _bindings.Context) (BaseSocketGetIpPacketInfoResult, error) {
	var req_ _bindings.Message
	resp_ := &baseSocketWithCtxGetIpPacketInfoResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketGetIpPacketInfoOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_IP` -> `IP_RECVTOS`.
func (p *BaseSocketWithCtxInterface) SetIpReceiveTypeOfService(ctx_ _bindings.Context, value bool) (BaseSocketSetIpReceiveTypeOfServiceResult, error) {
	req_ := &baseSocketWithCtxSetIpReceiveTypeOfServiceRequest{
		Value: value,
	}
	resp_ := &baseSocketWithCtxSetIpReceiveTypeOfServiceResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketSetIpReceiveTypeOfServiceOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_IP` -> `IP_RECVTOS`.
func (p *BaseSocketWithCtxInterface) GetIpReceiveTypeOfService(ctx_ _bindings.Context) (BaseSocketGetIpReceiveTypeOfServiceResult, error) {
	var req_ _bindings.Message
	resp_ := &baseSocketWithCtxGetIpReceiveTypeOfServiceResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketGetIpReceiveTypeOfServiceOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_IP` -> `IP_MULTICAST_IF`.
func (p *BaseSocketWithCtxInterface) SetIpMulticastInterface(ctx_ _bindings.Context, iface uint64, address fuchsianet.Ipv4Address) (BaseSocketSetIpMulticastInterfaceResult, error) {
	req_ := &baseSocketWithCtxSetIpMulticastInterfaceRequest{
		Iface:   iface,
		Address: address,
	}
	resp_ := &baseSocketWithCtxSetIpMulticastInterfaceResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketSetIpMulticastInterfaceOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_IP` -> `IP_MULTICAST_IF`.
func (p *BaseSocketWithCtxInterface) GetIpMulticastInterface(ctx_ _bindings.Context) (BaseSocketGetIpMulticastInterfaceResult, error) {
	var req_ _bindings.Message
	resp_ := &baseSocketWithCtxGetIpMulticastInterfaceResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketGetIpMulticastInterfaceOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_IP` -> `IP_MULTICAST_TTL`.
func (p *BaseSocketWithCtxInterface) SetIpMulticastTtl(ctx_ _bindings.Context, value OptionalUint8) (BaseSocketSetIpMulticastTtlResult, error) {
	req_ := &baseSocketWithCtxSetIpMulticastTtlRequest{
		Value: value,
	}
	resp_ := &baseSocketWithCtxSetIpMulticastTtlResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketSetIpMulticastTtlOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_IP` -> `IP_MULTICAST_TTL`.
func (p *BaseSocketWithCtxInterface) GetIpMulticastTtl(ctx_ _bindings.Context) (BaseSocketGetIpMulticastTtlResult, error) {
	var req_ _bindings.Message
	resp_ := &baseSocketWithCtxGetIpMulticastTtlResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketGetIpMulticastTtlOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_IP` -> `IP_MULTICAST_LOOP`.
func (p *BaseSocketWithCtxInterface) SetIpMulticastLoopback(ctx_ _bindings.Context, value bool) (BaseSocketSetIpMulticastLoopbackResult, error) {
	req_ := &baseSocketWithCtxSetIpMulticastLoopbackRequest{
		Value: value,
	}
	resp_ := &baseSocketWithCtxSetIpMulticastLoopbackResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketSetIpMulticastLoopbackOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_IP` -> `IP_MULTICAST_LOOP`.
func (p *BaseSocketWithCtxInterface) GetIpMulticastLoopback(ctx_ _bindings.Context) (BaseSocketGetIpMulticastLoopbackResult, error) {
	var req_ _bindings.Message
	resp_ := &baseSocketWithCtxGetIpMulticastLoopbackResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketGetIpMulticastLoopbackOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_IP` -> `IP_ADD_MEMBERSHIP`
func (p *BaseSocketWithCtxInterface) AddIpMembership(ctx_ _bindings.Context, membership IpMulticastMembership) (BaseSocketAddIpMembershipResult, error) {
	req_ := &baseSocketWithCtxAddIpMembershipRequest{
		Membership: membership,
	}
	resp_ := &baseSocketWithCtxAddIpMembershipResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketAddIpMembershipOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_IP` -> `IP_DROP_MEMBERSHIP`
func (p *BaseSocketWithCtxInterface) DropIpMembership(ctx_ _bindings.Context, membership IpMulticastMembership) (BaseSocketDropIpMembershipResult, error) {
	req_ := &baseSocketWithCtxDropIpMembershipRequest{
		Membership: membership,
	}
	resp_ := &baseSocketWithCtxDropIpMembershipResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketDropIpMembershipOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_IPV6` -> `IPV6_ADD_MEMBERSHIP`.
func (p *BaseSocketWithCtxInterface) AddIpv6Membership(ctx_ _bindings.Context, membership Ipv6MulticastMembership) (BaseSocketAddIpv6MembershipResult, error) {
	req_ := &baseSocketWithCtxAddIpv6MembershipRequest{
		Membership: membership,
	}
	resp_ := &baseSocketWithCtxAddIpv6MembershipResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketAddIpv6MembershipOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_IPV6` -> `IPV6_DROP_MEMBERSHIP`.
func (p *BaseSocketWithCtxInterface) DropIpv6Membership(ctx_ _bindings.Context, membership Ipv6MulticastMembership) (BaseSocketDropIpv6MembershipResult, error) {
	req_ := &baseSocketWithCtxDropIpv6MembershipRequest{
		Membership: membership,
	}
	resp_ := &baseSocketWithCtxDropIpv6MembershipResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketDropIpv6MembershipOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_IPV6` -> `IPV6_MULTICAST_IF`.
func (p *BaseSocketWithCtxInterface) SetIpv6MulticastInterface(ctx_ _bindings.Context, value uint64) (BaseSocketSetIpv6MulticastInterfaceResult, error) {
	req_ := &baseSocketWithCtxSetIpv6MulticastInterfaceRequest{
		Value: value,
	}
	resp_ := &baseSocketWithCtxSetIpv6MulticastInterfaceResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketSetIpv6MulticastInterfaceOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_IPV6` -> `IPV6_MULTICAST_IF`.
func (p *BaseSocketWithCtxInterface) GetIpv6MulticastInterface(ctx_ _bindings.Context) (BaseSocketGetIpv6MulticastInterfaceResult, error) {
	var req_ _bindings.Message
	resp_ := &baseSocketWithCtxGetIpv6MulticastInterfaceResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketGetIpv6MulticastInterfaceOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`.
func (p *BaseSocketWithCtxInterface) SetIpv6MulticastHops(ctx_ _bindings.Context, value OptionalUint8) (BaseSocketSetIpv6MulticastHopsResult, error) {
	req_ := &baseSocketWithCtxSetIpv6MulticastHopsRequest{
		Value: value,
	}
	resp_ := &baseSocketWithCtxSetIpv6MulticastHopsResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketSetIpv6MulticastHopsOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`.
func (p *BaseSocketWithCtxInterface) GetIpv6MulticastHops(ctx_ _bindings.Context) (BaseSocketGetIpv6MulticastHopsResult, error) {
	var req_ _bindings.Message
	resp_ := &baseSocketWithCtxGetIpv6MulticastHopsResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketGetIpv6MulticastHopsOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`.
func (p *BaseSocketWithCtxInterface) SetIpv6MulticastLoopback(ctx_ _bindings.Context, value bool) (BaseSocketSetIpv6MulticastLoopbackResult, error) {
	req_ := &baseSocketWithCtxSetIpv6MulticastLoopbackRequest{
		Value: value,
	}
	resp_ := &baseSocketWithCtxSetIpv6MulticastLoopbackResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketSetIpv6MulticastLoopbackOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`.
func (p *BaseSocketWithCtxInterface) GetIpv6MulticastLoopback(ctx_ _bindings.Context) (BaseSocketGetIpv6MulticastLoopbackResult, error) {
	var req_ _bindings.Message
	resp_ := &baseSocketWithCtxGetIpv6MulticastLoopbackResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketGetIpv6MulticastLoopbackOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_IPV6` -> `IPV6_V6ONLY`.
func (p *BaseSocketWithCtxInterface) SetIpv6Only(ctx_ _bindings.Context, value bool) (BaseSocketSetIpv6OnlyResult, error) {
	req_ := &baseSocketWithCtxSetIpv6OnlyRequest{
		Value: value,
	}
	resp_ := &baseSocketWithCtxSetIpv6OnlyResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketSetIpv6OnlyOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_IPV6` -> `IPV6_V6ONLY`.
func (p *BaseSocketWithCtxInterface) GetIpv6Only(ctx_ _bindings.Context) (BaseSocketGetIpv6OnlyResult, error) {
	var req_ _bindings.Message
	resp_ := &baseSocketWithCtxGetIpv6OnlyResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketGetIpv6OnlyOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_IPV6` -> `IPV6_RECVTCLASS`.
func (p *BaseSocketWithCtxInterface) SetIpv6ReceiveTrafficClass(ctx_ _bindings.Context, value bool) (BaseSocketSetIpv6ReceiveTrafficClassResult, error) {
	req_ := &baseSocketWithCtxSetIpv6ReceiveTrafficClassRequest{
		Value: value,
	}
	resp_ := &baseSocketWithCtxSetIpv6ReceiveTrafficClassResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketSetIpv6ReceiveTrafficClassOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_IPV6` -> `IPV6_RECVTCLASS`.
func (p *BaseSocketWithCtxInterface) GetIpv6ReceiveTrafficClass(ctx_ _bindings.Context) (BaseSocketGetIpv6ReceiveTrafficClassResult, error) {
	var req_ _bindings.Message
	resp_ := &baseSocketWithCtxGetIpv6ReceiveTrafficClassResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketGetIpv6ReceiveTrafficClassOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_IPV6` -> `IPV6_TCLASS`
func (p *BaseSocketWithCtxInterface) SetIpv6TrafficClass(ctx_ _bindings.Context, value OptionalUint8) (BaseSocketSetIpv6TrafficClassResult, error) {
	req_ := &baseSocketWithCtxSetIpv6TrafficClassRequest{
		Value: value,
	}
	resp_ := &baseSocketWithCtxSetIpv6TrafficClassResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketSetIpv6TrafficClassOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_IPV6` -> `IPV6_TCLASS`.
func (p *BaseSocketWithCtxInterface) GetIpv6TrafficClass(ctx_ _bindings.Context) (BaseSocketGetIpv6TrafficClassResult, error) {
	var req_ _bindings.Message
	resp_ := &baseSocketWithCtxGetIpv6TrafficClassResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketGetIpv6TrafficClassOrdinal, req_, resp_)
	return resp_.Result, err_
}

// A network socket.
//
// Once a socket has been retrieved from a `Provider`, this interface is then used to further
// configure and use the socket. This interface is essentially POSIX. Its implementation must
// support Linux-specific arguments to {Get,Set}SockOpt.
//
// 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.
type BaseSocketWithCtx interface {
	// Create another connection to the same remote object.
	//
	// `flags` may be any of:
	//
	// - `OPEN_RIGHT_*`
	// - `OPEN_FLAG_APPEND`
	// - `OPEN_FLAG_NO_REMOTE`
	// - `OPEN_FLAG_DESCRIBE`
	// - `CLONE_FLAG_SAME_RIGHTS`
	//
	// All other flags are ignored.
	//
	// The `OPEN_RIGHT_*` bits in `flags` request corresponding rights over the resulting
	// cloned object.
	// The cloned object must have rights less than or equal to the original object, otherwise
	// returns `ZX_ERR_ACCESS_DENIED`.
	// Alternatively, pass `CLONE_FLAG_SAME_RIGHTS` to inherit the rights on the source connection.
	// It is invalid to pass any of the `OPEN_RIGHT_*` flags together with
	// `CLONE_FLAG_SAME_RIGHTS`.
	Clone(ctx_ _bindings.Context, flags uint32, object fuchsiaio.NodeWithCtxInterfaceRequest) error
	// Terminates connection with object.
	//
	// This method does not require any rights.
	Close(ctx_ _bindings.Context) (int32, error)
	// Returns extra information about the type of the object.
	// If the `Describe` operation fails, the connection is closed.
	//
	// This method does not require any rights.
	Describe(ctx_ _bindings.Context) (fuchsiaio.NodeInfo, error)
	// An event produced eagerly by a FIDL server if requested by `OPEN_FLAG_DESCRIBE`.
	//
	// Indicates the success or failure of the open operation, and optionally describes the
	// object. If the status is `ZX_OK`, `info` contains descriptive information about the object
	// (the same as would be returned by `Describe`).
	// Synchronizes updates to the node to the underlying media, if it exists.
	//
	// This method does not require any rights.
	Sync(ctx_ _bindings.Context) (int32, error)
	// Acquires information about the node.
	//
	// This method does not require any rights.
	GetAttr(ctx_ _bindings.Context) (int32, fuchsiaio.NodeAttributes, error)
	// Updates information about the node.
	// `flags` may be any of `NODE_ATTRIBUTE_FLAG_*`.
	//
	// This method requires following rights: `OPEN_RIGHT_WRITABLE`, otherwise returns
	// `ZX_ERR_BAD_HANDLE`.
	SetAttr(ctx_ _bindings.Context, flags uint32, attributes fuchsiaio.NodeAttributes) (int32, error)
	// Acquires the `Directory.Open` rights and flags used to access this file.
	//
	// This method does not require any rights.
	// This method has the same functionality as GetFlags for File and is
	// meant as an in-progress replacement.
	NodeGetFlags(ctx_ _bindings.Context) (int32, uint32, error)
	// Changes the `Directory.Open` flags used to access the file.
	// Supported flags which can be turned on / off:
	// - `OPEN_FLAG_APPEND`
	//
	// This method does not require any rights.
	// This method has the same functionality as SetFlags for File and is
	// meant as an in-progress replacement.
	NodeSetFlags(ctx_ _bindings.Context, flags uint32) (int32, error)
	// Sets the local address used for the socket.
	Bind(ctx_ _bindings.Context, addr fuchsianet.SocketAddress) (BaseSocketBindResult, error)
	// Initiates a connection to a remote address.
	Connect(ctx_ _bindings.Context, addr fuchsianet.SocketAddress) (BaseSocketConnectResult, error)
	// Clears connection information from this socket.
	Disconnect(ctx_ _bindings.Context) (BaseSocketDisconnectResult, error)
	// Retrieves the local socket address.
	GetSockName(ctx_ _bindings.Context) (BaseSocketGetSockNameResult, error)
	// Retrieves the remote socket address.
	GetPeerName(ctx_ _bindings.Context) (BaseSocketGetPeerNameResult, error)
	// Shuts down part of the socket.
	Shutdown(ctx_ _bindings.Context, mode ShutdownMode) (BaseSocketShutdownResult, error)
	Shutdown2(ctx_ _bindings.Context, mode ShutdownMode) (BaseSocketShutdown2Result, error)
	// Set `SOL_SOCKET` -> `SO_REUSEADDR`.
	SetReuseAddress(ctx_ _bindings.Context, value bool) (BaseSocketSetReuseAddressResult, error)
	// Get `SOL_SOCKET` -> `SO_REUSEADDR`.
	GetReuseAddress(ctx_ _bindings.Context) (BaseSocketGetReuseAddressResult, error)
	// Get `SOL_SOCKET` -> `SO_ERROR`.
	// Returns the last error if there is an error set on the socket.
	GetError(ctx_ _bindings.Context) (BaseSocketGetErrorResult, error)
	// Set `SOL_SOCKET` -> `SO_BROADCAST`.
	SetBroadcast(ctx_ _bindings.Context, value bool) (BaseSocketSetBroadcastResult, error)
	// Get `SOL_SOCKET` -> `SO_BROADCAST`.
	GetBroadcast(ctx_ _bindings.Context) (BaseSocketGetBroadcastResult, error)
	// Set `SOL_SOCKET` -> `SO_SNDBUF`.
	SetSendBuffer(ctx_ _bindings.Context, valueBytes uint64) (BaseSocketSetSendBufferResult, error)
	// Get `SOL_SOCKET` -> `SO_SNDBUF`.
	GetSendBuffer(ctx_ _bindings.Context) (BaseSocketGetSendBufferResult, error)
	// Set `SOL_SOCKET` -> `SO_RCVBUF`.
	SetReceiveBuffer(ctx_ _bindings.Context, valueBytes uint64) (BaseSocketSetReceiveBufferResult, error)
	// Get `SOL_SOCKET` -> `SO_RCVBUF`.
	GetReceiveBuffer(ctx_ _bindings.Context) (BaseSocketGetReceiveBufferResult, error)
	// Set `SOL_SOCKET` -> `SO_KEEPALIVE`.
	SetKeepAlive(ctx_ _bindings.Context, value bool) (BaseSocketSetKeepAliveResult, error)
	// Get `SOL_SOCKET` -> `SO_KEEPALIVE`.
	GetKeepAlive(ctx_ _bindings.Context) (BaseSocketGetKeepAliveResult, error)
	// Set `SOL_SOCKET` -> `SO_OOBINLINE`.
	SetOutOfBandInline(ctx_ _bindings.Context, value bool) (BaseSocketSetOutOfBandInlineResult, error)
	// Get `SOL_SOCKET` -> `SO_OOBINLINE`.
	GetOutOfBandInline(ctx_ _bindings.Context) (BaseSocketGetOutOfBandInlineResult, error)
	// Set `SOL_SOCKET` -> `SO_NO_CHECK`.
	SetNoCheck(ctx_ _bindings.Context, value bool) (BaseSocketSetNoCheckResult, error)
	// Get `SOL_SOCKET` -> `SO_NO_CHECK`.
	GetNoCheck(ctx_ _bindings.Context) (BaseSocketGetNoCheckResult, error)
	// Set `SOL_SOCKET` -> `SO_LINGER`.
	SetLinger(ctx_ _bindings.Context, linger bool, lengthSecs uint32) (BaseSocketSetLingerResult, error)
	// Get `SOL_SOCKET` -> `SO_LINGER`.
	GetLinger(ctx_ _bindings.Context) (BaseSocketGetLingerResult, error)
	// Set `SOL_SOCKET` -> `SO_REUSEPORT`.
	SetReusePort(ctx_ _bindings.Context, value bool) (BaseSocketSetReusePortResult, error)
	// Get `SOL_SOCKET` -> `SO_REUSEPORT`.
	GetReusePort(ctx_ _bindings.Context) (BaseSocketGetReusePortResult, error)
	// Get `SOL_SOCKET` -> `SO_ACCEPTCONN`.
	GetAcceptConn(ctx_ _bindings.Context) (BaseSocketGetAcceptConnResult, error)
	// Set `SOL_SOCKET` -> `SO_BINDTODEVICE`.
	SetBindToDevice(ctx_ _bindings.Context, value string) (BaseSocketSetBindToDeviceResult, error)
	// Get `SOL_SOCKET` -> `SO_BINDTODEVICE`.
	GetBindToDevice(ctx_ _bindings.Context) (BaseSocketGetBindToDeviceResult, error)
	// Set `SOL_SOCKET` -> `SO_TIMESTAMP`.
	SetTimestamp(ctx_ _bindings.Context, value bool) (BaseSocketSetTimestampResult, error)
	// Get `SOL_SOCKET` -> `SO_TIMESTAMP`.
	GetTimestamp(ctx_ _bindings.Context) (BaseSocketGetTimestampResult, error)
	// Set `SOL_IP` -> `IP_TOS`.
	SetIpTypeOfService(ctx_ _bindings.Context, value uint8) (BaseSocketSetIpTypeOfServiceResult, error)
	// Get `SOL_IP` -> `IP_TOS`.
	GetIpTypeOfService(ctx_ _bindings.Context) (BaseSocketGetIpTypeOfServiceResult, error)
	// Set `SOL_IP` -> `IP_TTL`.
	SetIpTtl(ctx_ _bindings.Context, value OptionalUint8) (BaseSocketSetIpTtlResult, error)
	// Get `SOL_IP` -> `IP_TTL`.
	GetIpTtl(ctx_ _bindings.Context) (BaseSocketGetIpTtlResult, error)
	// Set `SOL_IP` -> `IP_PKTINFO`.
	SetIpPacketInfo(ctx_ _bindings.Context, value bool) (BaseSocketSetIpPacketInfoResult, error)
	// Get `SOL_IP` -> `IP_PKTINFO`.
	GetIpPacketInfo(ctx_ _bindings.Context) (BaseSocketGetIpPacketInfoResult, error)
	// Set `SOL_IP` -> `IP_RECVTOS`.
	SetIpReceiveTypeOfService(ctx_ _bindings.Context, value bool) (BaseSocketSetIpReceiveTypeOfServiceResult, error)
	// Get `SOL_IP` -> `IP_RECVTOS`.
	GetIpReceiveTypeOfService(ctx_ _bindings.Context) (BaseSocketGetIpReceiveTypeOfServiceResult, error)
	// Set `SOL_IP` -> `IP_MULTICAST_IF`.
	SetIpMulticastInterface(ctx_ _bindings.Context, iface uint64, address fuchsianet.Ipv4Address) (BaseSocketSetIpMulticastInterfaceResult, error)
	// Get `SOL_IP` -> `IP_MULTICAST_IF`.
	GetIpMulticastInterface(ctx_ _bindings.Context) (BaseSocketGetIpMulticastInterfaceResult, error)
	// Set `SOL_IP` -> `IP_MULTICAST_TTL`.
	SetIpMulticastTtl(ctx_ _bindings.Context, value OptionalUint8) (BaseSocketSetIpMulticastTtlResult, error)
	// Get `SOL_IP` -> `IP_MULTICAST_TTL`.
	GetIpMulticastTtl(ctx_ _bindings.Context) (BaseSocketGetIpMulticastTtlResult, error)
	// Set `SOL_IP` -> `IP_MULTICAST_LOOP`.
	SetIpMulticastLoopback(ctx_ _bindings.Context, value bool) (BaseSocketSetIpMulticastLoopbackResult, error)
	// Get `SOL_IP` -> `IP_MULTICAST_LOOP`.
	GetIpMulticastLoopback(ctx_ _bindings.Context) (BaseSocketGetIpMulticastLoopbackResult, error)
	// Set `SOL_IP` -> `IP_ADD_MEMBERSHIP`
	AddIpMembership(ctx_ _bindings.Context, membership IpMulticastMembership) (BaseSocketAddIpMembershipResult, error)
	// Set `SOL_IP` -> `IP_DROP_MEMBERSHIP`
	DropIpMembership(ctx_ _bindings.Context, membership IpMulticastMembership) (BaseSocketDropIpMembershipResult, error)
	// Set `SOL_IPV6` -> `IPV6_ADD_MEMBERSHIP`.
	AddIpv6Membership(ctx_ _bindings.Context, membership Ipv6MulticastMembership) (BaseSocketAddIpv6MembershipResult, error)
	// Set `SOL_IPV6` -> `IPV6_DROP_MEMBERSHIP`.
	DropIpv6Membership(ctx_ _bindings.Context, membership Ipv6MulticastMembership) (BaseSocketDropIpv6MembershipResult, error)
	// Set `SOL_IPV6` -> `IPV6_MULTICAST_IF`.
	SetIpv6MulticastInterface(ctx_ _bindings.Context, value uint64) (BaseSocketSetIpv6MulticastInterfaceResult, error)
	// Get `SOL_IPV6` -> `IPV6_MULTICAST_IF`.
	GetIpv6MulticastInterface(ctx_ _bindings.Context) (BaseSocketGetIpv6MulticastInterfaceResult, error)
	// Set `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`.
	SetIpv6MulticastHops(ctx_ _bindings.Context, value OptionalUint8) (BaseSocketSetIpv6MulticastHopsResult, error)
	// Get `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`.
	GetIpv6MulticastHops(ctx_ _bindings.Context) (BaseSocketGetIpv6MulticastHopsResult, error)
	// Set `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`.
	SetIpv6MulticastLoopback(ctx_ _bindings.Context, value bool) (BaseSocketSetIpv6MulticastLoopbackResult, error)
	// Get `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`.
	GetIpv6MulticastLoopback(ctx_ _bindings.Context) (BaseSocketGetIpv6MulticastLoopbackResult, error)
	// Set `SOL_IPV6` -> `IPV6_V6ONLY`.
	SetIpv6Only(ctx_ _bindings.Context, value bool) (BaseSocketSetIpv6OnlyResult, error)
	// Get `SOL_IPV6` -> `IPV6_V6ONLY`.
	GetIpv6Only(ctx_ _bindings.Context) (BaseSocketGetIpv6OnlyResult, error)
	// Set `SOL_IPV6` -> `IPV6_RECVTCLASS`.
	SetIpv6ReceiveTrafficClass(ctx_ _bindings.Context, value bool) (BaseSocketSetIpv6ReceiveTrafficClassResult, error)
	// Get `SOL_IPV6` -> `IPV6_RECVTCLASS`.
	GetIpv6ReceiveTrafficClass(ctx_ _bindings.Context) (BaseSocketGetIpv6ReceiveTrafficClassResult, error)
	// Set `SOL_IPV6` -> `IPV6_TCLASS`
	SetIpv6TrafficClass(ctx_ _bindings.Context, value OptionalUint8) (BaseSocketSetIpv6TrafficClassResult, error)
	// Get `SOL_IPV6` -> `IPV6_TCLASS`.
	GetIpv6TrafficClass(ctx_ _bindings.Context) (BaseSocketGetIpv6TrafficClassResult, error)
}

type BaseSocketWithCtxTransitionalBase struct{}

func (_ *BaseSocketWithCtxTransitionalBase) NodeGetFlags(ctx_ _bindings.Context) (int32, uint32, error) {
	panic("Not Implemented")
}
func (_ *BaseSocketWithCtxTransitionalBase) NodeSetFlags(ctx_ _bindings.Context, flags uint32) (int32, error) {
	panic("Not Implemented")
}

type BaseSocketWithCtxInterfaceRequest _bindings.InterfaceRequest

func NewBaseSocketWithCtxInterfaceRequest() (BaseSocketWithCtxInterfaceRequest, *BaseSocketWithCtxInterface, error) {
	req, cli, err := _bindings.NewInterfaceRequest()
	return BaseSocketWithCtxInterfaceRequest(req), (*BaseSocketWithCtxInterface)(cli), err
}

type BaseSocketWithCtxStub struct {
	Impl BaseSocketWithCtx
}

func (s_ *BaseSocketWithCtxStub) Dispatch(args_ _bindings.DispatchArgs) (_bindings.Message, bool, error) {
	switch args_.Ordinal {
	case BaseSocketCloneOrdinal:
		in_ := baseSocketWithCtxCloneRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		err_ := s_.Impl.Clone(args_.Ctx, in_.Flags, in_.Object)
		return nil, false, err_
	case BaseSocketCloseOrdinal:
		s, err_ := s_.Impl.Close(args_.Ctx)
		out_ := baseSocketWithCtxCloseResponse{}
		out_.S = s
		return &out_, true, err_
	case BaseSocketDescribeOrdinal:
		info, err_ := s_.Impl.Describe(args_.Ctx)
		out_ := baseSocketWithCtxDescribeResponse{}
		out_.Info = info
		return &out_, true, err_
	case BaseSocketSyncOrdinal:
		s, err_ := s_.Impl.Sync(args_.Ctx)
		out_ := baseSocketWithCtxSyncResponse{}
		out_.S = s
		return &out_, true, err_
	case BaseSocketGetAttrOrdinal:
		s, attributes, err_ := s_.Impl.GetAttr(args_.Ctx)
		out_ := baseSocketWithCtxGetAttrResponse{}
		out_.S = s
		out_.Attributes = attributes
		return &out_, true, err_
	case BaseSocketSetAttrOrdinal:
		in_ := baseSocketWithCtxSetAttrRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		s, err_ := s_.Impl.SetAttr(args_.Ctx, in_.Flags, in_.Attributes)
		out_ := baseSocketWithCtxSetAttrResponse{}
		out_.S = s
		return &out_, true, err_
	case BaseSocketNodeGetFlagsOrdinal:
		s, flags, err_ := s_.Impl.NodeGetFlags(args_.Ctx)
		out_ := baseSocketWithCtxNodeGetFlagsResponse{}
		out_.S = s
		out_.Flags = flags
		return &out_, true, err_
	case BaseSocketNodeSetFlagsOrdinal:
		in_ := baseSocketWithCtxNodeSetFlagsRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		s, err_ := s_.Impl.NodeSetFlags(args_.Ctx, in_.Flags)
		out_ := baseSocketWithCtxNodeSetFlagsResponse{}
		out_.S = s
		return &out_, true, err_
	case BaseSocketBindOrdinal:
		in_ := baseSocketWithCtxBindRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.Bind(args_.Ctx, in_.Addr)
		out_ := baseSocketWithCtxBindResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseSocketConnectOrdinal:
		in_ := baseSocketWithCtxConnectRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.Connect(args_.Ctx, in_.Addr)
		out_ := baseSocketWithCtxConnectResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseSocketDisconnectOrdinal:
		result, err_ := s_.Impl.Disconnect(args_.Ctx)
		out_ := baseSocketWithCtxDisconnectResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseSocketGetSockNameOrdinal:
		result, err_ := s_.Impl.GetSockName(args_.Ctx)
		out_ := baseSocketWithCtxGetSockNameResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseSocketGetPeerNameOrdinal:
		result, err_ := s_.Impl.GetPeerName(args_.Ctx)
		out_ := baseSocketWithCtxGetPeerNameResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseSocketShutdownOrdinal:
		in_ := baseSocketWithCtxShutdownRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.Shutdown(args_.Ctx, in_.Mode)
		out_ := baseSocketWithCtxShutdownResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseSocketShutdown2Ordinal:
		in_ := baseSocketWithCtxShutdown2Request{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.Shutdown2(args_.Ctx, in_.Mode)
		out_ := baseSocketWithCtxShutdown2Response{}
		out_.Result = result
		return &out_, true, err_
	case BaseSocketSetReuseAddressOrdinal:
		in_ := baseSocketWithCtxSetReuseAddressRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.SetReuseAddress(args_.Ctx, in_.Value)
		out_ := baseSocketWithCtxSetReuseAddressResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseSocketGetReuseAddressOrdinal:
		result, err_ := s_.Impl.GetReuseAddress(args_.Ctx)
		out_ := baseSocketWithCtxGetReuseAddressResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseSocketGetErrorOrdinal:
		result, err_ := s_.Impl.GetError(args_.Ctx)
		out_ := baseSocketWithCtxGetErrorResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseSocketSetBroadcastOrdinal:
		in_ := baseSocketWithCtxSetBroadcastRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.SetBroadcast(args_.Ctx, in_.Value)
		out_ := baseSocketWithCtxSetBroadcastResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseSocketGetBroadcastOrdinal:
		result, err_ := s_.Impl.GetBroadcast(args_.Ctx)
		out_ := baseSocketWithCtxGetBroadcastResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseSocketSetSendBufferOrdinal:
		in_ := baseSocketWithCtxSetSendBufferRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.SetSendBuffer(args_.Ctx, in_.ValueBytes)
		out_ := baseSocketWithCtxSetSendBufferResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseSocketGetSendBufferOrdinal:
		result, err_ := s_.Impl.GetSendBuffer(args_.Ctx)
		out_ := baseSocketWithCtxGetSendBufferResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseSocketSetReceiveBufferOrdinal:
		in_ := baseSocketWithCtxSetReceiveBufferRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.SetReceiveBuffer(args_.Ctx, in_.ValueBytes)
		out_ := baseSocketWithCtxSetReceiveBufferResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseSocketGetReceiveBufferOrdinal:
		result, err_ := s_.Impl.GetReceiveBuffer(args_.Ctx)
		out_ := baseSocketWithCtxGetReceiveBufferResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseSocketSetKeepAliveOrdinal:
		in_ := baseSocketWithCtxSetKeepAliveRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.SetKeepAlive(args_.Ctx, in_.Value)
		out_ := baseSocketWithCtxSetKeepAliveResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseSocketGetKeepAliveOrdinal:
		result, err_ := s_.Impl.GetKeepAlive(args_.Ctx)
		out_ := baseSocketWithCtxGetKeepAliveResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseSocketSetOutOfBandInlineOrdinal:
		in_ := baseSocketWithCtxSetOutOfBandInlineRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.SetOutOfBandInline(args_.Ctx, in_.Value)
		out_ := baseSocketWithCtxSetOutOfBandInlineResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseSocketGetOutOfBandInlineOrdinal:
		result, err_ := s_.Impl.GetOutOfBandInline(args_.Ctx)
		out_ := baseSocketWithCtxGetOutOfBandInlineResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseSocketSetNoCheckOrdinal:
		in_ := baseSocketWithCtxSetNoCheckRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.SetNoCheck(args_.Ctx, in_.Value)
		out_ := baseSocketWithCtxSetNoCheckResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseSocketGetNoCheckOrdinal:
		result, err_ := s_.Impl.GetNoCheck(args_.Ctx)
		out_ := baseSocketWithCtxGetNoCheckResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseSocketSetLingerOrdinal:
		in_ := baseSocketWithCtxSetLingerRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.SetLinger(args_.Ctx, in_.Linger, in_.LengthSecs)
		out_ := baseSocketWithCtxSetLingerResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseSocketGetLingerOrdinal:
		result, err_ := s_.Impl.GetLinger(args_.Ctx)
		out_ := baseSocketWithCtxGetLingerResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseSocketSetReusePortOrdinal:
		in_ := baseSocketWithCtxSetReusePortRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.SetReusePort(args_.Ctx, in_.Value)
		out_ := baseSocketWithCtxSetReusePortResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseSocketGetReusePortOrdinal:
		result, err_ := s_.Impl.GetReusePort(args_.Ctx)
		out_ := baseSocketWithCtxGetReusePortResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseSocketGetAcceptConnOrdinal:
		result, err_ := s_.Impl.GetAcceptConn(args_.Ctx)
		out_ := baseSocketWithCtxGetAcceptConnResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseSocketSetBindToDeviceOrdinal:
		in_ := baseSocketWithCtxSetBindToDeviceRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.SetBindToDevice(args_.Ctx, in_.Value)
		out_ := baseSocketWithCtxSetBindToDeviceResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseSocketGetBindToDeviceOrdinal:
		result, err_ := s_.Impl.GetBindToDevice(args_.Ctx)
		out_ := baseSocketWithCtxGetBindToDeviceResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseSocketSetTimestampOrdinal:
		in_ := baseSocketWithCtxSetTimestampRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.SetTimestamp(args_.Ctx, in_.Value)
		out_ := baseSocketWithCtxSetTimestampResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseSocketGetTimestampOrdinal:
		result, err_ := s_.Impl.GetTimestamp(args_.Ctx)
		out_ := baseSocketWithCtxGetTimestampResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseSocketSetIpTypeOfServiceOrdinal:
		in_ := baseSocketWithCtxSetIpTypeOfServiceRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.SetIpTypeOfService(args_.Ctx, in_.Value)
		out_ := baseSocketWithCtxSetIpTypeOfServiceResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseSocketGetIpTypeOfServiceOrdinal:
		result, err_ := s_.Impl.GetIpTypeOfService(args_.Ctx)
		out_ := baseSocketWithCtxGetIpTypeOfServiceResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseSocketSetIpTtlOrdinal:
		in_ := baseSocketWithCtxSetIpTtlRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.SetIpTtl(args_.Ctx, in_.Value)
		out_ := baseSocketWithCtxSetIpTtlResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseSocketGetIpTtlOrdinal:
		result, err_ := s_.Impl.GetIpTtl(args_.Ctx)
		out_ := baseSocketWithCtxGetIpTtlResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseSocketSetIpPacketInfoOrdinal:
		in_ := baseSocketWithCtxSetIpPacketInfoRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.SetIpPacketInfo(args_.Ctx, in_.Value)
		out_ := baseSocketWithCtxSetIpPacketInfoResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseSocketGetIpPacketInfoOrdinal:
		result, err_ := s_.Impl.GetIpPacketInfo(args_.Ctx)
		out_ := baseSocketWithCtxGetIpPacketInfoResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseSocketSetIpReceiveTypeOfServiceOrdinal:
		in_ := baseSocketWithCtxSetIpReceiveTypeOfServiceRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.SetIpReceiveTypeOfService(args_.Ctx, in_.Value)
		out_ := baseSocketWithCtxSetIpReceiveTypeOfServiceResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseSocketGetIpReceiveTypeOfServiceOrdinal:
		result, err_ := s_.Impl.GetIpReceiveTypeOfService(args_.Ctx)
		out_ := baseSocketWithCtxGetIpReceiveTypeOfServiceResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseSocketSetIpMulticastInterfaceOrdinal:
		in_ := baseSocketWithCtxSetIpMulticastInterfaceRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.SetIpMulticastInterface(args_.Ctx, in_.Iface, in_.Address)
		out_ := baseSocketWithCtxSetIpMulticastInterfaceResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseSocketGetIpMulticastInterfaceOrdinal:
		result, err_ := s_.Impl.GetIpMulticastInterface(args_.Ctx)
		out_ := baseSocketWithCtxGetIpMulticastInterfaceResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseSocketSetIpMulticastTtlOrdinal:
		in_ := baseSocketWithCtxSetIpMulticastTtlRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.SetIpMulticastTtl(args_.Ctx, in_.Value)
		out_ := baseSocketWithCtxSetIpMulticastTtlResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseSocketGetIpMulticastTtlOrdinal:
		result, err_ := s_.Impl.GetIpMulticastTtl(args_.Ctx)
		out_ := baseSocketWithCtxGetIpMulticastTtlResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseSocketSetIpMulticastLoopbackOrdinal:
		in_ := baseSocketWithCtxSetIpMulticastLoopbackRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.SetIpMulticastLoopback(args_.Ctx, in_.Value)
		out_ := baseSocketWithCtxSetIpMulticastLoopbackResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseSocketGetIpMulticastLoopbackOrdinal:
		result, err_ := s_.Impl.GetIpMulticastLoopback(args_.Ctx)
		out_ := baseSocketWithCtxGetIpMulticastLoopbackResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseSocketAddIpMembershipOrdinal:
		in_ := baseSocketWithCtxAddIpMembershipRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.AddIpMembership(args_.Ctx, in_.Membership)
		out_ := baseSocketWithCtxAddIpMembershipResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseSocketDropIpMembershipOrdinal:
		in_ := baseSocketWithCtxDropIpMembershipRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.DropIpMembership(args_.Ctx, in_.Membership)
		out_ := baseSocketWithCtxDropIpMembershipResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseSocketAddIpv6MembershipOrdinal:
		in_ := baseSocketWithCtxAddIpv6MembershipRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.AddIpv6Membership(args_.Ctx, in_.Membership)
		out_ := baseSocketWithCtxAddIpv6MembershipResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseSocketDropIpv6MembershipOrdinal:
		in_ := baseSocketWithCtxDropIpv6MembershipRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.DropIpv6Membership(args_.Ctx, in_.Membership)
		out_ := baseSocketWithCtxDropIpv6MembershipResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseSocketSetIpv6MulticastInterfaceOrdinal:
		in_ := baseSocketWithCtxSetIpv6MulticastInterfaceRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.SetIpv6MulticastInterface(args_.Ctx, in_.Value)
		out_ := baseSocketWithCtxSetIpv6MulticastInterfaceResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseSocketGetIpv6MulticastInterfaceOrdinal:
		result, err_ := s_.Impl.GetIpv6MulticastInterface(args_.Ctx)
		out_ := baseSocketWithCtxGetIpv6MulticastInterfaceResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseSocketSetIpv6MulticastHopsOrdinal:
		in_ := baseSocketWithCtxSetIpv6MulticastHopsRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.SetIpv6MulticastHops(args_.Ctx, in_.Value)
		out_ := baseSocketWithCtxSetIpv6MulticastHopsResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseSocketGetIpv6MulticastHopsOrdinal:
		result, err_ := s_.Impl.GetIpv6MulticastHops(args_.Ctx)
		out_ := baseSocketWithCtxGetIpv6MulticastHopsResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseSocketSetIpv6MulticastLoopbackOrdinal:
		in_ := baseSocketWithCtxSetIpv6MulticastLoopbackRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.SetIpv6MulticastLoopback(args_.Ctx, in_.Value)
		out_ := baseSocketWithCtxSetIpv6MulticastLoopbackResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseSocketGetIpv6MulticastLoopbackOrdinal:
		result, err_ := s_.Impl.GetIpv6MulticastLoopback(args_.Ctx)
		out_ := baseSocketWithCtxGetIpv6MulticastLoopbackResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseSocketSetIpv6OnlyOrdinal:
		in_ := baseSocketWithCtxSetIpv6OnlyRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.SetIpv6Only(args_.Ctx, in_.Value)
		out_ := baseSocketWithCtxSetIpv6OnlyResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseSocketGetIpv6OnlyOrdinal:
		result, err_ := s_.Impl.GetIpv6Only(args_.Ctx)
		out_ := baseSocketWithCtxGetIpv6OnlyResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseSocketSetIpv6ReceiveTrafficClassOrdinal:
		in_ := baseSocketWithCtxSetIpv6ReceiveTrafficClassRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.SetIpv6ReceiveTrafficClass(args_.Ctx, in_.Value)
		out_ := baseSocketWithCtxSetIpv6ReceiveTrafficClassResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseSocketGetIpv6ReceiveTrafficClassOrdinal:
		result, err_ := s_.Impl.GetIpv6ReceiveTrafficClass(args_.Ctx)
		out_ := baseSocketWithCtxGetIpv6ReceiveTrafficClassResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseSocketSetIpv6TrafficClassOrdinal:
		in_ := baseSocketWithCtxSetIpv6TrafficClassRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.SetIpv6TrafficClass(args_.Ctx, in_.Value)
		out_ := baseSocketWithCtxSetIpv6TrafficClassResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseSocketGetIpv6TrafficClassOrdinal:
		result, err_ := s_.Impl.GetIpv6TrafficClass(args_.Ctx)
		out_ := baseSocketWithCtxGetIpv6TrafficClassResponse{}
		out_.Result = result
		return &out_, true, err_
	}
	return nil, false, _bindings.ErrUnknownOrdinal
}

type BaseSocketEventProxy _bindings.ChannelProxy

func (p *BaseSocketEventProxy) OnOpen(s int32, info *fuchsiaio.NodeInfo) error {
	event_ := &baseSocketWithCtxOnOpenResponse{
		S:    s,
		Info: info,
	}
	return ((*_bindings.ChannelProxy)(p)).Send(BaseSocketOnOpenOrdinal, event_)
}

const (
	DatagramSocketCloneOrdinal                      uint64 = 0x5a61678f293ce16f
	DatagramSocketCloseOrdinal                      uint64 = 0x5309c5bd1c33dc44
	DatagramSocketDescribeOrdinal                   uint64 = 0xffcec215078dea0
	DatagramSocketOnOpenOrdinal                     uint64 = 0x7fc7bbb1dbfd1972
	DatagramSocketSyncOrdinal                       uint64 = 0x189d88326c18b519
	DatagramSocketGetAttrOrdinal                    uint64 = 0x78985e216314dafd
	DatagramSocketSetAttrOrdinal                    uint64 = 0x4186c0f40d938f46
	DatagramSocketNodeGetFlagsOrdinal               uint64 = 0x5b88fffb8eda3aa1
	DatagramSocketNodeSetFlagsOrdinal               uint64 = 0x5295b76c71fde733
	DatagramSocketBindOrdinal                       uint64 = 0xf8457e6b05e15bc
	DatagramSocketConnectOrdinal                    uint64 = 0x17abeee0b9843bb1
	DatagramSocketDisconnectOrdinal                 uint64 = 0x20eaedba2e0f70a4
	DatagramSocketGetSockNameOrdinal                uint64 = 0x41a618ef19a91f9d
	DatagramSocketGetPeerNameOrdinal                uint64 = 0x4009d08a4beb5e95
	DatagramSocketShutdownOrdinal                   uint64 = 0x382080a1d15b2111
	DatagramSocketShutdown2Ordinal                  uint64 = 0x57d3458f9754763b
	DatagramSocketSetReuseAddressOrdinal            uint64 = 0x1fd74ee8b9a4a876
	DatagramSocketGetReuseAddressOrdinal            uint64 = 0x67b7206b8d1bc0a5
	DatagramSocketGetErrorOrdinal                   uint64 = 0x5aad39b33e5f6ebb
	DatagramSocketSetBroadcastOrdinal               uint64 = 0x6023e081ce3cd947
	DatagramSocketGetBroadcastOrdinal               uint64 = 0x68796fc556f9780d
	DatagramSocketSetSendBufferOrdinal              uint64 = 0x756eac32d73a7a70
	DatagramSocketGetSendBufferOrdinal              uint64 = 0x78a52fd9c7b2410b
	DatagramSocketSetReceiveBufferOrdinal           uint64 = 0x6b0cf2f1919c7001
	DatagramSocketGetReceiveBufferOrdinal           uint64 = 0x14c1a4b64f709e5c
	DatagramSocketSetKeepAliveOrdinal               uint64 = 0x572df8f0b920d2c7
	DatagramSocketGetKeepAliveOrdinal               uint64 = 0x2dd29d3215f2c9d2
	DatagramSocketSetOutOfBandInlineOrdinal         uint64 = 0x3ecb49968bee439
	DatagramSocketGetOutOfBandInlineOrdinal         uint64 = 0x348c1ab3aeca1745
	DatagramSocketSetNoCheckOrdinal                 uint64 = 0x6bbf00c53a4c78c2
	DatagramSocketGetNoCheckOrdinal                 uint64 = 0x2cd4249286417694
	DatagramSocketSetLingerOrdinal                  uint64 = 0x45386351246e998e
	DatagramSocketGetLingerOrdinal                  uint64 = 0x48eb20fc5ccb0e45
	DatagramSocketSetReusePortOrdinal               uint64 = 0x24dd3e5cb36d9ccb
	DatagramSocketGetReusePortOrdinal               uint64 = 0x7a112c1ab54ff828
	DatagramSocketGetAcceptConnOrdinal              uint64 = 0x67ce6db6c2ec8966
	DatagramSocketSetBindToDeviceOrdinal            uint64 = 0x2118b483f28aafc4
	DatagramSocketGetBindToDeviceOrdinal            uint64 = 0x1ab1fbf0ef7906c8
	DatagramSocketSetTimestampOrdinal               uint64 = 0x285d6516c263d839
	DatagramSocketGetTimestampOrdinal               uint64 = 0x49f2fffbbcc2bd27
	DatagramSocketSetIpTypeOfServiceOrdinal         uint64 = 0x559849ba9574834a
	DatagramSocketGetIpTypeOfServiceOrdinal         uint64 = 0x2740d6bfa379deb1
	DatagramSocketSetIpTtlOrdinal                   uint64 = 0x67395f7176d7918e
	DatagramSocketGetIpTtlOrdinal                   uint64 = 0x789d5ddfe26b97ac
	DatagramSocketSetIpPacketInfoOrdinal            uint64 = 0x3e02030a2fd13c03
	DatagramSocketGetIpPacketInfoOrdinal            uint64 = 0x176f008d5a0dab15
	DatagramSocketSetIpReceiveTypeOfServiceOrdinal  uint64 = 0x17148064e563dde5
	DatagramSocketGetIpReceiveTypeOfServiceOrdinal  uint64 = 0x26cc26653b0fa460
	DatagramSocketSetIpMulticastInterfaceOrdinal    uint64 = 0x6566fdb7061bbcf8
	DatagramSocketGetIpMulticastInterfaceOrdinal    uint64 = 0x44415752b16ff024
	DatagramSocketSetIpMulticastTtlOrdinal          uint64 = 0x7d1a477776ba00d3
	DatagramSocketGetIpMulticastTtlOrdinal          uint64 = 0x17cbd4bd9246fc40
	DatagramSocketSetIpMulticastLoopbackOrdinal     uint64 = 0x2a56b32f8f02369
	DatagramSocketGetIpMulticastLoopbackOrdinal     uint64 = 0x27b16d7883c08ca8
	DatagramSocketAddIpMembershipOrdinal            uint64 = 0x39a4eda6580147a0
	DatagramSocketDropIpMembershipOrdinal           uint64 = 0x6d16e8fbaf496254
	DatagramSocketAddIpv6MembershipOrdinal          uint64 = 0x231556bfce3194c1
	DatagramSocketDropIpv6MembershipOrdinal         uint64 = 0x629c12db293444c0
	DatagramSocketSetIpv6MulticastInterfaceOrdinal  uint64 = 0x5d2a568e67b54234
	DatagramSocketGetIpv6MulticastInterfaceOrdinal  uint64 = 0x7b8f38fe354f32bc
	DatagramSocketSetIpv6MulticastHopsOrdinal       uint64 = 0x2b2167d12c8a495d
	DatagramSocketGetIpv6MulticastHopsOrdinal       uint64 = 0x51a3c8257b1a2745
	DatagramSocketSetIpv6MulticastLoopbackOrdinal   uint64 = 0x97706949c4163b7
	DatagramSocketGetIpv6MulticastLoopbackOrdinal   uint64 = 0x78d6544e48794935
	DatagramSocketSetIpv6OnlyOrdinal                uint64 = 0x1d87ce5c02d8bcb2
	DatagramSocketGetIpv6OnlyOrdinal                uint64 = 0x25d6755dbe2e9c7e
	DatagramSocketSetIpv6ReceiveTrafficClassOrdinal uint64 = 0x53b93b71c9431fe4
	DatagramSocketGetIpv6ReceiveTrafficClassOrdinal uint64 = 0x1c8433af11cd4596
	DatagramSocketSetIpv6TrafficClassOrdinal        uint64 = 0x32da0ca485fad782
	DatagramSocketGetIpv6TrafficClassOrdinal        uint64 = 0x6ca5b9166c8d3cba
	DatagramSocketRecvMsgOrdinal                    uint64 = 0x715341bb02f02b7a
	DatagramSocketSendMsgOrdinal                    uint64 = 0x359b626d62a7f17b
	DatagramSocketGetInfoOrdinal                    uint64 = 0x6e3122a6b1830c0f
)

type DatagramSocketWithCtxInterface _bindings.ChannelProxy

// Create another connection to the same remote object.
//
// `flags` may be any of:
//
// - `OPEN_RIGHT_*`
// - `OPEN_FLAG_APPEND`
// - `OPEN_FLAG_NO_REMOTE`
// - `OPEN_FLAG_DESCRIBE`
// - `CLONE_FLAG_SAME_RIGHTS`
//
// All other flags are ignored.
//
// The `OPEN_RIGHT_*` bits in `flags` request corresponding rights over the resulting
// cloned object.
// The cloned object must have rights less than or equal to the original object, otherwise
// returns `ZX_ERR_ACCESS_DENIED`.
// Alternatively, pass `CLONE_FLAG_SAME_RIGHTS` to inherit the rights on the source connection.
// It is invalid to pass any of the `OPEN_RIGHT_*` flags together with
// `CLONE_FLAG_SAME_RIGHTS`.
func (p *DatagramSocketWithCtxInterface) Clone(ctx_ _bindings.Context, flags uint32, object fuchsiaio.NodeWithCtxInterfaceRequest) error {
	req_ := &datagramSocketWithCtxCloneRequest{
		Flags:  flags,
		Object: object,
	}
	err_ := ((*_bindings.ChannelProxy)(p)).Send(DatagramSocketCloneOrdinal, req_)
	return err_
}

// Terminates connection with object.
//
// This method does not require any rights.
func (p *DatagramSocketWithCtxInterface) Close(ctx_ _bindings.Context) (int32, error) {
	var req_ _bindings.Message
	resp_ := &datagramSocketWithCtxCloseResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketCloseOrdinal, req_, resp_)
	return resp_.S, err_
}

// Returns extra information about the type of the object.
// If the `Describe` operation fails, the connection is closed.
//
// This method does not require any rights.
func (p *DatagramSocketWithCtxInterface) Describe(ctx_ _bindings.Context) (fuchsiaio.NodeInfo, error) {
	var req_ _bindings.Message
	resp_ := &datagramSocketWithCtxDescribeResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketDescribeOrdinal, req_, resp_)
	return resp_.Info, err_
}

// An event produced eagerly by a FIDL server if requested by `OPEN_FLAG_DESCRIBE`.
//
// Indicates the success or failure of the open operation, and optionally describes the
// object. If the status is `ZX_OK`, `info` contains descriptive information about the object
// (the same as would be returned by `Describe`).
func (p *DatagramSocketWithCtxInterface) ExpectOnOpen(ctx_ _bindings.Context) (int32, *fuchsiaio.NodeInfo, error) {
	resp_ := &datagramSocketWithCtxOnOpenResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Recv(DatagramSocketOnOpenOrdinal, resp_)
	return resp_.S, resp_.Info, err_
}

// Synchronizes updates to the node to the underlying media, if it exists.
//
// This method does not require any rights.
func (p *DatagramSocketWithCtxInterface) Sync(ctx_ _bindings.Context) (int32, error) {
	var req_ _bindings.Message
	resp_ := &datagramSocketWithCtxSyncResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketSyncOrdinal, req_, resp_)
	return resp_.S, err_
}

// Acquires information about the node.
//
// This method does not require any rights.
func (p *DatagramSocketWithCtxInterface) GetAttr(ctx_ _bindings.Context) (int32, fuchsiaio.NodeAttributes, error) {
	var req_ _bindings.Message
	resp_ := &datagramSocketWithCtxGetAttrResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketGetAttrOrdinal, req_, resp_)
	return resp_.S, resp_.Attributes, err_
}

// Updates information about the node.
// `flags` may be any of `NODE_ATTRIBUTE_FLAG_*`.
//
// This method requires following rights: `OPEN_RIGHT_WRITABLE`, otherwise returns
// `ZX_ERR_BAD_HANDLE`.
func (p *DatagramSocketWithCtxInterface) SetAttr(ctx_ _bindings.Context, flags uint32, attributes fuchsiaio.NodeAttributes) (int32, error) {
	req_ := &datagramSocketWithCtxSetAttrRequest{
		Flags:      flags,
		Attributes: attributes,
	}
	resp_ := &datagramSocketWithCtxSetAttrResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketSetAttrOrdinal, req_, resp_)
	return resp_.S, err_
}

// Acquires the `Directory.Open` rights and flags used to access this file.
//
// This method does not require any rights.
// This method has the same functionality as GetFlags for File and is
// meant as an in-progress replacement.
func (p *DatagramSocketWithCtxInterface) NodeGetFlags(ctx_ _bindings.Context) (int32, uint32, error) {
	var req_ _bindings.Message
	resp_ := &datagramSocketWithCtxNodeGetFlagsResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketNodeGetFlagsOrdinal, req_, resp_)
	return resp_.S, resp_.Flags, err_
}

// Changes the `Directory.Open` flags used to access the file.
// Supported flags which can be turned on / off:
// - `OPEN_FLAG_APPEND`
//
// This method does not require any rights.
// This method has the same functionality as SetFlags for File and is
// meant as an in-progress replacement.
func (p *DatagramSocketWithCtxInterface) NodeSetFlags(ctx_ _bindings.Context, flags uint32) (int32, error) {
	req_ := &datagramSocketWithCtxNodeSetFlagsRequest{
		Flags: flags,
	}
	resp_ := &datagramSocketWithCtxNodeSetFlagsResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketNodeSetFlagsOrdinal, req_, resp_)
	return resp_.S, err_
}

// Sets the local address used for the socket.
func (p *DatagramSocketWithCtxInterface) Bind(ctx_ _bindings.Context, addr fuchsianet.SocketAddress) (BaseSocketBindResult, error) {
	req_ := &datagramSocketWithCtxBindRequest{
		Addr: addr,
	}
	resp_ := &datagramSocketWithCtxBindResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketBindOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Initiates a connection to a remote address.
func (p *DatagramSocketWithCtxInterface) Connect(ctx_ _bindings.Context, addr fuchsianet.SocketAddress) (BaseSocketConnectResult, error) {
	req_ := &datagramSocketWithCtxConnectRequest{
		Addr: addr,
	}
	resp_ := &datagramSocketWithCtxConnectResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketConnectOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Clears connection information from this socket.
func (p *DatagramSocketWithCtxInterface) Disconnect(ctx_ _bindings.Context) (BaseSocketDisconnectResult, error) {
	var req_ _bindings.Message
	resp_ := &datagramSocketWithCtxDisconnectResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketDisconnectOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Retrieves the local socket address.
func (p *DatagramSocketWithCtxInterface) GetSockName(ctx_ _bindings.Context) (BaseSocketGetSockNameResult, error) {
	var req_ _bindings.Message
	resp_ := &datagramSocketWithCtxGetSockNameResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketGetSockNameOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Retrieves the remote socket address.
func (p *DatagramSocketWithCtxInterface) GetPeerName(ctx_ _bindings.Context) (BaseSocketGetPeerNameResult, error) {
	var req_ _bindings.Message
	resp_ := &datagramSocketWithCtxGetPeerNameResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketGetPeerNameOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Shuts down part of the socket.
func (p *DatagramSocketWithCtxInterface) Shutdown(ctx_ _bindings.Context, mode ShutdownMode) (BaseSocketShutdownResult, error) {
	req_ := &datagramSocketWithCtxShutdownRequest{
		Mode: mode,
	}
	resp_ := &datagramSocketWithCtxShutdownResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketShutdownOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *DatagramSocketWithCtxInterface) Shutdown2(ctx_ _bindings.Context, mode ShutdownMode) (BaseSocketShutdown2Result, error) {
	req_ := &datagramSocketWithCtxShutdown2Request{
		Mode: mode,
	}
	resp_ := &datagramSocketWithCtxShutdown2Response{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketShutdown2Ordinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_SOCKET` -> `SO_REUSEADDR`.
func (p *DatagramSocketWithCtxInterface) SetReuseAddress(ctx_ _bindings.Context, value bool) (BaseSocketSetReuseAddressResult, error) {
	req_ := &datagramSocketWithCtxSetReuseAddressRequest{
		Value: value,
	}
	resp_ := &datagramSocketWithCtxSetReuseAddressResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketSetReuseAddressOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_SOCKET` -> `SO_REUSEADDR`.
func (p *DatagramSocketWithCtxInterface) GetReuseAddress(ctx_ _bindings.Context) (BaseSocketGetReuseAddressResult, error) {
	var req_ _bindings.Message
	resp_ := &datagramSocketWithCtxGetReuseAddressResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketGetReuseAddressOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_SOCKET` -> `SO_ERROR`.
// Returns the last error if there is an error set on the socket.
func (p *DatagramSocketWithCtxInterface) GetError(ctx_ _bindings.Context) (BaseSocketGetErrorResult, error) {
	var req_ _bindings.Message
	resp_ := &datagramSocketWithCtxGetErrorResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketGetErrorOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_SOCKET` -> `SO_BROADCAST`.
func (p *DatagramSocketWithCtxInterface) SetBroadcast(ctx_ _bindings.Context, value bool) (BaseSocketSetBroadcastResult, error) {
	req_ := &datagramSocketWithCtxSetBroadcastRequest{
		Value: value,
	}
	resp_ := &datagramSocketWithCtxSetBroadcastResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketSetBroadcastOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_SOCKET` -> `SO_BROADCAST`.
func (p *DatagramSocketWithCtxInterface) GetBroadcast(ctx_ _bindings.Context) (BaseSocketGetBroadcastResult, error) {
	var req_ _bindings.Message
	resp_ := &datagramSocketWithCtxGetBroadcastResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketGetBroadcastOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_SOCKET` -> `SO_SNDBUF`.
func (p *DatagramSocketWithCtxInterface) SetSendBuffer(ctx_ _bindings.Context, valueBytes uint64) (BaseSocketSetSendBufferResult, error) {
	req_ := &datagramSocketWithCtxSetSendBufferRequest{
		ValueBytes: valueBytes,
	}
	resp_ := &datagramSocketWithCtxSetSendBufferResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketSetSendBufferOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_SOCKET` -> `SO_SNDBUF`.
func (p *DatagramSocketWithCtxInterface) GetSendBuffer(ctx_ _bindings.Context) (BaseSocketGetSendBufferResult, error) {
	var req_ _bindings.Message
	resp_ := &datagramSocketWithCtxGetSendBufferResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketGetSendBufferOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_SOCKET` -> `SO_RCVBUF`.
func (p *DatagramSocketWithCtxInterface) SetReceiveBuffer(ctx_ _bindings.Context, valueBytes uint64) (BaseSocketSetReceiveBufferResult, error) {
	req_ := &datagramSocketWithCtxSetReceiveBufferRequest{
		ValueBytes: valueBytes,
	}
	resp_ := &datagramSocketWithCtxSetReceiveBufferResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketSetReceiveBufferOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_SOCKET` -> `SO_RCVBUF`.
func (p *DatagramSocketWithCtxInterface) GetReceiveBuffer(ctx_ _bindings.Context) (BaseSocketGetReceiveBufferResult, error) {
	var req_ _bindings.Message
	resp_ := &datagramSocketWithCtxGetReceiveBufferResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketGetReceiveBufferOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_SOCKET` -> `SO_KEEPALIVE`.
func (p *DatagramSocketWithCtxInterface) SetKeepAlive(ctx_ _bindings.Context, value bool) (BaseSocketSetKeepAliveResult, error) {
	req_ := &datagramSocketWithCtxSetKeepAliveRequest{
		Value: value,
	}
	resp_ := &datagramSocketWithCtxSetKeepAliveResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketSetKeepAliveOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_SOCKET` -> `SO_KEEPALIVE`.
func (p *DatagramSocketWithCtxInterface) GetKeepAlive(ctx_ _bindings.Context) (BaseSocketGetKeepAliveResult, error) {
	var req_ _bindings.Message
	resp_ := &datagramSocketWithCtxGetKeepAliveResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketGetKeepAliveOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_SOCKET` -> `SO_OOBINLINE`.
func (p *DatagramSocketWithCtxInterface) SetOutOfBandInline(ctx_ _bindings.Context, value bool) (BaseSocketSetOutOfBandInlineResult, error) {
	req_ := &datagramSocketWithCtxSetOutOfBandInlineRequest{
		Value: value,
	}
	resp_ := &datagramSocketWithCtxSetOutOfBandInlineResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketSetOutOfBandInlineOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_SOCKET` -> `SO_OOBINLINE`.
func (p *DatagramSocketWithCtxInterface) GetOutOfBandInline(ctx_ _bindings.Context) (BaseSocketGetOutOfBandInlineResult, error) {
	var req_ _bindings.Message
	resp_ := &datagramSocketWithCtxGetOutOfBandInlineResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketGetOutOfBandInlineOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_SOCKET` -> `SO_NO_CHECK`.
func (p *DatagramSocketWithCtxInterface) SetNoCheck(ctx_ _bindings.Context, value bool) (BaseSocketSetNoCheckResult, error) {
	req_ := &datagramSocketWithCtxSetNoCheckRequest{
		Value: value,
	}
	resp_ := &datagramSocketWithCtxSetNoCheckResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketSetNoCheckOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_SOCKET` -> `SO_NO_CHECK`.
func (p *DatagramSocketWithCtxInterface) GetNoCheck(ctx_ _bindings.Context) (BaseSocketGetNoCheckResult, error) {
	var req_ _bindings.Message
	resp_ := &datagramSocketWithCtxGetNoCheckResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketGetNoCheckOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_SOCKET` -> `SO_LINGER`.
func (p *DatagramSocketWithCtxInterface) SetLinger(ctx_ _bindings.Context, linger bool, lengthSecs uint32) (BaseSocketSetLingerResult, error) {
	req_ := &datagramSocketWithCtxSetLingerRequest{
		Linger:     linger,
		LengthSecs: lengthSecs,
	}
	resp_ := &datagramSocketWithCtxSetLingerResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketSetLingerOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_SOCKET` -> `SO_LINGER`.
func (p *DatagramSocketWithCtxInterface) GetLinger(ctx_ _bindings.Context) (BaseSocketGetLingerResult, error) {
	var req_ _bindings.Message
	resp_ := &datagramSocketWithCtxGetLingerResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketGetLingerOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_SOCKET` -> `SO_REUSEPORT`.
func (p *DatagramSocketWithCtxInterface) SetReusePort(ctx_ _bindings.Context, value bool) (BaseSocketSetReusePortResult, error) {
	req_ := &datagramSocketWithCtxSetReusePortRequest{
		Value: value,
	}
	resp_ := &datagramSocketWithCtxSetReusePortResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketSetReusePortOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_SOCKET` -> `SO_REUSEPORT`.
func (p *DatagramSocketWithCtxInterface) GetReusePort(ctx_ _bindings.Context) (BaseSocketGetReusePortResult, error) {
	var req_ _bindings.Message
	resp_ := &datagramSocketWithCtxGetReusePortResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketGetReusePortOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_SOCKET` -> `SO_ACCEPTCONN`.
func (p *DatagramSocketWithCtxInterface) GetAcceptConn(ctx_ _bindings.Context) (BaseSocketGetAcceptConnResult, error) {
	var req_ _bindings.Message
	resp_ := &datagramSocketWithCtxGetAcceptConnResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketGetAcceptConnOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_SOCKET` -> `SO_BINDTODEVICE`.
func (p *DatagramSocketWithCtxInterface) SetBindToDevice(ctx_ _bindings.Context, value string) (BaseSocketSetBindToDeviceResult, error) {
	req_ := &datagramSocketWithCtxSetBindToDeviceRequest{
		Value: value,
	}
	resp_ := &datagramSocketWithCtxSetBindToDeviceResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketSetBindToDeviceOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_SOCKET` -> `SO_BINDTODEVICE`.
func (p *DatagramSocketWithCtxInterface) GetBindToDevice(ctx_ _bindings.Context) (BaseSocketGetBindToDeviceResult, error) {
	var req_ _bindings.Message
	resp_ := &datagramSocketWithCtxGetBindToDeviceResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketGetBindToDeviceOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_SOCKET` -> `SO_TIMESTAMP`.
func (p *DatagramSocketWithCtxInterface) SetTimestamp(ctx_ _bindings.Context, value bool) (BaseSocketSetTimestampResult, error) {
	req_ := &datagramSocketWithCtxSetTimestampRequest{
		Value: value,
	}
	resp_ := &datagramSocketWithCtxSetTimestampResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketSetTimestampOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_SOCKET` -> `SO_TIMESTAMP`.
func (p *DatagramSocketWithCtxInterface) GetTimestamp(ctx_ _bindings.Context) (BaseSocketGetTimestampResult, error) {
	var req_ _bindings.Message
	resp_ := &datagramSocketWithCtxGetTimestampResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketGetTimestampOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_IP` -> `IP_TOS`.
func (p *DatagramSocketWithCtxInterface) SetIpTypeOfService(ctx_ _bindings.Context, value uint8) (BaseSocketSetIpTypeOfServiceResult, error) {
	req_ := &datagramSocketWithCtxSetIpTypeOfServiceRequest{
		Value: value,
	}
	resp_ := &datagramSocketWithCtxSetIpTypeOfServiceResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketSetIpTypeOfServiceOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_IP` -> `IP_TOS`.
func (p *DatagramSocketWithCtxInterface) GetIpTypeOfService(ctx_ _bindings.Context) (BaseSocketGetIpTypeOfServiceResult, error) {
	var req_ _bindings.Message
	resp_ := &datagramSocketWithCtxGetIpTypeOfServiceResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketGetIpTypeOfServiceOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_IP` -> `IP_TTL`.
func (p *DatagramSocketWithCtxInterface) SetIpTtl(ctx_ _bindings.Context, value OptionalUint8) (BaseSocketSetIpTtlResult, error) {
	req_ := &datagramSocketWithCtxSetIpTtlRequest{
		Value: value,
	}
	resp_ := &datagramSocketWithCtxSetIpTtlResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketSetIpTtlOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_IP` -> `IP_TTL`.
func (p *DatagramSocketWithCtxInterface) GetIpTtl(ctx_ _bindings.Context) (BaseSocketGetIpTtlResult, error) {
	var req_ _bindings.Message
	resp_ := &datagramSocketWithCtxGetIpTtlResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketGetIpTtlOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_IP` -> `IP_PKTINFO`.
func (p *DatagramSocketWithCtxInterface) SetIpPacketInfo(ctx_ _bindings.Context, value bool) (BaseSocketSetIpPacketInfoResult, error) {
	req_ := &datagramSocketWithCtxSetIpPacketInfoRequest{
		Value: value,
	}
	resp_ := &datagramSocketWithCtxSetIpPacketInfoResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketSetIpPacketInfoOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_IP` -> `IP_PKTINFO`.
func (p *DatagramSocketWithCtxInterface) GetIpPacketInfo(ctx_ _bindings.Context) (BaseSocketGetIpPacketInfoResult, error) {
	var req_ _bindings.Message
	resp_ := &datagramSocketWithCtxGetIpPacketInfoResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketGetIpPacketInfoOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_IP` -> `IP_RECVTOS`.
func (p *DatagramSocketWithCtxInterface) SetIpReceiveTypeOfService(ctx_ _bindings.Context, value bool) (BaseSocketSetIpReceiveTypeOfServiceResult, error) {
	req_ := &datagramSocketWithCtxSetIpReceiveTypeOfServiceRequest{
		Value: value,
	}
	resp_ := &datagramSocketWithCtxSetIpReceiveTypeOfServiceResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketSetIpReceiveTypeOfServiceOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_IP` -> `IP_RECVTOS`.
func (p *DatagramSocketWithCtxInterface) GetIpReceiveTypeOfService(ctx_ _bindings.Context) (BaseSocketGetIpReceiveTypeOfServiceResult, error) {
	var req_ _bindings.Message
	resp_ := &datagramSocketWithCtxGetIpReceiveTypeOfServiceResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketGetIpReceiveTypeOfServiceOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_IP` -> `IP_MULTICAST_IF`.
func (p *DatagramSocketWithCtxInterface) SetIpMulticastInterface(ctx_ _bindings.Context, iface uint64, address fuchsianet.Ipv4Address) (BaseSocketSetIpMulticastInterfaceResult, error) {
	req_ := &datagramSocketWithCtxSetIpMulticastInterfaceRequest{
		Iface:   iface,
		Address: address,
	}
	resp_ := &datagramSocketWithCtxSetIpMulticastInterfaceResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketSetIpMulticastInterfaceOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_IP` -> `IP_MULTICAST_IF`.
func (p *DatagramSocketWithCtxInterface) GetIpMulticastInterface(ctx_ _bindings.Context) (BaseSocketGetIpMulticastInterfaceResult, error) {
	var req_ _bindings.Message
	resp_ := &datagramSocketWithCtxGetIpMulticastInterfaceResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketGetIpMulticastInterfaceOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_IP` -> `IP_MULTICAST_TTL`.
func (p *DatagramSocketWithCtxInterface) SetIpMulticastTtl(ctx_ _bindings.Context, value OptionalUint8) (BaseSocketSetIpMulticastTtlResult, error) {
	req_ := &datagramSocketWithCtxSetIpMulticastTtlRequest{
		Value: value,
	}
	resp_ := &datagramSocketWithCtxSetIpMulticastTtlResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketSetIpMulticastTtlOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_IP` -> `IP_MULTICAST_TTL`.
func (p *DatagramSocketWithCtxInterface) GetIpMulticastTtl(ctx_ _bindings.Context) (BaseSocketGetIpMulticastTtlResult, error) {
	var req_ _bindings.Message
	resp_ := &datagramSocketWithCtxGetIpMulticastTtlResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketGetIpMulticastTtlOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_IP` -> `IP_MULTICAST_LOOP`.
func (p *DatagramSocketWithCtxInterface) SetIpMulticastLoopback(ctx_ _bindings.Context, value bool) (BaseSocketSetIpMulticastLoopbackResult, error) {
	req_ := &datagramSocketWithCtxSetIpMulticastLoopbackRequest{
		Value: value,
	}
	resp_ := &datagramSocketWithCtxSetIpMulticastLoopbackResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketSetIpMulticastLoopbackOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_IP` -> `IP_MULTICAST_LOOP`.
func (p *DatagramSocketWithCtxInterface) GetIpMulticastLoopback(ctx_ _bindings.Context) (BaseSocketGetIpMulticastLoopbackResult, error) {
	var req_ _bindings.Message
	resp_ := &datagramSocketWithCtxGetIpMulticastLoopbackResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketGetIpMulticastLoopbackOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_IP` -> `IP_ADD_MEMBERSHIP`
func (p *DatagramSocketWithCtxInterface) AddIpMembership(ctx_ _bindings.Context, membership IpMulticastMembership) (BaseSocketAddIpMembershipResult, error) {
	req_ := &datagramSocketWithCtxAddIpMembershipRequest{
		Membership: membership,
	}
	resp_ := &datagramSocketWithCtxAddIpMembershipResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketAddIpMembershipOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_IP` -> `IP_DROP_MEMBERSHIP`
func (p *DatagramSocketWithCtxInterface) DropIpMembership(ctx_ _bindings.Context, membership IpMulticastMembership) (BaseSocketDropIpMembershipResult, error) {
	req_ := &datagramSocketWithCtxDropIpMembershipRequest{
		Membership: membership,
	}
	resp_ := &datagramSocketWithCtxDropIpMembershipResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketDropIpMembershipOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_IPV6` -> `IPV6_ADD_MEMBERSHIP`.
func (p *DatagramSocketWithCtxInterface) AddIpv6Membership(ctx_ _bindings.Context, membership Ipv6MulticastMembership) (BaseSocketAddIpv6MembershipResult, error) {
	req_ := &datagramSocketWithCtxAddIpv6MembershipRequest{
		Membership: membership,
	}
	resp_ := &datagramSocketWithCtxAddIpv6MembershipResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketAddIpv6MembershipOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_IPV6` -> `IPV6_DROP_MEMBERSHIP`.
func (p *DatagramSocketWithCtxInterface) DropIpv6Membership(ctx_ _bindings.Context, membership Ipv6MulticastMembership) (BaseSocketDropIpv6MembershipResult, error) {
	req_ := &datagramSocketWithCtxDropIpv6MembershipRequest{
		Membership: membership,
	}
	resp_ := &datagramSocketWithCtxDropIpv6MembershipResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketDropIpv6MembershipOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_IPV6` -> `IPV6_MULTICAST_IF`.
func (p *DatagramSocketWithCtxInterface) SetIpv6MulticastInterface(ctx_ _bindings.Context, value uint64) (BaseSocketSetIpv6MulticastInterfaceResult, error) {
	req_ := &datagramSocketWithCtxSetIpv6MulticastInterfaceRequest{
		Value: value,
	}
	resp_ := &datagramSocketWithCtxSetIpv6MulticastInterfaceResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketSetIpv6MulticastInterfaceOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_IPV6` -> `IPV6_MULTICAST_IF`.
func (p *DatagramSocketWithCtxInterface) GetIpv6MulticastInterface(ctx_ _bindings.Context) (BaseSocketGetIpv6MulticastInterfaceResult, error) {
	var req_ _bindings.Message
	resp_ := &datagramSocketWithCtxGetIpv6MulticastInterfaceResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketGetIpv6MulticastInterfaceOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`.
func (p *DatagramSocketWithCtxInterface) SetIpv6MulticastHops(ctx_ _bindings.Context, value OptionalUint8) (BaseSocketSetIpv6MulticastHopsResult, error) {
	req_ := &datagramSocketWithCtxSetIpv6MulticastHopsRequest{
		Value: value,
	}
	resp_ := &datagramSocketWithCtxSetIpv6MulticastHopsResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketSetIpv6MulticastHopsOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`.
func (p *DatagramSocketWithCtxInterface) GetIpv6MulticastHops(ctx_ _bindings.Context) (BaseSocketGetIpv6MulticastHopsResult, error) {
	var req_ _bindings.Message
	resp_ := &datagramSocketWithCtxGetIpv6MulticastHopsResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketGetIpv6MulticastHopsOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`.
func (p *DatagramSocketWithCtxInterface) SetIpv6MulticastLoopback(ctx_ _bindings.Context, value bool) (BaseSocketSetIpv6MulticastLoopbackResult, error) {
	req_ := &datagramSocketWithCtxSetIpv6MulticastLoopbackRequest{
		Value: value,
	}
	resp_ := &datagramSocketWithCtxSetIpv6MulticastLoopbackResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketSetIpv6MulticastLoopbackOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`.
func (p *DatagramSocketWithCtxInterface) GetIpv6MulticastLoopback(ctx_ _bindings.Context) (BaseSocketGetIpv6MulticastLoopbackResult, error) {
	var req_ _bindings.Message
	resp_ := &datagramSocketWithCtxGetIpv6MulticastLoopbackResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketGetIpv6MulticastLoopbackOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_IPV6` -> `IPV6_V6ONLY`.
func (p *DatagramSocketWithCtxInterface) SetIpv6Only(ctx_ _bindings.Context, value bool) (BaseSocketSetIpv6OnlyResult, error) {
	req_ := &datagramSocketWithCtxSetIpv6OnlyRequest{
		Value: value,
	}
	resp_ := &datagramSocketWithCtxSetIpv6OnlyResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketSetIpv6OnlyOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_IPV6` -> `IPV6_V6ONLY`.
func (p *DatagramSocketWithCtxInterface) GetIpv6Only(ctx_ _bindings.Context) (BaseSocketGetIpv6OnlyResult, error) {
	var req_ _bindings.Message
	resp_ := &datagramSocketWithCtxGetIpv6OnlyResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketGetIpv6OnlyOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_IPV6` -> `IPV6_RECVTCLASS`.
func (p *DatagramSocketWithCtxInterface) SetIpv6ReceiveTrafficClass(ctx_ _bindings.Context, value bool) (BaseSocketSetIpv6ReceiveTrafficClassResult, error) {
	req_ := &datagramSocketWithCtxSetIpv6ReceiveTrafficClassRequest{
		Value: value,
	}
	resp_ := &datagramSocketWithCtxSetIpv6ReceiveTrafficClassResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketSetIpv6ReceiveTrafficClassOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_IPV6` -> `IPV6_RECVTCLASS`.
func (p *DatagramSocketWithCtxInterface) GetIpv6ReceiveTrafficClass(ctx_ _bindings.Context) (BaseSocketGetIpv6ReceiveTrafficClassResult, error) {
	var req_ _bindings.Message
	resp_ := &datagramSocketWithCtxGetIpv6ReceiveTrafficClassResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketGetIpv6ReceiveTrafficClassOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_IPV6` -> `IPV6_TCLASS`
func (p *DatagramSocketWithCtxInterface) SetIpv6TrafficClass(ctx_ _bindings.Context, value OptionalUint8) (BaseSocketSetIpv6TrafficClassResult, error) {
	req_ := &datagramSocketWithCtxSetIpv6TrafficClassRequest{
		Value: value,
	}
	resp_ := &datagramSocketWithCtxSetIpv6TrafficClassResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketSetIpv6TrafficClassOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_IPV6` -> `IPV6_TCLASS`.
func (p *DatagramSocketWithCtxInterface) GetIpv6TrafficClass(ctx_ _bindings.Context) (BaseSocketGetIpv6TrafficClassResult, error) {
	var req_ _bindings.Message
	resp_ := &datagramSocketWithCtxGetIpv6TrafficClassResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketGetIpv6TrafficClassOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Receives a message from the socket.
func (p *DatagramSocketWithCtxInterface) RecvMsg(ctx_ _bindings.Context, wantAddr bool, dataLen uint32, wantControl bool, flags RecvMsgFlags) (DatagramSocketRecvMsgResult, error) {
	req_ := &datagramSocketWithCtxRecvMsgRequest{
		WantAddr:    wantAddr,
		DataLen:     dataLen,
		WantControl: wantControl,
		Flags:       flags,
	}
	resp_ := &datagramSocketWithCtxRecvMsgResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketRecvMsgOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Sends a message on the socket.
func (p *DatagramSocketWithCtxInterface) SendMsg(ctx_ _bindings.Context, addr *fuchsianet.SocketAddress, data []uint8, control SendControlData, flags SendMsgFlags) (DatagramSocketSendMsgResult, error) {
	req_ := &datagramSocketWithCtxSendMsgRequest{
		Addr:    addr,
		Data:    data,
		Control: control,
		Flags:   flags,
	}
	resp_ := &datagramSocketWithCtxSendMsgResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketSendMsgOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Retrieves creation information from the socket.
func (p *DatagramSocketWithCtxInterface) GetInfo(ctx_ _bindings.Context) (DatagramSocketGetInfoResult, error) {
	var req_ _bindings.Message
	resp_ := &datagramSocketWithCtxGetInfoResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketGetInfoOrdinal, req_, resp_)
	return resp_.Result, err_
}

// A datagram socket.
//
// This type's [`fuchsia.io.Node/Describe`] method returns an eventpair which is used to signal
// additional information about the state of the socket such as readiness or shutdown-ness.
//
// All methods on this type are nonblocking; their exact behaviors match their Linux counterparts.
type DatagramSocketWithCtx interface {
	// Create another connection to the same remote object.
	//
	// `flags` may be any of:
	//
	// - `OPEN_RIGHT_*`
	// - `OPEN_FLAG_APPEND`
	// - `OPEN_FLAG_NO_REMOTE`
	// - `OPEN_FLAG_DESCRIBE`
	// - `CLONE_FLAG_SAME_RIGHTS`
	//
	// All other flags are ignored.
	//
	// The `OPEN_RIGHT_*` bits in `flags` request corresponding rights over the resulting
	// cloned object.
	// The cloned object must have rights less than or equal to the original object, otherwise
	// returns `ZX_ERR_ACCESS_DENIED`.
	// Alternatively, pass `CLONE_FLAG_SAME_RIGHTS` to inherit the rights on the source connection.
	// It is invalid to pass any of the `OPEN_RIGHT_*` flags together with
	// `CLONE_FLAG_SAME_RIGHTS`.
	Clone(ctx_ _bindings.Context, flags uint32, object fuchsiaio.NodeWithCtxInterfaceRequest) error
	// Terminates connection with object.
	//
	// This method does not require any rights.
	Close(ctx_ _bindings.Context) (int32, error)
	// Returns extra information about the type of the object.
	// If the `Describe` operation fails, the connection is closed.
	//
	// This method does not require any rights.
	Describe(ctx_ _bindings.Context) (fuchsiaio.NodeInfo, error)
	// An event produced eagerly by a FIDL server if requested by `OPEN_FLAG_DESCRIBE`.
	//
	// Indicates the success or failure of the open operation, and optionally describes the
	// object. If the status is `ZX_OK`, `info` contains descriptive information about the object
	// (the same as would be returned by `Describe`).
	// Synchronizes updates to the node to the underlying media, if it exists.
	//
	// This method does not require any rights.
	Sync(ctx_ _bindings.Context) (int32, error)
	// Acquires information about the node.
	//
	// This method does not require any rights.
	GetAttr(ctx_ _bindings.Context) (int32, fuchsiaio.NodeAttributes, error)
	// Updates information about the node.
	// `flags` may be any of `NODE_ATTRIBUTE_FLAG_*`.
	//
	// This method requires following rights: `OPEN_RIGHT_WRITABLE`, otherwise returns
	// `ZX_ERR_BAD_HANDLE`.
	SetAttr(ctx_ _bindings.Context, flags uint32, attributes fuchsiaio.NodeAttributes) (int32, error)
	// Acquires the `Directory.Open` rights and flags used to access this file.
	//
	// This method does not require any rights.
	// This method has the same functionality as GetFlags for File and is
	// meant as an in-progress replacement.
	NodeGetFlags(ctx_ _bindings.Context) (int32, uint32, error)
	// Changes the `Directory.Open` flags used to access the file.
	// Supported flags which can be turned on / off:
	// - `OPEN_FLAG_APPEND`
	//
	// This method does not require any rights.
	// This method has the same functionality as SetFlags for File and is
	// meant as an in-progress replacement.
	NodeSetFlags(ctx_ _bindings.Context, flags uint32) (int32, error)
	// Sets the local address used for the socket.
	Bind(ctx_ _bindings.Context, addr fuchsianet.SocketAddress) (BaseSocketBindResult, error)
	// Initiates a connection to a remote address.
	Connect(ctx_ _bindings.Context, addr fuchsianet.SocketAddress) (BaseSocketConnectResult, error)
	// Clears connection information from this socket.
	Disconnect(ctx_ _bindings.Context) (BaseSocketDisconnectResult, error)
	// Retrieves the local socket address.
	GetSockName(ctx_ _bindings.Context) (BaseSocketGetSockNameResult, error)
	// Retrieves the remote socket address.
	GetPeerName(ctx_ _bindings.Context) (BaseSocketGetPeerNameResult, error)
	// Shuts down part of the socket.
	Shutdown(ctx_ _bindings.Context, mode ShutdownMode) (BaseSocketShutdownResult, error)
	Shutdown2(ctx_ _bindings.Context, mode ShutdownMode) (BaseSocketShutdown2Result, error)
	// Set `SOL_SOCKET` -> `SO_REUSEADDR`.
	SetReuseAddress(ctx_ _bindings.Context, value bool) (BaseSocketSetReuseAddressResult, error)
	// Get `SOL_SOCKET` -> `SO_REUSEADDR`.
	GetReuseAddress(ctx_ _bindings.Context) (BaseSocketGetReuseAddressResult, error)
	// Get `SOL_SOCKET` -> `SO_ERROR`.
	// Returns the last error if there is an error set on the socket.
	GetError(ctx_ _bindings.Context) (BaseSocketGetErrorResult, error)
	// Set `SOL_SOCKET` -> `SO_BROADCAST`.
	SetBroadcast(ctx_ _bindings.Context, value bool) (BaseSocketSetBroadcastResult, error)
	// Get `SOL_SOCKET` -> `SO_BROADCAST`.
	GetBroadcast(ctx_ _bindings.Context) (BaseSocketGetBroadcastResult, error)
	// Set `SOL_SOCKET` -> `SO_SNDBUF`.
	SetSendBuffer(ctx_ _bindings.Context, valueBytes uint64) (BaseSocketSetSendBufferResult, error)
	// Get `SOL_SOCKET` -> `SO_SNDBUF`.
	GetSendBuffer(ctx_ _bindings.Context) (BaseSocketGetSendBufferResult, error)
	// Set `SOL_SOCKET` -> `SO_RCVBUF`.
	SetReceiveBuffer(ctx_ _bindings.Context, valueBytes uint64) (BaseSocketSetReceiveBufferResult, error)
	// Get `SOL_SOCKET` -> `SO_RCVBUF`.
	GetReceiveBuffer(ctx_ _bindings.Context) (BaseSocketGetReceiveBufferResult, error)
	// Set `SOL_SOCKET` -> `SO_KEEPALIVE`.
	SetKeepAlive(ctx_ _bindings.Context, value bool) (BaseSocketSetKeepAliveResult, error)
	// Get `SOL_SOCKET` -> `SO_KEEPALIVE`.
	GetKeepAlive(ctx_ _bindings.Context) (BaseSocketGetKeepAliveResult, error)
	// Set `SOL_SOCKET` -> `SO_OOBINLINE`.
	SetOutOfBandInline(ctx_ _bindings.Context, value bool) (BaseSocketSetOutOfBandInlineResult, error)
	// Get `SOL_SOCKET` -> `SO_OOBINLINE`.
	GetOutOfBandInline(ctx_ _bindings.Context) (BaseSocketGetOutOfBandInlineResult, error)
	// Set `SOL_SOCKET` -> `SO_NO_CHECK`.
	SetNoCheck(ctx_ _bindings.Context, value bool) (BaseSocketSetNoCheckResult, error)
	// Get `SOL_SOCKET` -> `SO_NO_CHECK`.
	GetNoCheck(ctx_ _bindings.Context) (BaseSocketGetNoCheckResult, error)
	// Set `SOL_SOCKET` -> `SO_LINGER`.
	SetLinger(ctx_ _bindings.Context, linger bool, lengthSecs uint32) (BaseSocketSetLingerResult, error)
	// Get `SOL_SOCKET` -> `SO_LINGER`.
	GetLinger(ctx_ _bindings.Context) (BaseSocketGetLingerResult, error)
	// Set `SOL_SOCKET` -> `SO_REUSEPORT`.
	SetReusePort(ctx_ _bindings.Context, value bool) (BaseSocketSetReusePortResult, error)
	// Get `SOL_SOCKET` -> `SO_REUSEPORT`.
	GetReusePort(ctx_ _bindings.Context) (BaseSocketGetReusePortResult, error)
	// Get `SOL_SOCKET` -> `SO_ACCEPTCONN`.
	GetAcceptConn(ctx_ _bindings.Context) (BaseSocketGetAcceptConnResult, error)
	// Set `SOL_SOCKET` -> `SO_BINDTODEVICE`.
	SetBindToDevice(ctx_ _bindings.Context, value string) (BaseSocketSetBindToDeviceResult, error)
	// Get `SOL_SOCKET` -> `SO_BINDTODEVICE`.
	GetBindToDevice(ctx_ _bindings.Context) (BaseSocketGetBindToDeviceResult, error)
	// Set `SOL_SOCKET` -> `SO_TIMESTAMP`.
	SetTimestamp(ctx_ _bindings.Context, value bool) (BaseSocketSetTimestampResult, error)
	// Get `SOL_SOCKET` -> `SO_TIMESTAMP`.
	GetTimestamp(ctx_ _bindings.Context) (BaseSocketGetTimestampResult, error)
	// Set `SOL_IP` -> `IP_TOS`.
	SetIpTypeOfService(ctx_ _bindings.Context, value uint8) (BaseSocketSetIpTypeOfServiceResult, error)
	// Get `SOL_IP` -> `IP_TOS`.
	GetIpTypeOfService(ctx_ _bindings.Context) (BaseSocketGetIpTypeOfServiceResult, error)
	// Set `SOL_IP` -> `IP_TTL`.
	SetIpTtl(ctx_ _bindings.Context, value OptionalUint8) (BaseSocketSetIpTtlResult, error)
	// Get `SOL_IP` -> `IP_TTL`.
	GetIpTtl(ctx_ _bindings.Context) (BaseSocketGetIpTtlResult, error)
	// Set `SOL_IP` -> `IP_PKTINFO`.
	SetIpPacketInfo(ctx_ _bindings.Context, value bool) (BaseSocketSetIpPacketInfoResult, error)
	// Get `SOL_IP` -> `IP_PKTINFO`.
	GetIpPacketInfo(ctx_ _bindings.Context) (BaseSocketGetIpPacketInfoResult, error)
	// Set `SOL_IP` -> `IP_RECVTOS`.
	SetIpReceiveTypeOfService(ctx_ _bindings.Context, value bool) (BaseSocketSetIpReceiveTypeOfServiceResult, error)
	// Get `SOL_IP` -> `IP_RECVTOS`.
	GetIpReceiveTypeOfService(ctx_ _bindings.Context) (BaseSocketGetIpReceiveTypeOfServiceResult, error)
	// Set `SOL_IP` -> `IP_MULTICAST_IF`.
	SetIpMulticastInterface(ctx_ _bindings.Context, iface uint64, address fuchsianet.Ipv4Address) (BaseSocketSetIpMulticastInterfaceResult, error)
	// Get `SOL_IP` -> `IP_MULTICAST_IF`.
	GetIpMulticastInterface(ctx_ _bindings.Context) (BaseSocketGetIpMulticastInterfaceResult, error)
	// Set `SOL_IP` -> `IP_MULTICAST_TTL`.
	SetIpMulticastTtl(ctx_ _bindings.Context, value OptionalUint8) (BaseSocketSetIpMulticastTtlResult, error)
	// Get `SOL_IP` -> `IP_MULTICAST_TTL`.
	GetIpMulticastTtl(ctx_ _bindings.Context) (BaseSocketGetIpMulticastTtlResult, error)
	// Set `SOL_IP` -> `IP_MULTICAST_LOOP`.
	SetIpMulticastLoopback(ctx_ _bindings.Context, value bool) (BaseSocketSetIpMulticastLoopbackResult, error)
	// Get `SOL_IP` -> `IP_MULTICAST_LOOP`.
	GetIpMulticastLoopback(ctx_ _bindings.Context) (BaseSocketGetIpMulticastLoopbackResult, error)
	// Set `SOL_IP` -> `IP_ADD_MEMBERSHIP`
	AddIpMembership(ctx_ _bindings.Context, membership IpMulticastMembership) (BaseSocketAddIpMembershipResult, error)
	// Set `SOL_IP` -> `IP_DROP_MEMBERSHIP`
	DropIpMembership(ctx_ _bindings.Context, membership IpMulticastMembership) (BaseSocketDropIpMembershipResult, error)
	// Set `SOL_IPV6` -> `IPV6_ADD_MEMBERSHIP`.
	AddIpv6Membership(ctx_ _bindings.Context, membership Ipv6MulticastMembership) (BaseSocketAddIpv6MembershipResult, error)
	// Set `SOL_IPV6` -> `IPV6_DROP_MEMBERSHIP`.
	DropIpv6Membership(ctx_ _bindings.Context, membership Ipv6MulticastMembership) (BaseSocketDropIpv6MembershipResult, error)
	// Set `SOL_IPV6` -> `IPV6_MULTICAST_IF`.
	SetIpv6MulticastInterface(ctx_ _bindings.Context, value uint64) (BaseSocketSetIpv6MulticastInterfaceResult, error)
	// Get `SOL_IPV6` -> `IPV6_MULTICAST_IF`.
	GetIpv6MulticastInterface(ctx_ _bindings.Context) (BaseSocketGetIpv6MulticastInterfaceResult, error)
	// Set `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`.
	SetIpv6MulticastHops(ctx_ _bindings.Context, value OptionalUint8) (BaseSocketSetIpv6MulticastHopsResult, error)
	// Get `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`.
	GetIpv6MulticastHops(ctx_ _bindings.Context) (BaseSocketGetIpv6MulticastHopsResult, error)
	// Set `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`.
	SetIpv6MulticastLoopback(ctx_ _bindings.Context, value bool) (BaseSocketSetIpv6MulticastLoopbackResult, error)
	// Get `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`.
	GetIpv6MulticastLoopback(ctx_ _bindings.Context) (BaseSocketGetIpv6MulticastLoopbackResult, error)
	// Set `SOL_IPV6` -> `IPV6_V6ONLY`.
	SetIpv6Only(ctx_ _bindings.Context, value bool) (BaseSocketSetIpv6OnlyResult, error)
	// Get `SOL_IPV6` -> `IPV6_V6ONLY`.
	GetIpv6Only(ctx_ _bindings.Context) (BaseSocketGetIpv6OnlyResult, error)
	// Set `SOL_IPV6` -> `IPV6_RECVTCLASS`.
	SetIpv6ReceiveTrafficClass(ctx_ _bindings.Context, value bool) (BaseSocketSetIpv6ReceiveTrafficClassResult, error)
	// Get `SOL_IPV6` -> `IPV6_RECVTCLASS`.
	GetIpv6ReceiveTrafficClass(ctx_ _bindings.Context) (BaseSocketGetIpv6ReceiveTrafficClassResult, error)
	// Set `SOL_IPV6` -> `IPV6_TCLASS`
	SetIpv6TrafficClass(ctx_ _bindings.Context, value OptionalUint8) (BaseSocketSetIpv6TrafficClassResult, error)
	// Get `SOL_IPV6` -> `IPV6_TCLASS`.
	GetIpv6TrafficClass(ctx_ _bindings.Context) (BaseSocketGetIpv6TrafficClassResult, error)
	// Receives a message from the socket.
	RecvMsg(ctx_ _bindings.Context, wantAddr bool, dataLen uint32, wantControl bool, flags RecvMsgFlags) (DatagramSocketRecvMsgResult, error)
	// Sends a message on the socket.
	SendMsg(ctx_ _bindings.Context, addr *fuchsianet.SocketAddress, data []uint8, control SendControlData, flags SendMsgFlags) (DatagramSocketSendMsgResult, error)
	// Retrieves creation information from the socket.
	GetInfo(ctx_ _bindings.Context) (DatagramSocketGetInfoResult, error)
}

type DatagramSocketWithCtxTransitionalBase struct{}

func (_ *DatagramSocketWithCtxTransitionalBase) NodeGetFlags(ctx_ _bindings.Context) (int32, uint32, error) {
	panic("Not Implemented")
}
func (_ *DatagramSocketWithCtxTransitionalBase) NodeSetFlags(ctx_ _bindings.Context, flags uint32) (int32, error) {
	panic("Not Implemented")
}

type DatagramSocketWithCtxInterfaceRequest _bindings.InterfaceRequest

func NewDatagramSocketWithCtxInterfaceRequest() (DatagramSocketWithCtxInterfaceRequest, *DatagramSocketWithCtxInterface, error) {
	req, cli, err := _bindings.NewInterfaceRequest()
	return DatagramSocketWithCtxInterfaceRequest(req), (*DatagramSocketWithCtxInterface)(cli), err
}

type DatagramSocketWithCtxStub struct {
	Impl DatagramSocketWithCtx
}

func (s_ *DatagramSocketWithCtxStub) Dispatch(args_ _bindings.DispatchArgs) (_bindings.Message, bool, error) {
	switch args_.Ordinal {
	case DatagramSocketCloneOrdinal:
		in_ := datagramSocketWithCtxCloneRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		err_ := s_.Impl.Clone(args_.Ctx, in_.Flags, in_.Object)
		return nil, false, err_
	case DatagramSocketCloseOrdinal:
		s, err_ := s_.Impl.Close(args_.Ctx)
		out_ := datagramSocketWithCtxCloseResponse{}
		out_.S = s
		return &out_, true, err_
	case DatagramSocketDescribeOrdinal:
		info, err_ := s_.Impl.Describe(args_.Ctx)
		out_ := datagramSocketWithCtxDescribeResponse{}
		out_.Info = info
		return &out_, true, err_
	case DatagramSocketSyncOrdinal:
		s, err_ := s_.Impl.Sync(args_.Ctx)
		out_ := datagramSocketWithCtxSyncResponse{}
		out_.S = s
		return &out_, true, err_
	case DatagramSocketGetAttrOrdinal:
		s, attributes, err_ := s_.Impl.GetAttr(args_.Ctx)
		out_ := datagramSocketWithCtxGetAttrResponse{}
		out_.S = s
		out_.Attributes = attributes
		return &out_, true, err_
	case DatagramSocketSetAttrOrdinal:
		in_ := datagramSocketWithCtxSetAttrRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		s, err_ := s_.Impl.SetAttr(args_.Ctx, in_.Flags, in_.Attributes)
		out_ := datagramSocketWithCtxSetAttrResponse{}
		out_.S = s
		return &out_, true, err_
	case DatagramSocketNodeGetFlagsOrdinal:
		s, flags, err_ := s_.Impl.NodeGetFlags(args_.Ctx)
		out_ := datagramSocketWithCtxNodeGetFlagsResponse{}
		out_.S = s
		out_.Flags = flags
		return &out_, true, err_
	case DatagramSocketNodeSetFlagsOrdinal:
		in_ := datagramSocketWithCtxNodeSetFlagsRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		s, err_ := s_.Impl.NodeSetFlags(args_.Ctx, in_.Flags)
		out_ := datagramSocketWithCtxNodeSetFlagsResponse{}
		out_.S = s
		return &out_, true, err_
	case DatagramSocketBindOrdinal:
		in_ := datagramSocketWithCtxBindRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.Bind(args_.Ctx, in_.Addr)
		out_ := datagramSocketWithCtxBindResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketConnectOrdinal:
		in_ := datagramSocketWithCtxConnectRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.Connect(args_.Ctx, in_.Addr)
		out_ := datagramSocketWithCtxConnectResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketDisconnectOrdinal:
		result, err_ := s_.Impl.Disconnect(args_.Ctx)
		out_ := datagramSocketWithCtxDisconnectResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketGetSockNameOrdinal:
		result, err_ := s_.Impl.GetSockName(args_.Ctx)
		out_ := datagramSocketWithCtxGetSockNameResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketGetPeerNameOrdinal:
		result, err_ := s_.Impl.GetPeerName(args_.Ctx)
		out_ := datagramSocketWithCtxGetPeerNameResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketShutdownOrdinal:
		in_ := datagramSocketWithCtxShutdownRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.Shutdown(args_.Ctx, in_.Mode)
		out_ := datagramSocketWithCtxShutdownResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketShutdown2Ordinal:
		in_ := datagramSocketWithCtxShutdown2Request{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.Shutdown2(args_.Ctx, in_.Mode)
		out_ := datagramSocketWithCtxShutdown2Response{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketSetReuseAddressOrdinal:
		in_ := datagramSocketWithCtxSetReuseAddressRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.SetReuseAddress(args_.Ctx, in_.Value)
		out_ := datagramSocketWithCtxSetReuseAddressResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketGetReuseAddressOrdinal:
		result, err_ := s_.Impl.GetReuseAddress(args_.Ctx)
		out_ := datagramSocketWithCtxGetReuseAddressResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketGetErrorOrdinal:
		result, err_ := s_.Impl.GetError(args_.Ctx)
		out_ := datagramSocketWithCtxGetErrorResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketSetBroadcastOrdinal:
		in_ := datagramSocketWithCtxSetBroadcastRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.SetBroadcast(args_.Ctx, in_.Value)
		out_ := datagramSocketWithCtxSetBroadcastResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketGetBroadcastOrdinal:
		result, err_ := s_.Impl.GetBroadcast(args_.Ctx)
		out_ := datagramSocketWithCtxGetBroadcastResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketSetSendBufferOrdinal:
		in_ := datagramSocketWithCtxSetSendBufferRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.SetSendBuffer(args_.Ctx, in_.ValueBytes)
		out_ := datagramSocketWithCtxSetSendBufferResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketGetSendBufferOrdinal:
		result, err_ := s_.Impl.GetSendBuffer(args_.Ctx)
		out_ := datagramSocketWithCtxGetSendBufferResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketSetReceiveBufferOrdinal:
		in_ := datagramSocketWithCtxSetReceiveBufferRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.SetReceiveBuffer(args_.Ctx, in_.ValueBytes)
		out_ := datagramSocketWithCtxSetReceiveBufferResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketGetReceiveBufferOrdinal:
		result, err_ := s_.Impl.GetReceiveBuffer(args_.Ctx)
		out_ := datagramSocketWithCtxGetReceiveBufferResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketSetKeepAliveOrdinal:
		in_ := datagramSocketWithCtxSetKeepAliveRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.SetKeepAlive(args_.Ctx, in_.Value)
		out_ := datagramSocketWithCtxSetKeepAliveResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketGetKeepAliveOrdinal:
		result, err_ := s_.Impl.GetKeepAlive(args_.Ctx)
		out_ := datagramSocketWithCtxGetKeepAliveResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketSetOutOfBandInlineOrdinal:
		in_ := datagramSocketWithCtxSetOutOfBandInlineRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.SetOutOfBandInline(args_.Ctx, in_.Value)
		out_ := datagramSocketWithCtxSetOutOfBandInlineResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketGetOutOfBandInlineOrdinal:
		result, err_ := s_.Impl.GetOutOfBandInline(args_.Ctx)
		out_ := datagramSocketWithCtxGetOutOfBandInlineResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketSetNoCheckOrdinal:
		in_ := datagramSocketWithCtxSetNoCheckRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.SetNoCheck(args_.Ctx, in_.Value)
		out_ := datagramSocketWithCtxSetNoCheckResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketGetNoCheckOrdinal:
		result, err_ := s_.Impl.GetNoCheck(args_.Ctx)
		out_ := datagramSocketWithCtxGetNoCheckResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketSetLingerOrdinal:
		in_ := datagramSocketWithCtxSetLingerRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.SetLinger(args_.Ctx, in_.Linger, in_.LengthSecs)
		out_ := datagramSocketWithCtxSetLingerResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketGetLingerOrdinal:
		result, err_ := s_.Impl.GetLinger(args_.Ctx)
		out_ := datagramSocketWithCtxGetLingerResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketSetReusePortOrdinal:
		in_ := datagramSocketWithCtxSetReusePortRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.SetReusePort(args_.Ctx, in_.Value)
		out_ := datagramSocketWithCtxSetReusePortResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketGetReusePortOrdinal:
		result, err_ := s_.Impl.GetReusePort(args_.Ctx)
		out_ := datagramSocketWithCtxGetReusePortResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketGetAcceptConnOrdinal:
		result, err_ := s_.Impl.GetAcceptConn(args_.Ctx)
		out_ := datagramSocketWithCtxGetAcceptConnResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketSetBindToDeviceOrdinal:
		in_ := datagramSocketWithCtxSetBindToDeviceRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.SetBindToDevice(args_.Ctx, in_.Value)
		out_ := datagramSocketWithCtxSetBindToDeviceResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketGetBindToDeviceOrdinal:
		result, err_ := s_.Impl.GetBindToDevice(args_.Ctx)
		out_ := datagramSocketWithCtxGetBindToDeviceResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketSetTimestampOrdinal:
		in_ := datagramSocketWithCtxSetTimestampRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.SetTimestamp(args_.Ctx, in_.Value)
		out_ := datagramSocketWithCtxSetTimestampResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketGetTimestampOrdinal:
		result, err_ := s_.Impl.GetTimestamp(args_.Ctx)
		out_ := datagramSocketWithCtxGetTimestampResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketSetIpTypeOfServiceOrdinal:
		in_ := datagramSocketWithCtxSetIpTypeOfServiceRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.SetIpTypeOfService(args_.Ctx, in_.Value)
		out_ := datagramSocketWithCtxSetIpTypeOfServiceResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketGetIpTypeOfServiceOrdinal:
		result, err_ := s_.Impl.GetIpTypeOfService(args_.Ctx)
		out_ := datagramSocketWithCtxGetIpTypeOfServiceResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketSetIpTtlOrdinal:
		in_ := datagramSocketWithCtxSetIpTtlRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.SetIpTtl(args_.Ctx, in_.Value)
		out_ := datagramSocketWithCtxSetIpTtlResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketGetIpTtlOrdinal:
		result, err_ := s_.Impl.GetIpTtl(args_.Ctx)
		out_ := datagramSocketWithCtxGetIpTtlResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketSetIpPacketInfoOrdinal:
		in_ := datagramSocketWithCtxSetIpPacketInfoRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.SetIpPacketInfo(args_.Ctx, in_.Value)
		out_ := datagramSocketWithCtxSetIpPacketInfoResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketGetIpPacketInfoOrdinal:
		result, err_ := s_.Impl.GetIpPacketInfo(args_.Ctx)
		out_ := datagramSocketWithCtxGetIpPacketInfoResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketSetIpReceiveTypeOfServiceOrdinal:
		in_ := datagramSocketWithCtxSetIpReceiveTypeOfServiceRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.SetIpReceiveTypeOfService(args_.Ctx, in_.Value)
		out_ := datagramSocketWithCtxSetIpReceiveTypeOfServiceResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketGetIpReceiveTypeOfServiceOrdinal:
		result, err_ := s_.Impl.GetIpReceiveTypeOfService(args_.Ctx)
		out_ := datagramSocketWithCtxGetIpReceiveTypeOfServiceResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketSetIpMulticastInterfaceOrdinal:
		in_ := datagramSocketWithCtxSetIpMulticastInterfaceRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.SetIpMulticastInterface(args_.Ctx, in_.Iface, in_.Address)
		out_ := datagramSocketWithCtxSetIpMulticastInterfaceResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketGetIpMulticastInterfaceOrdinal:
		result, err_ := s_.Impl.GetIpMulticastInterface(args_.Ctx)
		out_ := datagramSocketWithCtxGetIpMulticastInterfaceResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketSetIpMulticastTtlOrdinal:
		in_ := datagramSocketWithCtxSetIpMulticastTtlRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.SetIpMulticastTtl(args_.Ctx, in_.Value)
		out_ := datagramSocketWithCtxSetIpMulticastTtlResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketGetIpMulticastTtlOrdinal:
		result, err_ := s_.Impl.GetIpMulticastTtl(args_.Ctx)
		out_ := datagramSocketWithCtxGetIpMulticastTtlResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketSetIpMulticastLoopbackOrdinal:
		in_ := datagramSocketWithCtxSetIpMulticastLoopbackRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.SetIpMulticastLoopback(args_.Ctx, in_.Value)
		out_ := datagramSocketWithCtxSetIpMulticastLoopbackResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketGetIpMulticastLoopbackOrdinal:
		result, err_ := s_.Impl.GetIpMulticastLoopback(args_.Ctx)
		out_ := datagramSocketWithCtxGetIpMulticastLoopbackResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketAddIpMembershipOrdinal:
		in_ := datagramSocketWithCtxAddIpMembershipRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.AddIpMembership(args_.Ctx, in_.Membership)
		out_ := datagramSocketWithCtxAddIpMembershipResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketDropIpMembershipOrdinal:
		in_ := datagramSocketWithCtxDropIpMembershipRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.DropIpMembership(args_.Ctx, in_.Membership)
		out_ := datagramSocketWithCtxDropIpMembershipResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketAddIpv6MembershipOrdinal:
		in_ := datagramSocketWithCtxAddIpv6MembershipRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.AddIpv6Membership(args_.Ctx, in_.Membership)
		out_ := datagramSocketWithCtxAddIpv6MembershipResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketDropIpv6MembershipOrdinal:
		in_ := datagramSocketWithCtxDropIpv6MembershipRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.DropIpv6Membership(args_.Ctx, in_.Membership)
		out_ := datagramSocketWithCtxDropIpv6MembershipResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketSetIpv6MulticastInterfaceOrdinal:
		in_ := datagramSocketWithCtxSetIpv6MulticastInterfaceRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.SetIpv6MulticastInterface(args_.Ctx, in_.Value)
		out_ := datagramSocketWithCtxSetIpv6MulticastInterfaceResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketGetIpv6MulticastInterfaceOrdinal:
		result, err_ := s_.Impl.GetIpv6MulticastInterface(args_.Ctx)
		out_ := datagramSocketWithCtxGetIpv6MulticastInterfaceResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketSetIpv6MulticastHopsOrdinal:
		in_ := datagramSocketWithCtxSetIpv6MulticastHopsRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.SetIpv6MulticastHops(args_.Ctx, in_.Value)
		out_ := datagramSocketWithCtxSetIpv6MulticastHopsResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketGetIpv6MulticastHopsOrdinal:
		result, err_ := s_.Impl.GetIpv6MulticastHops(args_.Ctx)
		out_ := datagramSocketWithCtxGetIpv6MulticastHopsResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketSetIpv6MulticastLoopbackOrdinal:
		in_ := datagramSocketWithCtxSetIpv6MulticastLoopbackRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.SetIpv6MulticastLoopback(args_.Ctx, in_.Value)
		out_ := datagramSocketWithCtxSetIpv6MulticastLoopbackResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketGetIpv6MulticastLoopbackOrdinal:
		result, err_ := s_.Impl.GetIpv6MulticastLoopback(args_.Ctx)
		out_ := datagramSocketWithCtxGetIpv6MulticastLoopbackResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketSetIpv6OnlyOrdinal:
		in_ := datagramSocketWithCtxSetIpv6OnlyRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.SetIpv6Only(args_.Ctx, in_.Value)
		out_ := datagramSocketWithCtxSetIpv6OnlyResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketGetIpv6OnlyOrdinal:
		result, err_ := s_.Impl.GetIpv6Only(args_.Ctx)
		out_ := datagramSocketWithCtxGetIpv6OnlyResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketSetIpv6ReceiveTrafficClassOrdinal:
		in_ := datagramSocketWithCtxSetIpv6ReceiveTrafficClassRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.SetIpv6ReceiveTrafficClass(args_.Ctx, in_.Value)
		out_ := datagramSocketWithCtxSetIpv6ReceiveTrafficClassResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketGetIpv6ReceiveTrafficClassOrdinal:
		result, err_ := s_.Impl.GetIpv6ReceiveTrafficClass(args_.Ctx)
		out_ := datagramSocketWithCtxGetIpv6ReceiveTrafficClassResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketSetIpv6TrafficClassOrdinal:
		in_ := datagramSocketWithCtxSetIpv6TrafficClassRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.SetIpv6TrafficClass(args_.Ctx, in_.Value)
		out_ := datagramSocketWithCtxSetIpv6TrafficClassResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketGetIpv6TrafficClassOrdinal:
		result, err_ := s_.Impl.GetIpv6TrafficClass(args_.Ctx)
		out_ := datagramSocketWithCtxGetIpv6TrafficClassResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketRecvMsgOrdinal:
		in_ := datagramSocketWithCtxRecvMsgRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.RecvMsg(args_.Ctx, in_.WantAddr, in_.DataLen, in_.WantControl, in_.Flags)
		out_ := datagramSocketWithCtxRecvMsgResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketSendMsgOrdinal:
		in_ := datagramSocketWithCtxSendMsgRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.SendMsg(args_.Ctx, in_.Addr, in_.Data, in_.Control, in_.Flags)
		out_ := datagramSocketWithCtxSendMsgResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketGetInfoOrdinal:
		result, err_ := s_.Impl.GetInfo(args_.Ctx)
		out_ := datagramSocketWithCtxGetInfoResponse{}
		out_.Result = result
		return &out_, true, err_
	}
	return nil, false, _bindings.ErrUnknownOrdinal
}

type DatagramSocketEventProxy _bindings.ChannelProxy

func (p *DatagramSocketEventProxy) OnOpen(s int32, info *fuchsiaio.NodeInfo) error {
	event_ := &datagramSocketWithCtxOnOpenResponse{
		S:    s,
		Info: info,
	}
	return ((*_bindings.ChannelProxy)(p)).Send(DatagramSocketOnOpenOrdinal, event_)
}

const (
	StreamSocketCloneOrdinal                      uint64 = 0x5a61678f293ce16f
	StreamSocketCloseOrdinal                      uint64 = 0x5309c5bd1c33dc44
	StreamSocketDescribeOrdinal                   uint64 = 0xffcec215078dea0
	StreamSocketOnOpenOrdinal                     uint64 = 0x7fc7bbb1dbfd1972
	StreamSocketSyncOrdinal                       uint64 = 0x189d88326c18b519
	StreamSocketGetAttrOrdinal                    uint64 = 0x78985e216314dafd
	StreamSocketSetAttrOrdinal                    uint64 = 0x4186c0f40d938f46
	StreamSocketNodeGetFlagsOrdinal               uint64 = 0x5b88fffb8eda3aa1
	StreamSocketNodeSetFlagsOrdinal               uint64 = 0x5295b76c71fde733
	StreamSocketBindOrdinal                       uint64 = 0xf8457e6b05e15bc
	StreamSocketConnectOrdinal                    uint64 = 0x17abeee0b9843bb1
	StreamSocketDisconnectOrdinal                 uint64 = 0x20eaedba2e0f70a4
	StreamSocketGetSockNameOrdinal                uint64 = 0x41a618ef19a91f9d
	StreamSocketGetPeerNameOrdinal                uint64 = 0x4009d08a4beb5e95
	StreamSocketShutdownOrdinal                   uint64 = 0x382080a1d15b2111
	StreamSocketShutdown2Ordinal                  uint64 = 0x57d3458f9754763b
	StreamSocketSetReuseAddressOrdinal            uint64 = 0x1fd74ee8b9a4a876
	StreamSocketGetReuseAddressOrdinal            uint64 = 0x67b7206b8d1bc0a5
	StreamSocketGetErrorOrdinal                   uint64 = 0x5aad39b33e5f6ebb
	StreamSocketSetBroadcastOrdinal               uint64 = 0x6023e081ce3cd947
	StreamSocketGetBroadcastOrdinal               uint64 = 0x68796fc556f9780d
	StreamSocketSetSendBufferOrdinal              uint64 = 0x756eac32d73a7a70
	StreamSocketGetSendBufferOrdinal              uint64 = 0x78a52fd9c7b2410b
	StreamSocketSetReceiveBufferOrdinal           uint64 = 0x6b0cf2f1919c7001
	StreamSocketGetReceiveBufferOrdinal           uint64 = 0x14c1a4b64f709e5c
	StreamSocketSetKeepAliveOrdinal               uint64 = 0x572df8f0b920d2c7
	StreamSocketGetKeepAliveOrdinal               uint64 = 0x2dd29d3215f2c9d2
	StreamSocketSetOutOfBandInlineOrdinal         uint64 = 0x3ecb49968bee439
	StreamSocketGetOutOfBandInlineOrdinal         uint64 = 0x348c1ab3aeca1745
	StreamSocketSetNoCheckOrdinal                 uint64 = 0x6bbf00c53a4c78c2
	StreamSocketGetNoCheckOrdinal                 uint64 = 0x2cd4249286417694
	StreamSocketSetLingerOrdinal                  uint64 = 0x45386351246e998e
	StreamSocketGetLingerOrdinal                  uint64 = 0x48eb20fc5ccb0e45
	StreamSocketSetReusePortOrdinal               uint64 = 0x24dd3e5cb36d9ccb
	StreamSocketGetReusePortOrdinal               uint64 = 0x7a112c1ab54ff828
	StreamSocketGetAcceptConnOrdinal              uint64 = 0x67ce6db6c2ec8966
	StreamSocketSetBindToDeviceOrdinal            uint64 = 0x2118b483f28aafc4
	StreamSocketGetBindToDeviceOrdinal            uint64 = 0x1ab1fbf0ef7906c8
	StreamSocketSetTimestampOrdinal               uint64 = 0x285d6516c263d839
	StreamSocketGetTimestampOrdinal               uint64 = 0x49f2fffbbcc2bd27
	StreamSocketSetIpTypeOfServiceOrdinal         uint64 = 0x559849ba9574834a
	StreamSocketGetIpTypeOfServiceOrdinal         uint64 = 0x2740d6bfa379deb1
	StreamSocketSetIpTtlOrdinal                   uint64 = 0x67395f7176d7918e
	StreamSocketGetIpTtlOrdinal                   uint64 = 0x789d5ddfe26b97ac
	StreamSocketSetIpPacketInfoOrdinal            uint64 = 0x3e02030a2fd13c03
	StreamSocketGetIpPacketInfoOrdinal            uint64 = 0x176f008d5a0dab15
	StreamSocketSetIpReceiveTypeOfServiceOrdinal  uint64 = 0x17148064e563dde5
	StreamSocketGetIpReceiveTypeOfServiceOrdinal  uint64 = 0x26cc26653b0fa460
	StreamSocketSetIpMulticastInterfaceOrdinal    uint64 = 0x6566fdb7061bbcf8
	StreamSocketGetIpMulticastInterfaceOrdinal    uint64 = 0x44415752b16ff024
	StreamSocketSetIpMulticastTtlOrdinal          uint64 = 0x7d1a477776ba00d3
	StreamSocketGetIpMulticastTtlOrdinal          uint64 = 0x17cbd4bd9246fc40
	StreamSocketSetIpMulticastLoopbackOrdinal     uint64 = 0x2a56b32f8f02369
	StreamSocketGetIpMulticastLoopbackOrdinal     uint64 = 0x27b16d7883c08ca8
	StreamSocketAddIpMembershipOrdinal            uint64 = 0x39a4eda6580147a0
	StreamSocketDropIpMembershipOrdinal           uint64 = 0x6d16e8fbaf496254
	StreamSocketAddIpv6MembershipOrdinal          uint64 = 0x231556bfce3194c1
	StreamSocketDropIpv6MembershipOrdinal         uint64 = 0x629c12db293444c0
	StreamSocketSetIpv6MulticastInterfaceOrdinal  uint64 = 0x5d2a568e67b54234
	StreamSocketGetIpv6MulticastInterfaceOrdinal  uint64 = 0x7b8f38fe354f32bc
	StreamSocketSetIpv6MulticastHopsOrdinal       uint64 = 0x2b2167d12c8a495d
	StreamSocketGetIpv6MulticastHopsOrdinal       uint64 = 0x51a3c8257b1a2745
	StreamSocketSetIpv6MulticastLoopbackOrdinal   uint64 = 0x97706949c4163b7
	StreamSocketGetIpv6MulticastLoopbackOrdinal   uint64 = 0x78d6544e48794935
	StreamSocketSetIpv6OnlyOrdinal                uint64 = 0x1d87ce5c02d8bcb2
	StreamSocketGetIpv6OnlyOrdinal                uint64 = 0x25d6755dbe2e9c7e
	StreamSocketSetIpv6ReceiveTrafficClassOrdinal uint64 = 0x53b93b71c9431fe4
	StreamSocketGetIpv6ReceiveTrafficClassOrdinal uint64 = 0x1c8433af11cd4596
	StreamSocketSetIpv6TrafficClassOrdinal        uint64 = 0x32da0ca485fad782
	StreamSocketGetIpv6TrafficClassOrdinal        uint64 = 0x6ca5b9166c8d3cba
	StreamSocketListenOrdinal                     uint64 = 0x3d0a65ced3d10108
	StreamSocketAcceptOrdinal                     uint64 = 0x5ab7ad620424c163
	StreamSocketGetInfoOrdinal                    uint64 = 0x87cfa55d19f878f
	StreamSocketSetTcpNoDelayOrdinal              uint64 = 0x5a59b778f7333ada
	StreamSocketGetTcpNoDelayOrdinal              uint64 = 0xac219a3218b0799
	StreamSocketSetTcpMaxSegmentOrdinal           uint64 = 0xb3d30c498266d18
	StreamSocketGetTcpMaxSegmentOrdinal           uint64 = 0x637404d1b4b9982c
	StreamSocketSetTcpCorkOrdinal                 uint64 = 0x62e26891541143a0
	StreamSocketGetTcpCorkOrdinal                 uint64 = 0x435bb232e0e74f32
	StreamSocketSetTcpKeepAliveIdleOrdinal        uint64 = 0x196d053d8363c42
	StreamSocketGetTcpKeepAliveIdleOrdinal        uint64 = 0x35ec58564879dac
	StreamSocketSetTcpKeepAliveIntervalOrdinal    uint64 = 0x485ffbc2da1243f2
	StreamSocketGetTcpKeepAliveIntervalOrdinal    uint64 = 0x264eaf46306b284
	StreamSocketSetTcpKeepAliveCountOrdinal       uint64 = 0x2ab2e8c111708421
	StreamSocketGetTcpKeepAliveCountOrdinal       uint64 = 0x2f176ae271fe7a09
	StreamSocketSetTcpSynCountOrdinal             uint64 = 0x4dcd6ab5573c1eb3
	StreamSocketGetTcpSynCountOrdinal             uint64 = 0x7d457cba8f5f3ee6
	StreamSocketSetTcpLingerOrdinal               uint64 = 0xd5cc1e8654d36e4
	StreamSocketGetTcpLingerOrdinal               uint64 = 0xad870d311cf30eb
	StreamSocketSetTcpDeferAcceptOrdinal          uint64 = 0x15092f181e57c404
	StreamSocketGetTcpDeferAcceptOrdinal          uint64 = 0x64589790842cb7c6
	StreamSocketSetTcpWindowClampOrdinal          uint64 = 0x4a26ce07d847f1c6
	StreamSocketGetTcpWindowClampOrdinal          uint64 = 0x2df6b636bf0a6a4e
	StreamSocketGetTcpInfoOrdinal                 uint64 = 0x1ffb123d9f03ead2
	StreamSocketSetTcpQuickAckOrdinal             uint64 = 0x6fa811be8fde7457
	StreamSocketGetTcpQuickAckOrdinal             uint64 = 0x7356a949bef2df32
	StreamSocketSetTcpCongestionOrdinal           uint64 = 0x7924c6eabde7819e
	StreamSocketGetTcpCongestionOrdinal           uint64 = 0x11e16397e1b72a47
	StreamSocketSetTcpUserTimeoutOrdinal          uint64 = 0x6b459e81c3741a60
	StreamSocketGetTcpUserTimeoutOrdinal          uint64 = 0x24bbd5858ad8c380
)

type StreamSocketWithCtxInterface _bindings.ChannelProxy

// Create another connection to the same remote object.
//
// `flags` may be any of:
//
// - `OPEN_RIGHT_*`
// - `OPEN_FLAG_APPEND`
// - `OPEN_FLAG_NO_REMOTE`
// - `OPEN_FLAG_DESCRIBE`
// - `CLONE_FLAG_SAME_RIGHTS`
//
// All other flags are ignored.
//
// The `OPEN_RIGHT_*` bits in `flags` request corresponding rights over the resulting
// cloned object.
// The cloned object must have rights less than or equal to the original object, otherwise
// returns `ZX_ERR_ACCESS_DENIED`.
// Alternatively, pass `CLONE_FLAG_SAME_RIGHTS` to inherit the rights on the source connection.
// It is invalid to pass any of the `OPEN_RIGHT_*` flags together with
// `CLONE_FLAG_SAME_RIGHTS`.
func (p *StreamSocketWithCtxInterface) Clone(ctx_ _bindings.Context, flags uint32, object fuchsiaio.NodeWithCtxInterfaceRequest) error {
	req_ := &streamSocketWithCtxCloneRequest{
		Flags:  flags,
		Object: object,
	}
	err_ := ((*_bindings.ChannelProxy)(p)).Send(StreamSocketCloneOrdinal, req_)
	return err_
}

// Terminates connection with object.
//
// This method does not require any rights.
func (p *StreamSocketWithCtxInterface) Close(ctx_ _bindings.Context) (int32, error) {
	var req_ _bindings.Message
	resp_ := &streamSocketWithCtxCloseResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketCloseOrdinal, req_, resp_)
	return resp_.S, err_
}

// Returns extra information about the type of the object.
// If the `Describe` operation fails, the connection is closed.
//
// This method does not require any rights.
func (p *StreamSocketWithCtxInterface) Describe(ctx_ _bindings.Context) (fuchsiaio.NodeInfo, error) {
	var req_ _bindings.Message
	resp_ := &streamSocketWithCtxDescribeResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketDescribeOrdinal, req_, resp_)
	return resp_.Info, err_
}

// An event produced eagerly by a FIDL server if requested by `OPEN_FLAG_DESCRIBE`.
//
// Indicates the success or failure of the open operation, and optionally describes the
// object. If the status is `ZX_OK`, `info` contains descriptive information about the object
// (the same as would be returned by `Describe`).
func (p *StreamSocketWithCtxInterface) ExpectOnOpen(ctx_ _bindings.Context) (int32, *fuchsiaio.NodeInfo, error) {
	resp_ := &streamSocketWithCtxOnOpenResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Recv(StreamSocketOnOpenOrdinal, resp_)
	return resp_.S, resp_.Info, err_
}

// Synchronizes updates to the node to the underlying media, if it exists.
//
// This method does not require any rights.
func (p *StreamSocketWithCtxInterface) Sync(ctx_ _bindings.Context) (int32, error) {
	var req_ _bindings.Message
	resp_ := &streamSocketWithCtxSyncResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketSyncOrdinal, req_, resp_)
	return resp_.S, err_
}

// Acquires information about the node.
//
// This method does not require any rights.
func (p *StreamSocketWithCtxInterface) GetAttr(ctx_ _bindings.Context) (int32, fuchsiaio.NodeAttributes, error) {
	var req_ _bindings.Message
	resp_ := &streamSocketWithCtxGetAttrResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetAttrOrdinal, req_, resp_)
	return resp_.S, resp_.Attributes, err_
}

// Updates information about the node.
// `flags` may be any of `NODE_ATTRIBUTE_FLAG_*`.
//
// This method requires following rights: `OPEN_RIGHT_WRITABLE`, otherwise returns
// `ZX_ERR_BAD_HANDLE`.
func (p *StreamSocketWithCtxInterface) SetAttr(ctx_ _bindings.Context, flags uint32, attributes fuchsiaio.NodeAttributes) (int32, error) {
	req_ := &streamSocketWithCtxSetAttrRequest{
		Flags:      flags,
		Attributes: attributes,
	}
	resp_ := &streamSocketWithCtxSetAttrResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketSetAttrOrdinal, req_, resp_)
	return resp_.S, err_
}

// Acquires the `Directory.Open` rights and flags used to access this file.
//
// This method does not require any rights.
// This method has the same functionality as GetFlags for File and is
// meant as an in-progress replacement.
func (p *StreamSocketWithCtxInterface) NodeGetFlags(ctx_ _bindings.Context) (int32, uint32, error) {
	var req_ _bindings.Message
	resp_ := &streamSocketWithCtxNodeGetFlagsResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketNodeGetFlagsOrdinal, req_, resp_)
	return resp_.S, resp_.Flags, err_
}

// Changes the `Directory.Open` flags used to access the file.
// Supported flags which can be turned on / off:
// - `OPEN_FLAG_APPEND`
//
// This method does not require any rights.
// This method has the same functionality as SetFlags for File and is
// meant as an in-progress replacement.
func (p *StreamSocketWithCtxInterface) NodeSetFlags(ctx_ _bindings.Context, flags uint32) (int32, error) {
	req_ := &streamSocketWithCtxNodeSetFlagsRequest{
		Flags: flags,
	}
	resp_ := &streamSocketWithCtxNodeSetFlagsResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketNodeSetFlagsOrdinal, req_, resp_)
	return resp_.S, err_
}

// Sets the local address used for the socket.
func (p *StreamSocketWithCtxInterface) Bind(ctx_ _bindings.Context, addr fuchsianet.SocketAddress) (BaseSocketBindResult, error) {
	req_ := &streamSocketWithCtxBindRequest{
		Addr: addr,
	}
	resp_ := &streamSocketWithCtxBindResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketBindOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Initiates a connection to a remote address.
func (p *StreamSocketWithCtxInterface) Connect(ctx_ _bindings.Context, addr fuchsianet.SocketAddress) (BaseSocketConnectResult, error) {
	req_ := &streamSocketWithCtxConnectRequest{
		Addr: addr,
	}
	resp_ := &streamSocketWithCtxConnectResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketConnectOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Clears connection information from this socket.
func (p *StreamSocketWithCtxInterface) Disconnect(ctx_ _bindings.Context) (BaseSocketDisconnectResult, error) {
	var req_ _bindings.Message
	resp_ := &streamSocketWithCtxDisconnectResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketDisconnectOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Retrieves the local socket address.
func (p *StreamSocketWithCtxInterface) GetSockName(ctx_ _bindings.Context) (BaseSocketGetSockNameResult, error) {
	var req_ _bindings.Message
	resp_ := &streamSocketWithCtxGetSockNameResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetSockNameOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Retrieves the remote socket address.
func (p *StreamSocketWithCtxInterface) GetPeerName(ctx_ _bindings.Context) (BaseSocketGetPeerNameResult, error) {
	var req_ _bindings.Message
	resp_ := &streamSocketWithCtxGetPeerNameResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetPeerNameOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Shuts down part of the socket.
func (p *StreamSocketWithCtxInterface) Shutdown(ctx_ _bindings.Context, mode ShutdownMode) (BaseSocketShutdownResult, error) {
	req_ := &streamSocketWithCtxShutdownRequest{
		Mode: mode,
	}
	resp_ := &streamSocketWithCtxShutdownResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketShutdownOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *StreamSocketWithCtxInterface) Shutdown2(ctx_ _bindings.Context, mode ShutdownMode) (BaseSocketShutdown2Result, error) {
	req_ := &streamSocketWithCtxShutdown2Request{
		Mode: mode,
	}
	resp_ := &streamSocketWithCtxShutdown2Response{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketShutdown2Ordinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_SOCKET` -> `SO_REUSEADDR`.
func (p *StreamSocketWithCtxInterface) SetReuseAddress(ctx_ _bindings.Context, value bool) (BaseSocketSetReuseAddressResult, error) {
	req_ := &streamSocketWithCtxSetReuseAddressRequest{
		Value: value,
	}
	resp_ := &streamSocketWithCtxSetReuseAddressResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketSetReuseAddressOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_SOCKET` -> `SO_REUSEADDR`.
func (p *StreamSocketWithCtxInterface) GetReuseAddress(ctx_ _bindings.Context) (BaseSocketGetReuseAddressResult, error) {
	var req_ _bindings.Message
	resp_ := &streamSocketWithCtxGetReuseAddressResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetReuseAddressOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_SOCKET` -> `SO_ERROR`.
// Returns the last error if there is an error set on the socket.
func (p *StreamSocketWithCtxInterface) GetError(ctx_ _bindings.Context) (BaseSocketGetErrorResult, error) {
	var req_ _bindings.Message
	resp_ := &streamSocketWithCtxGetErrorResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetErrorOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_SOCKET` -> `SO_BROADCAST`.
func (p *StreamSocketWithCtxInterface) SetBroadcast(ctx_ _bindings.Context, value bool) (BaseSocketSetBroadcastResult, error) {
	req_ := &streamSocketWithCtxSetBroadcastRequest{
		Value: value,
	}
	resp_ := &streamSocketWithCtxSetBroadcastResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketSetBroadcastOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_SOCKET` -> `SO_BROADCAST`.
func (p *StreamSocketWithCtxInterface) GetBroadcast(ctx_ _bindings.Context) (BaseSocketGetBroadcastResult, error) {
	var req_ _bindings.Message
	resp_ := &streamSocketWithCtxGetBroadcastResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetBroadcastOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_SOCKET` -> `SO_SNDBUF`.
func (p *StreamSocketWithCtxInterface) SetSendBuffer(ctx_ _bindings.Context, valueBytes uint64) (BaseSocketSetSendBufferResult, error) {
	req_ := &streamSocketWithCtxSetSendBufferRequest{
		ValueBytes: valueBytes,
	}
	resp_ := &streamSocketWithCtxSetSendBufferResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketSetSendBufferOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_SOCKET` -> `SO_SNDBUF`.
func (p *StreamSocketWithCtxInterface) GetSendBuffer(ctx_ _bindings.Context) (BaseSocketGetSendBufferResult, error) {
	var req_ _bindings.Message
	resp_ := &streamSocketWithCtxGetSendBufferResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetSendBufferOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_SOCKET` -> `SO_RCVBUF`.
func (p *StreamSocketWithCtxInterface) SetReceiveBuffer(ctx_ _bindings.Context, valueBytes uint64) (BaseSocketSetReceiveBufferResult, error) {
	req_ := &streamSocketWithCtxSetReceiveBufferRequest{
		ValueBytes: valueBytes,
	}
	resp_ := &streamSocketWithCtxSetReceiveBufferResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketSetReceiveBufferOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_SOCKET` -> `SO_RCVBUF`.
func (p *StreamSocketWithCtxInterface) GetReceiveBuffer(ctx_ _bindings.Context) (BaseSocketGetReceiveBufferResult, error) {
	var req_ _bindings.Message
	resp_ := &streamSocketWithCtxGetReceiveBufferResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetReceiveBufferOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_SOCKET` -> `SO_KEEPALIVE`.
func (p *StreamSocketWithCtxInterface) SetKeepAlive(ctx_ _bindings.Context, value bool) (BaseSocketSetKeepAliveResult, error) {
	req_ := &streamSocketWithCtxSetKeepAliveRequest{
		Value: value,
	}
	resp_ := &streamSocketWithCtxSetKeepAliveResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketSetKeepAliveOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_SOCKET` -> `SO_KEEPALIVE`.
func (p *StreamSocketWithCtxInterface) GetKeepAlive(ctx_ _bindings.Context) (BaseSocketGetKeepAliveResult, error) {
	var req_ _bindings.Message
	resp_ := &streamSocketWithCtxGetKeepAliveResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetKeepAliveOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_SOCKET` -> `SO_OOBINLINE`.
func (p *StreamSocketWithCtxInterface) SetOutOfBandInline(ctx_ _bindings.Context, value bool) (BaseSocketSetOutOfBandInlineResult, error) {
	req_ := &streamSocketWithCtxSetOutOfBandInlineRequest{
		Value: value,
	}
	resp_ := &streamSocketWithCtxSetOutOfBandInlineResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketSetOutOfBandInlineOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_SOCKET` -> `SO_OOBINLINE`.
func (p *StreamSocketWithCtxInterface) GetOutOfBandInline(ctx_ _bindings.Context) (BaseSocketGetOutOfBandInlineResult, error) {
	var req_ _bindings.Message
	resp_ := &streamSocketWithCtxGetOutOfBandInlineResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetOutOfBandInlineOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_SOCKET` -> `SO_NO_CHECK`.
func (p *StreamSocketWithCtxInterface) SetNoCheck(ctx_ _bindings.Context, value bool) (BaseSocketSetNoCheckResult, error) {
	req_ := &streamSocketWithCtxSetNoCheckRequest{
		Value: value,
	}
	resp_ := &streamSocketWithCtxSetNoCheckResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketSetNoCheckOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_SOCKET` -> `SO_NO_CHECK`.
func (p *StreamSocketWithCtxInterface) GetNoCheck(ctx_ _bindings.Context) (BaseSocketGetNoCheckResult, error) {
	var req_ _bindings.Message
	resp_ := &streamSocketWithCtxGetNoCheckResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetNoCheckOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_SOCKET` -> `SO_LINGER`.
func (p *StreamSocketWithCtxInterface) SetLinger(ctx_ _bindings.Context, linger bool, lengthSecs uint32) (BaseSocketSetLingerResult, error) {
	req_ := &streamSocketWithCtxSetLingerRequest{
		Linger:     linger,
		LengthSecs: lengthSecs,
	}
	resp_ := &streamSocketWithCtxSetLingerResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketSetLingerOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_SOCKET` -> `SO_LINGER`.
func (p *StreamSocketWithCtxInterface) GetLinger(ctx_ _bindings.Context) (BaseSocketGetLingerResult, error) {
	var req_ _bindings.Message
	resp_ := &streamSocketWithCtxGetLingerResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetLingerOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_SOCKET` -> `SO_REUSEPORT`.
func (p *StreamSocketWithCtxInterface) SetReusePort(ctx_ _bindings.Context, value bool) (BaseSocketSetReusePortResult, error) {
	req_ := &streamSocketWithCtxSetReusePortRequest{
		Value: value,
	}
	resp_ := &streamSocketWithCtxSetReusePortResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketSetReusePortOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_SOCKET` -> `SO_REUSEPORT`.
func (p *StreamSocketWithCtxInterface) GetReusePort(ctx_ _bindings.Context) (BaseSocketGetReusePortResult, error) {
	var req_ _bindings.Message
	resp_ := &streamSocketWithCtxGetReusePortResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetReusePortOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_SOCKET` -> `SO_ACCEPTCONN`.
func (p *StreamSocketWithCtxInterface) GetAcceptConn(ctx_ _bindings.Context) (BaseSocketGetAcceptConnResult, error) {
	var req_ _bindings.Message
	resp_ := &streamSocketWithCtxGetAcceptConnResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetAcceptConnOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_SOCKET` -> `SO_BINDTODEVICE`.
func (p *StreamSocketWithCtxInterface) SetBindToDevice(ctx_ _bindings.Context, value string) (BaseSocketSetBindToDeviceResult, error) {
	req_ := &streamSocketWithCtxSetBindToDeviceRequest{
		Value: value,
	}
	resp_ := &streamSocketWithCtxSetBindToDeviceResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketSetBindToDeviceOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_SOCKET` -> `SO_BINDTODEVICE`.
func (p *StreamSocketWithCtxInterface) GetBindToDevice(ctx_ _bindings.Context) (BaseSocketGetBindToDeviceResult, error) {
	var req_ _bindings.Message
	resp_ := &streamSocketWithCtxGetBindToDeviceResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetBindToDeviceOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_SOCKET` -> `SO_TIMESTAMP`.
func (p *StreamSocketWithCtxInterface) SetTimestamp(ctx_ _bindings.Context, value bool) (BaseSocketSetTimestampResult, error) {
	req_ := &streamSocketWithCtxSetTimestampRequest{
		Value: value,
	}
	resp_ := &streamSocketWithCtxSetTimestampResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketSetTimestampOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_SOCKET` -> `SO_TIMESTAMP`.
func (p *StreamSocketWithCtxInterface) GetTimestamp(ctx_ _bindings.Context) (BaseSocketGetTimestampResult, error) {
	var req_ _bindings.Message
	resp_ := &streamSocketWithCtxGetTimestampResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetTimestampOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_IP` -> `IP_TOS`.
func (p *StreamSocketWithCtxInterface) SetIpTypeOfService(ctx_ _bindings.Context, value uint8) (BaseSocketSetIpTypeOfServiceResult, error) {
	req_ := &streamSocketWithCtxSetIpTypeOfServiceRequest{
		Value: value,
	}
	resp_ := &streamSocketWithCtxSetIpTypeOfServiceResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketSetIpTypeOfServiceOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_IP` -> `IP_TOS`.
func (p *StreamSocketWithCtxInterface) GetIpTypeOfService(ctx_ _bindings.Context) (BaseSocketGetIpTypeOfServiceResult, error) {
	var req_ _bindings.Message
	resp_ := &streamSocketWithCtxGetIpTypeOfServiceResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetIpTypeOfServiceOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_IP` -> `IP_TTL`.
func (p *StreamSocketWithCtxInterface) SetIpTtl(ctx_ _bindings.Context, value OptionalUint8) (BaseSocketSetIpTtlResult, error) {
	req_ := &streamSocketWithCtxSetIpTtlRequest{
		Value: value,
	}
	resp_ := &streamSocketWithCtxSetIpTtlResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketSetIpTtlOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_IP` -> `IP_TTL`.
func (p *StreamSocketWithCtxInterface) GetIpTtl(ctx_ _bindings.Context) (BaseSocketGetIpTtlResult, error) {
	var req_ _bindings.Message
	resp_ := &streamSocketWithCtxGetIpTtlResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetIpTtlOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_IP` -> `IP_PKTINFO`.
func (p *StreamSocketWithCtxInterface) SetIpPacketInfo(ctx_ _bindings.Context, value bool) (BaseSocketSetIpPacketInfoResult, error) {
	req_ := &streamSocketWithCtxSetIpPacketInfoRequest{
		Value: value,
	}
	resp_ := &streamSocketWithCtxSetIpPacketInfoResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketSetIpPacketInfoOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_IP` -> `IP_PKTINFO`.
func (p *StreamSocketWithCtxInterface) GetIpPacketInfo(ctx_ _bindings.Context) (BaseSocketGetIpPacketInfoResult, error) {
	var req_ _bindings.Message
	resp_ := &streamSocketWithCtxGetIpPacketInfoResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetIpPacketInfoOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_IP` -> `IP_RECVTOS`.
func (p *StreamSocketWithCtxInterface) SetIpReceiveTypeOfService(ctx_ _bindings.Context, value bool) (BaseSocketSetIpReceiveTypeOfServiceResult, error) {
	req_ := &streamSocketWithCtxSetIpReceiveTypeOfServiceRequest{
		Value: value,
	}
	resp_ := &streamSocketWithCtxSetIpReceiveTypeOfServiceResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketSetIpReceiveTypeOfServiceOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_IP` -> `IP_RECVTOS`.
func (p *StreamSocketWithCtxInterface) GetIpReceiveTypeOfService(ctx_ _bindings.Context) (BaseSocketGetIpReceiveTypeOfServiceResult, error) {
	var req_ _bindings.Message
	resp_ := &streamSocketWithCtxGetIpReceiveTypeOfServiceResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetIpReceiveTypeOfServiceOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_IP` -> `IP_MULTICAST_IF`.
func (p *StreamSocketWithCtxInterface) SetIpMulticastInterface(ctx_ _bindings.Context, iface uint64, address fuchsianet.Ipv4Address) (BaseSocketSetIpMulticastInterfaceResult, error) {
	req_ := &streamSocketWithCtxSetIpMulticastInterfaceRequest{
		Iface:   iface,
		Address: address,
	}
	resp_ := &streamSocketWithCtxSetIpMulticastInterfaceResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketSetIpMulticastInterfaceOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_IP` -> `IP_MULTICAST_IF`.
func (p *StreamSocketWithCtxInterface) GetIpMulticastInterface(ctx_ _bindings.Context) (BaseSocketGetIpMulticastInterfaceResult, error) {
	var req_ _bindings.Message
	resp_ := &streamSocketWithCtxGetIpMulticastInterfaceResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetIpMulticastInterfaceOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_IP` -> `IP_MULTICAST_TTL`.
func (p *StreamSocketWithCtxInterface) SetIpMulticastTtl(ctx_ _bindings.Context, value OptionalUint8) (BaseSocketSetIpMulticastTtlResult, error) {
	req_ := &streamSocketWithCtxSetIpMulticastTtlRequest{
		Value: value,
	}
	resp_ := &streamSocketWithCtxSetIpMulticastTtlResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketSetIpMulticastTtlOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_IP` -> `IP_MULTICAST_TTL`.
func (p *StreamSocketWithCtxInterface) GetIpMulticastTtl(ctx_ _bindings.Context) (BaseSocketGetIpMulticastTtlResult, error) {
	var req_ _bindings.Message
	resp_ := &streamSocketWithCtxGetIpMulticastTtlResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetIpMulticastTtlOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_IP` -> `IP_MULTICAST_LOOP`.
func (p *StreamSocketWithCtxInterface) SetIpMulticastLoopback(ctx_ _bindings.Context, value bool) (BaseSocketSetIpMulticastLoopbackResult, error) {
	req_ := &streamSocketWithCtxSetIpMulticastLoopbackRequest{
		Value: value,
	}
	resp_ := &streamSocketWithCtxSetIpMulticastLoopbackResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketSetIpMulticastLoopbackOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_IP` -> `IP_MULTICAST_LOOP`.
func (p *StreamSocketWithCtxInterface) GetIpMulticastLoopback(ctx_ _bindings.Context) (BaseSocketGetIpMulticastLoopbackResult, error) {
	var req_ _bindings.Message
	resp_ := &streamSocketWithCtxGetIpMulticastLoopbackResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetIpMulticastLoopbackOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_IP` -> `IP_ADD_MEMBERSHIP`
func (p *StreamSocketWithCtxInterface) AddIpMembership(ctx_ _bindings.Context, membership IpMulticastMembership) (BaseSocketAddIpMembershipResult, error) {
	req_ := &streamSocketWithCtxAddIpMembershipRequest{
		Membership: membership,
	}
	resp_ := &streamSocketWithCtxAddIpMembershipResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketAddIpMembershipOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_IP` -> `IP_DROP_MEMBERSHIP`
func (p *StreamSocketWithCtxInterface) DropIpMembership(ctx_ _bindings.Context, membership IpMulticastMembership) (BaseSocketDropIpMembershipResult, error) {
	req_ := &streamSocketWithCtxDropIpMembershipRequest{
		Membership: membership,
	}
	resp_ := &streamSocketWithCtxDropIpMembershipResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketDropIpMembershipOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_IPV6` -> `IPV6_ADD_MEMBERSHIP`.
func (p *StreamSocketWithCtxInterface) AddIpv6Membership(ctx_ _bindings.Context, membership Ipv6MulticastMembership) (BaseSocketAddIpv6MembershipResult, error) {
	req_ := &streamSocketWithCtxAddIpv6MembershipRequest{
		Membership: membership,
	}
	resp_ := &streamSocketWithCtxAddIpv6MembershipResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketAddIpv6MembershipOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_IPV6` -> `IPV6_DROP_MEMBERSHIP`.
func (p *StreamSocketWithCtxInterface) DropIpv6Membership(ctx_ _bindings.Context, membership Ipv6MulticastMembership) (BaseSocketDropIpv6MembershipResult, error) {
	req_ := &streamSocketWithCtxDropIpv6MembershipRequest{
		Membership: membership,
	}
	resp_ := &streamSocketWithCtxDropIpv6MembershipResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketDropIpv6MembershipOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_IPV6` -> `IPV6_MULTICAST_IF`.
func (p *StreamSocketWithCtxInterface) SetIpv6MulticastInterface(ctx_ _bindings.Context, value uint64) (BaseSocketSetIpv6MulticastInterfaceResult, error) {
	req_ := &streamSocketWithCtxSetIpv6MulticastInterfaceRequest{
		Value: value,
	}
	resp_ := &streamSocketWithCtxSetIpv6MulticastInterfaceResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketSetIpv6MulticastInterfaceOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_IPV6` -> `IPV6_MULTICAST_IF`.
func (p *StreamSocketWithCtxInterface) GetIpv6MulticastInterface(ctx_ _bindings.Context) (BaseSocketGetIpv6MulticastInterfaceResult, error) {
	var req_ _bindings.Message
	resp_ := &streamSocketWithCtxGetIpv6MulticastInterfaceResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetIpv6MulticastInterfaceOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`.
func (p *StreamSocketWithCtxInterface) SetIpv6MulticastHops(ctx_ _bindings.Context, value OptionalUint8) (BaseSocketSetIpv6MulticastHopsResult, error) {
	req_ := &streamSocketWithCtxSetIpv6MulticastHopsRequest{
		Value: value,
	}
	resp_ := &streamSocketWithCtxSetIpv6MulticastHopsResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketSetIpv6MulticastHopsOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`.
func (p *StreamSocketWithCtxInterface) GetIpv6MulticastHops(ctx_ _bindings.Context) (BaseSocketGetIpv6MulticastHopsResult, error) {
	var req_ _bindings.Message
	resp_ := &streamSocketWithCtxGetIpv6MulticastHopsResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetIpv6MulticastHopsOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`.
func (p *StreamSocketWithCtxInterface) SetIpv6MulticastLoopback(ctx_ _bindings.Context, value bool) (BaseSocketSetIpv6MulticastLoopbackResult, error) {
	req_ := &streamSocketWithCtxSetIpv6MulticastLoopbackRequest{
		Value: value,
	}
	resp_ := &streamSocketWithCtxSetIpv6MulticastLoopbackResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketSetIpv6MulticastLoopbackOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`.
func (p *StreamSocketWithCtxInterface) GetIpv6MulticastLoopback(ctx_ _bindings.Context) (BaseSocketGetIpv6MulticastLoopbackResult, error) {
	var req_ _bindings.Message
	resp_ := &streamSocketWithCtxGetIpv6MulticastLoopbackResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetIpv6MulticastLoopbackOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_IPV6` -> `IPV6_V6ONLY`.
func (p *StreamSocketWithCtxInterface) SetIpv6Only(ctx_ _bindings.Context, value bool) (BaseSocketSetIpv6OnlyResult, error) {
	req_ := &streamSocketWithCtxSetIpv6OnlyRequest{
		Value: value,
	}
	resp_ := &streamSocketWithCtxSetIpv6OnlyResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketSetIpv6OnlyOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_IPV6` -> `IPV6_V6ONLY`.
func (p *StreamSocketWithCtxInterface) GetIpv6Only(ctx_ _bindings.Context) (BaseSocketGetIpv6OnlyResult, error) {
	var req_ _bindings.Message
	resp_ := &streamSocketWithCtxGetIpv6OnlyResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetIpv6OnlyOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_IPV6` -> `IPV6_RECVTCLASS`.
func (p *StreamSocketWithCtxInterface) SetIpv6ReceiveTrafficClass(ctx_ _bindings.Context, value bool) (BaseSocketSetIpv6ReceiveTrafficClassResult, error) {
	req_ := &streamSocketWithCtxSetIpv6ReceiveTrafficClassRequest{
		Value: value,
	}
	resp_ := &streamSocketWithCtxSetIpv6ReceiveTrafficClassResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketSetIpv6ReceiveTrafficClassOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_IPV6` -> `IPV6_RECVTCLASS`.
func (p *StreamSocketWithCtxInterface) GetIpv6ReceiveTrafficClass(ctx_ _bindings.Context) (BaseSocketGetIpv6ReceiveTrafficClassResult, error) {
	var req_ _bindings.Message
	resp_ := &streamSocketWithCtxGetIpv6ReceiveTrafficClassResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetIpv6ReceiveTrafficClassOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_IPV6` -> `IPV6_TCLASS`
func (p *StreamSocketWithCtxInterface) SetIpv6TrafficClass(ctx_ _bindings.Context, value OptionalUint8) (BaseSocketSetIpv6TrafficClassResult, error) {
	req_ := &streamSocketWithCtxSetIpv6TrafficClassRequest{
		Value: value,
	}
	resp_ := &streamSocketWithCtxSetIpv6TrafficClassResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketSetIpv6TrafficClassOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_IPV6` -> `IPV6_TCLASS`.
func (p *StreamSocketWithCtxInterface) GetIpv6TrafficClass(ctx_ _bindings.Context) (BaseSocketGetIpv6TrafficClassResult, error) {
	var req_ _bindings.Message
	resp_ := &streamSocketWithCtxGetIpv6TrafficClassResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetIpv6TrafficClassOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Begins listening for new incoming connections. At most `backlog` connections will be
// buffered.
func (p *StreamSocketWithCtxInterface) Listen(ctx_ _bindings.Context, backlog int16) (StreamSocketListenResult, error) {
	req_ := &streamSocketWithCtxListenRequest{
		Backlog: backlog,
	}
	resp_ := &streamSocketWithCtxListenResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketListenOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Accepts a buffered incoming connection.
func (p *StreamSocketWithCtxInterface) Accept(ctx_ _bindings.Context, wantAddr bool) (StreamSocketAcceptResult, error) {
	req_ := &streamSocketWithCtxAcceptRequest{
		WantAddr: wantAddr,
	}
	resp_ := &streamSocketWithCtxAcceptResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketAcceptOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Retrieves creation information from the socket.
func (p *StreamSocketWithCtxInterface) GetInfo(ctx_ _bindings.Context) (StreamSocketGetInfoResult, error) {
	var req_ _bindings.Message
	resp_ := &streamSocketWithCtxGetInfoResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetInfoOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_TCP` -> `TCP_NODELAY`.
func (p *StreamSocketWithCtxInterface) SetTcpNoDelay(ctx_ _bindings.Context, value bool) (StreamSocketSetTcpNoDelayResult, error) {
	req_ := &streamSocketWithCtxSetTcpNoDelayRequest{
		Value: value,
	}
	resp_ := &streamSocketWithCtxSetTcpNoDelayResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketSetTcpNoDelayOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_TCP` -> `TCP_NODELAY`.
func (p *StreamSocketWithCtxInterface) GetTcpNoDelay(ctx_ _bindings.Context) (StreamSocketGetTcpNoDelayResult, error) {
	var req_ _bindings.Message
	resp_ := &streamSocketWithCtxGetTcpNoDelayResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetTcpNoDelayOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_TCP` -> `TCP_MAXSEG`.
func (p *StreamSocketWithCtxInterface) SetTcpMaxSegment(ctx_ _bindings.Context, valueBytes uint32) (StreamSocketSetTcpMaxSegmentResult, error) {
	req_ := &streamSocketWithCtxSetTcpMaxSegmentRequest{
		ValueBytes: valueBytes,
	}
	resp_ := &streamSocketWithCtxSetTcpMaxSegmentResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketSetTcpMaxSegmentOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_TCP` -> `TCP_MAXSEG`.
func (p *StreamSocketWithCtxInterface) GetTcpMaxSegment(ctx_ _bindings.Context) (StreamSocketGetTcpMaxSegmentResult, error) {
	var req_ _bindings.Message
	resp_ := &streamSocketWithCtxGetTcpMaxSegmentResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetTcpMaxSegmentOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_TCP` -> `TCP_CORK`.
func (p *StreamSocketWithCtxInterface) SetTcpCork(ctx_ _bindings.Context, value bool) (StreamSocketSetTcpCorkResult, error) {
	req_ := &streamSocketWithCtxSetTcpCorkRequest{
		Value: value,
	}
	resp_ := &streamSocketWithCtxSetTcpCorkResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketSetTcpCorkOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_TCP` -> `TCP_CORK`.
func (p *StreamSocketWithCtxInterface) GetTcpCork(ctx_ _bindings.Context) (StreamSocketGetTcpCorkResult, error) {
	var req_ _bindings.Message
	resp_ := &streamSocketWithCtxGetTcpCorkResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetTcpCorkOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_TCP` -> `TCP_KEEPIDLE`.
func (p *StreamSocketWithCtxInterface) SetTcpKeepAliveIdle(ctx_ _bindings.Context, valueSecs uint32) (StreamSocketSetTcpKeepAliveIdleResult, error) {
	req_ := &streamSocketWithCtxSetTcpKeepAliveIdleRequest{
		ValueSecs: valueSecs,
	}
	resp_ := &streamSocketWithCtxSetTcpKeepAliveIdleResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketSetTcpKeepAliveIdleOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_TCP` -> `TCP_KEEPIDLE`.
func (p *StreamSocketWithCtxInterface) GetTcpKeepAliveIdle(ctx_ _bindings.Context) (StreamSocketGetTcpKeepAliveIdleResult, error) {
	var req_ _bindings.Message
	resp_ := &streamSocketWithCtxGetTcpKeepAliveIdleResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetTcpKeepAliveIdleOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_TCP` -> `TCP_KEEPINTVL`.
func (p *StreamSocketWithCtxInterface) SetTcpKeepAliveInterval(ctx_ _bindings.Context, valueSecs uint32) (StreamSocketSetTcpKeepAliveIntervalResult, error) {
	req_ := &streamSocketWithCtxSetTcpKeepAliveIntervalRequest{
		ValueSecs: valueSecs,
	}
	resp_ := &streamSocketWithCtxSetTcpKeepAliveIntervalResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketSetTcpKeepAliveIntervalOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_TCP` -> `TCP_KEEPINTVL`.
func (p *StreamSocketWithCtxInterface) GetTcpKeepAliveInterval(ctx_ _bindings.Context) (StreamSocketGetTcpKeepAliveIntervalResult, error) {
	var req_ _bindings.Message
	resp_ := &streamSocketWithCtxGetTcpKeepAliveIntervalResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetTcpKeepAliveIntervalOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_TCP` -> `TCP_KEEPCNT`.
func (p *StreamSocketWithCtxInterface) SetTcpKeepAliveCount(ctx_ _bindings.Context, value uint32) (StreamSocketSetTcpKeepAliveCountResult, error) {
	req_ := &streamSocketWithCtxSetTcpKeepAliveCountRequest{
		Value: value,
	}
	resp_ := &streamSocketWithCtxSetTcpKeepAliveCountResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketSetTcpKeepAliveCountOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_TCP` -> `TCP_KEEPCNT`.
func (p *StreamSocketWithCtxInterface) GetTcpKeepAliveCount(ctx_ _bindings.Context) (StreamSocketGetTcpKeepAliveCountResult, error) {
	var req_ _bindings.Message
	resp_ := &streamSocketWithCtxGetTcpKeepAliveCountResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetTcpKeepAliveCountOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_TCP` -> `TCP_SYNCNT`.
func (p *StreamSocketWithCtxInterface) SetTcpSynCount(ctx_ _bindings.Context, value uint32) (StreamSocketSetTcpSynCountResult, error) {
	req_ := &streamSocketWithCtxSetTcpSynCountRequest{
		Value: value,
	}
	resp_ := &streamSocketWithCtxSetTcpSynCountResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketSetTcpSynCountOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_TCP` -> `TCP_SYNCNT`.
func (p *StreamSocketWithCtxInterface) GetTcpSynCount(ctx_ _bindings.Context) (StreamSocketGetTcpSynCountResult, error) {
	var req_ _bindings.Message
	resp_ := &streamSocketWithCtxGetTcpSynCountResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetTcpSynCountOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_TCP` -> `TCP_LINGER2`.
func (p *StreamSocketWithCtxInterface) SetTcpLinger(ctx_ _bindings.Context, valueSecs OptionalUint32) (StreamSocketSetTcpLingerResult, error) {
	req_ := &streamSocketWithCtxSetTcpLingerRequest{
		ValueSecs: valueSecs,
	}
	resp_ := &streamSocketWithCtxSetTcpLingerResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketSetTcpLingerOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_TCP` -> `TCP_LINGER2`.
func (p *StreamSocketWithCtxInterface) GetTcpLinger(ctx_ _bindings.Context) (StreamSocketGetTcpLingerResult, error) {
	var req_ _bindings.Message
	resp_ := &streamSocketWithCtxGetTcpLingerResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetTcpLingerOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_TCP` -> `TCP_DEFER_ACCEPT`.
func (p *StreamSocketWithCtxInterface) SetTcpDeferAccept(ctx_ _bindings.Context, valueSecs uint32) (StreamSocketSetTcpDeferAcceptResult, error) {
	req_ := &streamSocketWithCtxSetTcpDeferAcceptRequest{
		ValueSecs: valueSecs,
	}
	resp_ := &streamSocketWithCtxSetTcpDeferAcceptResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketSetTcpDeferAcceptOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_TCP` -> `TCP_DEFER_ACCEPT`.
func (p *StreamSocketWithCtxInterface) GetTcpDeferAccept(ctx_ _bindings.Context) (StreamSocketGetTcpDeferAcceptResult, error) {
	var req_ _bindings.Message
	resp_ := &streamSocketWithCtxGetTcpDeferAcceptResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetTcpDeferAcceptOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_TCP` -> `TCP_WINDOW_CLAMP`.
func (p *StreamSocketWithCtxInterface) SetTcpWindowClamp(ctx_ _bindings.Context, value uint32) (StreamSocketSetTcpWindowClampResult, error) {
	req_ := &streamSocketWithCtxSetTcpWindowClampRequest{
		Value: value,
	}
	resp_ := &streamSocketWithCtxSetTcpWindowClampResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketSetTcpWindowClampOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_TCP` -> `TCP_WINDOW_CLAMP`.
func (p *StreamSocketWithCtxInterface) GetTcpWindowClamp(ctx_ _bindings.Context) (StreamSocketGetTcpWindowClampResult, error) {
	var req_ _bindings.Message
	resp_ := &streamSocketWithCtxGetTcpWindowClampResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetTcpWindowClampOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_TCP` -> `TCP_INFO`.
func (p *StreamSocketWithCtxInterface) GetTcpInfo(ctx_ _bindings.Context) (StreamSocketGetTcpInfoResult, error) {
	var req_ _bindings.Message
	resp_ := &streamSocketWithCtxGetTcpInfoResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetTcpInfoOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_TCP` -> `TCP_QUICKACK`.
func (p *StreamSocketWithCtxInterface) SetTcpQuickAck(ctx_ _bindings.Context, value bool) (StreamSocketSetTcpQuickAckResult, error) {
	req_ := &streamSocketWithCtxSetTcpQuickAckRequest{
		Value: value,
	}
	resp_ := &streamSocketWithCtxSetTcpQuickAckResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketSetTcpQuickAckOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_TCP` -> `TCP_QUICKACK`.
func (p *StreamSocketWithCtxInterface) GetTcpQuickAck(ctx_ _bindings.Context) (StreamSocketGetTcpQuickAckResult, error) {
	var req_ _bindings.Message
	resp_ := &streamSocketWithCtxGetTcpQuickAckResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetTcpQuickAckOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_TCP` -> `TCP_CONGESTION`.
func (p *StreamSocketWithCtxInterface) SetTcpCongestion(ctx_ _bindings.Context, value TcpCongestionControl) (StreamSocketSetTcpCongestionResult, error) {
	req_ := &streamSocketWithCtxSetTcpCongestionRequest{
		Value: value,
	}
	resp_ := &streamSocketWithCtxSetTcpCongestionResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketSetTcpCongestionOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_TCP` -> `TCP_CONGESTION`.
func (p *StreamSocketWithCtxInterface) GetTcpCongestion(ctx_ _bindings.Context) (StreamSocketGetTcpCongestionResult, error) {
	var req_ _bindings.Message
	resp_ := &streamSocketWithCtxGetTcpCongestionResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetTcpCongestionOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_TCP` -> `TCP_USER_TIMEOUT`.
func (p *StreamSocketWithCtxInterface) SetTcpUserTimeout(ctx_ _bindings.Context, valueMillis uint32) (StreamSocketSetTcpUserTimeoutResult, error) {
	req_ := &streamSocketWithCtxSetTcpUserTimeoutRequest{
		ValueMillis: valueMillis,
	}
	resp_ := &streamSocketWithCtxSetTcpUserTimeoutResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketSetTcpUserTimeoutOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_TCP` -> `TCP_USER_TIMEOUT`.
func (p *StreamSocketWithCtxInterface) GetTcpUserTimeout(ctx_ _bindings.Context) (StreamSocketGetTcpUserTimeoutResult, error) {
	var req_ _bindings.Message
	resp_ := &streamSocketWithCtxGetTcpUserTimeoutResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetTcpUserTimeoutOrdinal, req_, resp_)
	return resp_.Result, err_
}

// A stream socket.
//
// This type's [`fuchsia.io.Node/Describe`] method returns a socket which is used to transfer data
// to and from the caller. Signals are used to communicate additional information about the state
// of the socket such as connectedness and the presence of incoming connections in the case of a
// listening socket.
//
// All methods on this type are nonblocking; their exact behaviors match their Linux counterparts.
type StreamSocketWithCtx interface {
	// Create another connection to the same remote object.
	//
	// `flags` may be any of:
	//
	// - `OPEN_RIGHT_*`
	// - `OPEN_FLAG_APPEND`
	// - `OPEN_FLAG_NO_REMOTE`
	// - `OPEN_FLAG_DESCRIBE`
	// - `CLONE_FLAG_SAME_RIGHTS`
	//
	// All other flags are ignored.
	//
	// The `OPEN_RIGHT_*` bits in `flags` request corresponding rights over the resulting
	// cloned object.
	// The cloned object must have rights less than or equal to the original object, otherwise
	// returns `ZX_ERR_ACCESS_DENIED`.
	// Alternatively, pass `CLONE_FLAG_SAME_RIGHTS` to inherit the rights on the source connection.
	// It is invalid to pass any of the `OPEN_RIGHT_*` flags together with
	// `CLONE_FLAG_SAME_RIGHTS`.
	Clone(ctx_ _bindings.Context, flags uint32, object fuchsiaio.NodeWithCtxInterfaceRequest) error
	// Terminates connection with object.
	//
	// This method does not require any rights.
	Close(ctx_ _bindings.Context) (int32, error)
	// Returns extra information about the type of the object.
	// If the `Describe` operation fails, the connection is closed.
	//
	// This method does not require any rights.
	Describe(ctx_ _bindings.Context) (fuchsiaio.NodeInfo, error)
	// An event produced eagerly by a FIDL server if requested by `OPEN_FLAG_DESCRIBE`.
	//
	// Indicates the success or failure of the open operation, and optionally describes the
	// object. If the status is `ZX_OK`, `info` contains descriptive information about the object
	// (the same as would be returned by `Describe`).
	// Synchronizes updates to the node to the underlying media, if it exists.
	//
	// This method does not require any rights.
	Sync(ctx_ _bindings.Context) (int32, error)
	// Acquires information about the node.
	//
	// This method does not require any rights.
	GetAttr(ctx_ _bindings.Context) (int32, fuchsiaio.NodeAttributes, error)
	// Updates information about the node.
	// `flags` may be any of `NODE_ATTRIBUTE_FLAG_*`.
	//
	// This method requires following rights: `OPEN_RIGHT_WRITABLE`, otherwise returns
	// `ZX_ERR_BAD_HANDLE`.
	SetAttr(ctx_ _bindings.Context, flags uint32, attributes fuchsiaio.NodeAttributes) (int32, error)
	// Acquires the `Directory.Open` rights and flags used to access this file.
	//
	// This method does not require any rights.
	// This method has the same functionality as GetFlags for File and is
	// meant as an in-progress replacement.
	NodeGetFlags(ctx_ _bindings.Context) (int32, uint32, error)
	// Changes the `Directory.Open` flags used to access the file.
	// Supported flags which can be turned on / off:
	// - `OPEN_FLAG_APPEND`
	//
	// This method does not require any rights.
	// This method has the same functionality as SetFlags for File and is
	// meant as an in-progress replacement.
	NodeSetFlags(ctx_ _bindings.Context, flags uint32) (int32, error)
	// Sets the local address used for the socket.
	Bind(ctx_ _bindings.Context, addr fuchsianet.SocketAddress) (BaseSocketBindResult, error)
	// Initiates a connection to a remote address.
	Connect(ctx_ _bindings.Context, addr fuchsianet.SocketAddress) (BaseSocketConnectResult, error)
	// Clears connection information from this socket.
	Disconnect(ctx_ _bindings.Context) (BaseSocketDisconnectResult, error)
	// Retrieves the local socket address.
	GetSockName(ctx_ _bindings.Context) (BaseSocketGetSockNameResult, error)
	// Retrieves the remote socket address.
	GetPeerName(ctx_ _bindings.Context) (BaseSocketGetPeerNameResult, error)
	// Shuts down part of the socket.
	Shutdown(ctx_ _bindings.Context, mode ShutdownMode) (BaseSocketShutdownResult, error)
	Shutdown2(ctx_ _bindings.Context, mode ShutdownMode) (BaseSocketShutdown2Result, error)
	// Set `SOL_SOCKET` -> `SO_REUSEADDR`.
	SetReuseAddress(ctx_ _bindings.Context, value bool) (BaseSocketSetReuseAddressResult, error)
	// Get `SOL_SOCKET` -> `SO_REUSEADDR`.
	GetReuseAddress(ctx_ _bindings.Context) (BaseSocketGetReuseAddressResult, error)
	// Get `SOL_SOCKET` -> `SO_ERROR`.
	// Returns the last error if there is an error set on the socket.
	GetError(ctx_ _bindings.Context) (BaseSocketGetErrorResult, error)
	// Set `SOL_SOCKET` -> `SO_BROADCAST`.
	SetBroadcast(ctx_ _bindings.Context, value bool) (BaseSocketSetBroadcastResult, error)
	// Get `SOL_SOCKET` -> `SO_BROADCAST`.
	GetBroadcast(ctx_ _bindings.Context) (BaseSocketGetBroadcastResult, error)
	// Set `SOL_SOCKET` -> `SO_SNDBUF`.
	SetSendBuffer(ctx_ _bindings.Context, valueBytes uint64) (BaseSocketSetSendBufferResult, error)
	// Get `SOL_SOCKET` -> `SO_SNDBUF`.
	GetSendBuffer(ctx_ _bindings.Context) (BaseSocketGetSendBufferResult, error)
	// Set `SOL_SOCKET` -> `SO_RCVBUF`.
	SetReceiveBuffer(ctx_ _bindings.Context, valueBytes uint64) (BaseSocketSetReceiveBufferResult, error)
	// Get `SOL_SOCKET` -> `SO_RCVBUF`.
	GetReceiveBuffer(ctx_ _bindings.Context) (BaseSocketGetReceiveBufferResult, error)
	// Set `SOL_SOCKET` -> `SO_KEEPALIVE`.
	SetKeepAlive(ctx_ _bindings.Context, value bool) (BaseSocketSetKeepAliveResult, error)
	// Get `SOL_SOCKET` -> `SO_KEEPALIVE`.
	GetKeepAlive(ctx_ _bindings.Context) (BaseSocketGetKeepAliveResult, error)
	// Set `SOL_SOCKET` -> `SO_OOBINLINE`.
	SetOutOfBandInline(ctx_ _bindings.Context, value bool) (BaseSocketSetOutOfBandInlineResult, error)
	// Get `SOL_SOCKET` -> `SO_OOBINLINE`.
	GetOutOfBandInline(ctx_ _bindings.Context) (BaseSocketGetOutOfBandInlineResult, error)
	// Set `SOL_SOCKET` -> `SO_NO_CHECK`.
	SetNoCheck(ctx_ _bindings.Context, value bool) (BaseSocketSetNoCheckResult, error)
	// Get `SOL_SOCKET` -> `SO_NO_CHECK`.
	GetNoCheck(ctx_ _bindings.Context) (BaseSocketGetNoCheckResult, error)
	// Set `SOL_SOCKET` -> `SO_LINGER`.
	SetLinger(ctx_ _bindings.Context, linger bool, lengthSecs uint32) (BaseSocketSetLingerResult, error)
	// Get `SOL_SOCKET` -> `SO_LINGER`.
	GetLinger(ctx_ _bindings.Context) (BaseSocketGetLingerResult, error)
	// Set `SOL_SOCKET` -> `SO_REUSEPORT`.
	SetReusePort(ctx_ _bindings.Context, value bool) (BaseSocketSetReusePortResult, error)
	// Get `SOL_SOCKET` -> `SO_REUSEPORT`.
	GetReusePort(ctx_ _bindings.Context) (BaseSocketGetReusePortResult, error)
	// Get `SOL_SOCKET` -> `SO_ACCEPTCONN`.
	GetAcceptConn(ctx_ _bindings.Context) (BaseSocketGetAcceptConnResult, error)
	// Set `SOL_SOCKET` -> `SO_BINDTODEVICE`.
	SetBindToDevice(ctx_ _bindings.Context, value string) (BaseSocketSetBindToDeviceResult, error)
	// Get `SOL_SOCKET` -> `SO_BINDTODEVICE`.
	GetBindToDevice(ctx_ _bindings.Context) (BaseSocketGetBindToDeviceResult, error)
	// Set `SOL_SOCKET` -> `SO_TIMESTAMP`.
	SetTimestamp(ctx_ _bindings.Context, value bool) (BaseSocketSetTimestampResult, error)
	// Get `SOL_SOCKET` -> `SO_TIMESTAMP`.
	GetTimestamp(ctx_ _bindings.Context) (BaseSocketGetTimestampResult, error)
	// Set `SOL_IP` -> `IP_TOS`.
	SetIpTypeOfService(ctx_ _bindings.Context, value uint8) (BaseSocketSetIpTypeOfServiceResult, error)
	// Get `SOL_IP` -> `IP_TOS`.
	GetIpTypeOfService(ctx_ _bindings.Context) (BaseSocketGetIpTypeOfServiceResult, error)
	// Set `SOL_IP` -> `IP_TTL`.
	SetIpTtl(ctx_ _bindings.Context, value OptionalUint8) (BaseSocketSetIpTtlResult, error)
	// Get `SOL_IP` -> `IP_TTL`.
	GetIpTtl(ctx_ _bindings.Context) (BaseSocketGetIpTtlResult, error)
	// Set `SOL_IP` -> `IP_PKTINFO`.
	SetIpPacketInfo(ctx_ _bindings.Context, value bool) (BaseSocketSetIpPacketInfoResult, error)
	// Get `SOL_IP` -> `IP_PKTINFO`.
	GetIpPacketInfo(ctx_ _bindings.Context) (BaseSocketGetIpPacketInfoResult, error)
	// Set `SOL_IP` -> `IP_RECVTOS`.
	SetIpReceiveTypeOfService(ctx_ _bindings.Context, value bool) (BaseSocketSetIpReceiveTypeOfServiceResult, error)
	// Get `SOL_IP` -> `IP_RECVTOS`.
	GetIpReceiveTypeOfService(ctx_ _bindings.Context) (BaseSocketGetIpReceiveTypeOfServiceResult, error)
	// Set `SOL_IP` -> `IP_MULTICAST_IF`.
	SetIpMulticastInterface(ctx_ _bindings.Context, iface uint64, address fuchsianet.Ipv4Address) (BaseSocketSetIpMulticastInterfaceResult, error)
	// Get `SOL_IP` -> `IP_MULTICAST_IF`.
	GetIpMulticastInterface(ctx_ _bindings.Context) (BaseSocketGetIpMulticastInterfaceResult, error)
	// Set `SOL_IP` -> `IP_MULTICAST_TTL`.
	SetIpMulticastTtl(ctx_ _bindings.Context, value OptionalUint8) (BaseSocketSetIpMulticastTtlResult, error)
	// Get `SOL_IP` -> `IP_MULTICAST_TTL`.
	GetIpMulticastTtl(ctx_ _bindings.Context) (BaseSocketGetIpMulticastTtlResult, error)
	// Set `SOL_IP` -> `IP_MULTICAST_LOOP`.
	SetIpMulticastLoopback(ctx_ _bindings.Context, value bool) (BaseSocketSetIpMulticastLoopbackResult, error)
	// Get `SOL_IP` -> `IP_MULTICAST_LOOP`.
	GetIpMulticastLoopback(ctx_ _bindings.Context) (BaseSocketGetIpMulticastLoopbackResult, error)
	// Set `SOL_IP` -> `IP_ADD_MEMBERSHIP`
	AddIpMembership(ctx_ _bindings.Context, membership IpMulticastMembership) (BaseSocketAddIpMembershipResult, error)
	// Set `SOL_IP` -> `IP_DROP_MEMBERSHIP`
	DropIpMembership(ctx_ _bindings.Context, membership IpMulticastMembership) (BaseSocketDropIpMembershipResult, error)
	// Set `SOL_IPV6` -> `IPV6_ADD_MEMBERSHIP`.
	AddIpv6Membership(ctx_ _bindings.Context, membership Ipv6MulticastMembership) (BaseSocketAddIpv6MembershipResult, error)
	// Set `SOL_IPV6` -> `IPV6_DROP_MEMBERSHIP`.
	DropIpv6Membership(ctx_ _bindings.Context, membership Ipv6MulticastMembership) (BaseSocketDropIpv6MembershipResult, error)
	// Set `SOL_IPV6` -> `IPV6_MULTICAST_IF`.
	SetIpv6MulticastInterface(ctx_ _bindings.Context, value uint64) (BaseSocketSetIpv6MulticastInterfaceResult, error)
	// Get `SOL_IPV6` -> `IPV6_MULTICAST_IF`.
	GetIpv6MulticastInterface(ctx_ _bindings.Context) (BaseSocketGetIpv6MulticastInterfaceResult, error)
	// Set `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`.
	SetIpv6MulticastHops(ctx_ _bindings.Context, value OptionalUint8) (BaseSocketSetIpv6MulticastHopsResult, error)
	// Get `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`.
	GetIpv6MulticastHops(ctx_ _bindings.Context) (BaseSocketGetIpv6MulticastHopsResult, error)
	// Set `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`.
	SetIpv6MulticastLoopback(ctx_ _bindings.Context, value bool) (BaseSocketSetIpv6MulticastLoopbackResult, error)
	// Get `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`.
	GetIpv6MulticastLoopback(ctx_ _bindings.Context) (BaseSocketGetIpv6MulticastLoopbackResult, error)
	// Set `SOL_IPV6` -> `IPV6_V6ONLY`.
	SetIpv6Only(ctx_ _bindings.Context, value bool) (BaseSocketSetIpv6OnlyResult, error)
	// Get `SOL_IPV6` -> `IPV6_V6ONLY`.
	GetIpv6Only(ctx_ _bindings.Context) (BaseSocketGetIpv6OnlyResult, error)
	// Set `SOL_IPV6` -> `IPV6_RECVTCLASS`.
	SetIpv6ReceiveTrafficClass(ctx_ _bindings.Context, value bool) (BaseSocketSetIpv6ReceiveTrafficClassResult, error)
	// Get `SOL_IPV6` -> `IPV6_RECVTCLASS`.
	GetIpv6ReceiveTrafficClass(ctx_ _bindings.Context) (BaseSocketGetIpv6ReceiveTrafficClassResult, error)
	// Set `SOL_IPV6` -> `IPV6_TCLASS`
	SetIpv6TrafficClass(ctx_ _bindings.Context, value OptionalUint8) (BaseSocketSetIpv6TrafficClassResult, error)
	// Get `SOL_IPV6` -> `IPV6_TCLASS`.
	GetIpv6TrafficClass(ctx_ _bindings.Context) (BaseSocketGetIpv6TrafficClassResult, error)
	// Begins listening for new incoming connections. At most `backlog` connections will be
	// buffered.
	Listen(ctx_ _bindings.Context, backlog int16) (StreamSocketListenResult, error)
	// Accepts a buffered incoming connection.
	Accept(ctx_ _bindings.Context, wantAddr bool) (StreamSocketAcceptResult, error)
	// Retrieves creation information from the socket.
	GetInfo(ctx_ _bindings.Context) (StreamSocketGetInfoResult, error)
	// Set `SOL_TCP` -> `TCP_NODELAY`.
	SetTcpNoDelay(ctx_ _bindings.Context, value bool) (StreamSocketSetTcpNoDelayResult, error)
	// Get `SOL_TCP` -> `TCP_NODELAY`.
	GetTcpNoDelay(ctx_ _bindings.Context) (StreamSocketGetTcpNoDelayResult, error)
	// Set `SOL_TCP` -> `TCP_MAXSEG`.
	SetTcpMaxSegment(ctx_ _bindings.Context, valueBytes uint32) (StreamSocketSetTcpMaxSegmentResult, error)
	// Get `SOL_TCP` -> `TCP_MAXSEG`.
	GetTcpMaxSegment(ctx_ _bindings.Context) (StreamSocketGetTcpMaxSegmentResult, error)
	// Set `SOL_TCP` -> `TCP_CORK`.
	SetTcpCork(ctx_ _bindings.Context, value bool) (StreamSocketSetTcpCorkResult, error)
	// Get `SOL_TCP` -> `TCP_CORK`.
	GetTcpCork(ctx_ _bindings.Context) (StreamSocketGetTcpCorkResult, error)
	// Set `SOL_TCP` -> `TCP_KEEPIDLE`.
	SetTcpKeepAliveIdle(ctx_ _bindings.Context, valueSecs uint32) (StreamSocketSetTcpKeepAliveIdleResult, error)
	// Get `SOL_TCP` -> `TCP_KEEPIDLE`.
	GetTcpKeepAliveIdle(ctx_ _bindings.Context) (StreamSocketGetTcpKeepAliveIdleResult, error)
	// Set `SOL_TCP` -> `TCP_KEEPINTVL`.
	SetTcpKeepAliveInterval(ctx_ _bindings.Context, valueSecs uint32) (StreamSocketSetTcpKeepAliveIntervalResult, error)
	// Get `SOL_TCP` -> `TCP_KEEPINTVL`.
	GetTcpKeepAliveInterval(ctx_ _bindings.Context) (StreamSocketGetTcpKeepAliveIntervalResult, error)
	// Set `SOL_TCP` -> `TCP_KEEPCNT`.
	SetTcpKeepAliveCount(ctx_ _bindings.Context, value uint32) (StreamSocketSetTcpKeepAliveCountResult, error)
	// Get `SOL_TCP` -> `TCP_KEEPCNT`.
	GetTcpKeepAliveCount(ctx_ _bindings.Context) (StreamSocketGetTcpKeepAliveCountResult, error)
	// Set `SOL_TCP` -> `TCP_SYNCNT`.
	SetTcpSynCount(ctx_ _bindings.Context, value uint32) (StreamSocketSetTcpSynCountResult, error)
	// Get `SOL_TCP` -> `TCP_SYNCNT`.
	GetTcpSynCount(ctx_ _bindings.Context) (StreamSocketGetTcpSynCountResult, error)
	// Set `SOL_TCP` -> `TCP_LINGER2`.
	SetTcpLinger(ctx_ _bindings.Context, valueSecs OptionalUint32) (StreamSocketSetTcpLingerResult, error)
	// Get `SOL_TCP` -> `TCP_LINGER2`.
	GetTcpLinger(ctx_ _bindings.Context) (StreamSocketGetTcpLingerResult, error)
	// Set `SOL_TCP` -> `TCP_DEFER_ACCEPT`.
	SetTcpDeferAccept(ctx_ _bindings.Context, valueSecs uint32) (StreamSocketSetTcpDeferAcceptResult, error)
	// Get `SOL_TCP` -> `TCP_DEFER_ACCEPT`.
	GetTcpDeferAccept(ctx_ _bindings.Context) (StreamSocketGetTcpDeferAcceptResult, error)
	// Set `SOL_TCP` -> `TCP_WINDOW_CLAMP`.
	SetTcpWindowClamp(ctx_ _bindings.Context, value uint32) (StreamSocketSetTcpWindowClampResult, error)
	// Get `SOL_TCP` -> `TCP_WINDOW_CLAMP`.
	GetTcpWindowClamp(ctx_ _bindings.Context) (StreamSocketGetTcpWindowClampResult, error)
	// Get `SOL_TCP` -> `TCP_INFO`.
	GetTcpInfo(ctx_ _bindings.Context) (StreamSocketGetTcpInfoResult, error)
	// Set `SOL_TCP` -> `TCP_QUICKACK`.
	SetTcpQuickAck(ctx_ _bindings.Context, value bool) (StreamSocketSetTcpQuickAckResult, error)
	// Get `SOL_TCP` -> `TCP_QUICKACK`.
	GetTcpQuickAck(ctx_ _bindings.Context) (StreamSocketGetTcpQuickAckResult, error)
	// Set `SOL_TCP` -> `TCP_CONGESTION`.
	SetTcpCongestion(ctx_ _bindings.Context, value TcpCongestionControl) (StreamSocketSetTcpCongestionResult, error)
	// Get `SOL_TCP` -> `TCP_CONGESTION`.
	GetTcpCongestion(ctx_ _bindings.Context) (StreamSocketGetTcpCongestionResult, error)
	// Set `SOL_TCP` -> `TCP_USER_TIMEOUT`.
	SetTcpUserTimeout(ctx_ _bindings.Context, valueMillis uint32) (StreamSocketSetTcpUserTimeoutResult, error)
	// Get `SOL_TCP` -> `TCP_USER_TIMEOUT`.
	GetTcpUserTimeout(ctx_ _bindings.Context) (StreamSocketGetTcpUserTimeoutResult, error)
}

type StreamSocketWithCtxTransitionalBase struct{}

func (_ *StreamSocketWithCtxTransitionalBase) NodeGetFlags(ctx_ _bindings.Context) (int32, uint32, error) {
	panic("Not Implemented")
}
func (_ *StreamSocketWithCtxTransitionalBase) NodeSetFlags(ctx_ _bindings.Context, flags uint32) (int32, error) {
	panic("Not Implemented")
}

type StreamSocketWithCtxInterfaceRequest _bindings.InterfaceRequest

func NewStreamSocketWithCtxInterfaceRequest() (StreamSocketWithCtxInterfaceRequest, *StreamSocketWithCtxInterface, error) {
	req, cli, err := _bindings.NewInterfaceRequest()
	return StreamSocketWithCtxInterfaceRequest(req), (*StreamSocketWithCtxInterface)(cli), err
}

type StreamSocketWithCtxStub struct {
	Impl StreamSocketWithCtx
}

func (s_ *StreamSocketWithCtxStub) Dispatch(args_ _bindings.DispatchArgs) (_bindings.Message, bool, error) {
	switch args_.Ordinal {
	case StreamSocketCloneOrdinal:
		in_ := streamSocketWithCtxCloneRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		err_ := s_.Impl.Clone(args_.Ctx, in_.Flags, in_.Object)
		return nil, false, err_
	case StreamSocketCloseOrdinal:
		s, err_ := s_.Impl.Close(args_.Ctx)
		out_ := streamSocketWithCtxCloseResponse{}
		out_.S = s
		return &out_, true, err_
	case StreamSocketDescribeOrdinal:
		info, err_ := s_.Impl.Describe(args_.Ctx)
		out_ := streamSocketWithCtxDescribeResponse{}
		out_.Info = info
		return &out_, true, err_
	case StreamSocketSyncOrdinal:
		s, err_ := s_.Impl.Sync(args_.Ctx)
		out_ := streamSocketWithCtxSyncResponse{}
		out_.S = s
		return &out_, true, err_
	case StreamSocketGetAttrOrdinal:
		s, attributes, err_ := s_.Impl.GetAttr(args_.Ctx)
		out_ := streamSocketWithCtxGetAttrResponse{}
		out_.S = s
		out_.Attributes = attributes
		return &out_, true, err_
	case StreamSocketSetAttrOrdinal:
		in_ := streamSocketWithCtxSetAttrRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		s, err_ := s_.Impl.SetAttr(args_.Ctx, in_.Flags, in_.Attributes)
		out_ := streamSocketWithCtxSetAttrResponse{}
		out_.S = s
		return &out_, true, err_
	case StreamSocketNodeGetFlagsOrdinal:
		s, flags, err_ := s_.Impl.NodeGetFlags(args_.Ctx)
		out_ := streamSocketWithCtxNodeGetFlagsResponse{}
		out_.S = s
		out_.Flags = flags
		return &out_, true, err_
	case StreamSocketNodeSetFlagsOrdinal:
		in_ := streamSocketWithCtxNodeSetFlagsRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		s, err_ := s_.Impl.NodeSetFlags(args_.Ctx, in_.Flags)
		out_ := streamSocketWithCtxNodeSetFlagsResponse{}
		out_.S = s
		return &out_, true, err_
	case StreamSocketBindOrdinal:
		in_ := streamSocketWithCtxBindRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.Bind(args_.Ctx, in_.Addr)
		out_ := streamSocketWithCtxBindResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketConnectOrdinal:
		in_ := streamSocketWithCtxConnectRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.Connect(args_.Ctx, in_.Addr)
		out_ := streamSocketWithCtxConnectResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketDisconnectOrdinal:
		result, err_ := s_.Impl.Disconnect(args_.Ctx)
		out_ := streamSocketWithCtxDisconnectResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketGetSockNameOrdinal:
		result, err_ := s_.Impl.GetSockName(args_.Ctx)
		out_ := streamSocketWithCtxGetSockNameResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketGetPeerNameOrdinal:
		result, err_ := s_.Impl.GetPeerName(args_.Ctx)
		out_ := streamSocketWithCtxGetPeerNameResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketShutdownOrdinal:
		in_ := streamSocketWithCtxShutdownRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.Shutdown(args_.Ctx, in_.Mode)
		out_ := streamSocketWithCtxShutdownResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketShutdown2Ordinal:
		in_ := streamSocketWithCtxShutdown2Request{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.Shutdown2(args_.Ctx, in_.Mode)
		out_ := streamSocketWithCtxShutdown2Response{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketSetReuseAddressOrdinal:
		in_ := streamSocketWithCtxSetReuseAddressRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.SetReuseAddress(args_.Ctx, in_.Value)
		out_ := streamSocketWithCtxSetReuseAddressResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketGetReuseAddressOrdinal:
		result, err_ := s_.Impl.GetReuseAddress(args_.Ctx)
		out_ := streamSocketWithCtxGetReuseAddressResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketGetErrorOrdinal:
		result, err_ := s_.Impl.GetError(args_.Ctx)
		out_ := streamSocketWithCtxGetErrorResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketSetBroadcastOrdinal:
		in_ := streamSocketWithCtxSetBroadcastRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.SetBroadcast(args_.Ctx, in_.Value)
		out_ := streamSocketWithCtxSetBroadcastResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketGetBroadcastOrdinal:
		result, err_ := s_.Impl.GetBroadcast(args_.Ctx)
		out_ := streamSocketWithCtxGetBroadcastResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketSetSendBufferOrdinal:
		in_ := streamSocketWithCtxSetSendBufferRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.SetSendBuffer(args_.Ctx, in_.ValueBytes)
		out_ := streamSocketWithCtxSetSendBufferResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketGetSendBufferOrdinal:
		result, err_ := s_.Impl.GetSendBuffer(args_.Ctx)
		out_ := streamSocketWithCtxGetSendBufferResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketSetReceiveBufferOrdinal:
		in_ := streamSocketWithCtxSetReceiveBufferRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.SetReceiveBuffer(args_.Ctx, in_.ValueBytes)
		out_ := streamSocketWithCtxSetReceiveBufferResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketGetReceiveBufferOrdinal:
		result, err_ := s_.Impl.GetReceiveBuffer(args_.Ctx)
		out_ := streamSocketWithCtxGetReceiveBufferResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketSetKeepAliveOrdinal:
		in_ := streamSocketWithCtxSetKeepAliveRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.SetKeepAlive(args_.Ctx, in_.Value)
		out_ := streamSocketWithCtxSetKeepAliveResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketGetKeepAliveOrdinal:
		result, err_ := s_.Impl.GetKeepAlive(args_.Ctx)
		out_ := streamSocketWithCtxGetKeepAliveResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketSetOutOfBandInlineOrdinal:
		in_ := streamSocketWithCtxSetOutOfBandInlineRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.SetOutOfBandInline(args_.Ctx, in_.Value)
		out_ := streamSocketWithCtxSetOutOfBandInlineResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketGetOutOfBandInlineOrdinal:
		result, err_ := s_.Impl.GetOutOfBandInline(args_.Ctx)
		out_ := streamSocketWithCtxGetOutOfBandInlineResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketSetNoCheckOrdinal:
		in_ := streamSocketWithCtxSetNoCheckRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.SetNoCheck(args_.Ctx, in_.Value)
		out_ := streamSocketWithCtxSetNoCheckResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketGetNoCheckOrdinal:
		result, err_ := s_.Impl.GetNoCheck(args_.Ctx)
		out_ := streamSocketWithCtxGetNoCheckResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketSetLingerOrdinal:
		in_ := streamSocketWithCtxSetLingerRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.SetLinger(args_.Ctx, in_.Linger, in_.LengthSecs)
		out_ := streamSocketWithCtxSetLingerResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketGetLingerOrdinal:
		result, err_ := s_.Impl.GetLinger(args_.Ctx)
		out_ := streamSocketWithCtxGetLingerResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketSetReusePortOrdinal:
		in_ := streamSocketWithCtxSetReusePortRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.SetReusePort(args_.Ctx, in_.Value)
		out_ := streamSocketWithCtxSetReusePortResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketGetReusePortOrdinal:
		result, err_ := s_.Impl.GetReusePort(args_.Ctx)
		out_ := streamSocketWithCtxGetReusePortResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketGetAcceptConnOrdinal:
		result, err_ := s_.Impl.GetAcceptConn(args_.Ctx)
		out_ := streamSocketWithCtxGetAcceptConnResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketSetBindToDeviceOrdinal:
		in_ := streamSocketWithCtxSetBindToDeviceRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.SetBindToDevice(args_.Ctx, in_.Value)
		out_ := streamSocketWithCtxSetBindToDeviceResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketGetBindToDeviceOrdinal:
		result, err_ := s_.Impl.GetBindToDevice(args_.Ctx)
		out_ := streamSocketWithCtxGetBindToDeviceResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketSetTimestampOrdinal:
		in_ := streamSocketWithCtxSetTimestampRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.SetTimestamp(args_.Ctx, in_.Value)
		out_ := streamSocketWithCtxSetTimestampResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketGetTimestampOrdinal:
		result, err_ := s_.Impl.GetTimestamp(args_.Ctx)
		out_ := streamSocketWithCtxGetTimestampResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketSetIpTypeOfServiceOrdinal:
		in_ := streamSocketWithCtxSetIpTypeOfServiceRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.SetIpTypeOfService(args_.Ctx, in_.Value)
		out_ := streamSocketWithCtxSetIpTypeOfServiceResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketGetIpTypeOfServiceOrdinal:
		result, err_ := s_.Impl.GetIpTypeOfService(args_.Ctx)
		out_ := streamSocketWithCtxGetIpTypeOfServiceResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketSetIpTtlOrdinal:
		in_ := streamSocketWithCtxSetIpTtlRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.SetIpTtl(args_.Ctx, in_.Value)
		out_ := streamSocketWithCtxSetIpTtlResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketGetIpTtlOrdinal:
		result, err_ := s_.Impl.GetIpTtl(args_.Ctx)
		out_ := streamSocketWithCtxGetIpTtlResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketSetIpPacketInfoOrdinal:
		in_ := streamSocketWithCtxSetIpPacketInfoRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.SetIpPacketInfo(args_.Ctx, in_.Value)
		out_ := streamSocketWithCtxSetIpPacketInfoResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketGetIpPacketInfoOrdinal:
		result, err_ := s_.Impl.GetIpPacketInfo(args_.Ctx)
		out_ := streamSocketWithCtxGetIpPacketInfoResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketSetIpReceiveTypeOfServiceOrdinal:
		in_ := streamSocketWithCtxSetIpReceiveTypeOfServiceRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.SetIpReceiveTypeOfService(args_.Ctx, in_.Value)
		out_ := streamSocketWithCtxSetIpReceiveTypeOfServiceResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketGetIpReceiveTypeOfServiceOrdinal:
		result, err_ := s_.Impl.GetIpReceiveTypeOfService(args_.Ctx)
		out_ := streamSocketWithCtxGetIpReceiveTypeOfServiceResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketSetIpMulticastInterfaceOrdinal:
		in_ := streamSocketWithCtxSetIpMulticastInterfaceRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.SetIpMulticastInterface(args_.Ctx, in_.Iface, in_.Address)
		out_ := streamSocketWithCtxSetIpMulticastInterfaceResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketGetIpMulticastInterfaceOrdinal:
		result, err_ := s_.Impl.GetIpMulticastInterface(args_.Ctx)
		out_ := streamSocketWithCtxGetIpMulticastInterfaceResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketSetIpMulticastTtlOrdinal:
		in_ := streamSocketWithCtxSetIpMulticastTtlRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.SetIpMulticastTtl(args_.Ctx, in_.Value)
		out_ := streamSocketWithCtxSetIpMulticastTtlResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketGetIpMulticastTtlOrdinal:
		result, err_ := s_.Impl.GetIpMulticastTtl(args_.Ctx)
		out_ := streamSocketWithCtxGetIpMulticastTtlResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketSetIpMulticastLoopbackOrdinal:
		in_ := streamSocketWithCtxSetIpMulticastLoopbackRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.SetIpMulticastLoopback(args_.Ctx, in_.Value)
		out_ := streamSocketWithCtxSetIpMulticastLoopbackResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketGetIpMulticastLoopbackOrdinal:
		result, err_ := s_.Impl.GetIpMulticastLoopback(args_.Ctx)
		out_ := streamSocketWithCtxGetIpMulticastLoopbackResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketAddIpMembershipOrdinal:
		in_ := streamSocketWithCtxAddIpMembershipRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.AddIpMembership(args_.Ctx, in_.Membership)
		out_ := streamSocketWithCtxAddIpMembershipResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketDropIpMembershipOrdinal:
		in_ := streamSocketWithCtxDropIpMembershipRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.DropIpMembership(args_.Ctx, in_.Membership)
		out_ := streamSocketWithCtxDropIpMembershipResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketAddIpv6MembershipOrdinal:
		in_ := streamSocketWithCtxAddIpv6MembershipRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.AddIpv6Membership(args_.Ctx, in_.Membership)
		out_ := streamSocketWithCtxAddIpv6MembershipResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketDropIpv6MembershipOrdinal:
		in_ := streamSocketWithCtxDropIpv6MembershipRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.DropIpv6Membership(args_.Ctx, in_.Membership)
		out_ := streamSocketWithCtxDropIpv6MembershipResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketSetIpv6MulticastInterfaceOrdinal:
		in_ := streamSocketWithCtxSetIpv6MulticastInterfaceRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.SetIpv6MulticastInterface(args_.Ctx, in_.Value)
		out_ := streamSocketWithCtxSetIpv6MulticastInterfaceResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketGetIpv6MulticastInterfaceOrdinal:
		result, err_ := s_.Impl.GetIpv6MulticastInterface(args_.Ctx)
		out_ := streamSocketWithCtxGetIpv6MulticastInterfaceResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketSetIpv6MulticastHopsOrdinal:
		in_ := streamSocketWithCtxSetIpv6MulticastHopsRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.SetIpv6MulticastHops(args_.Ctx, in_.Value)
		out_ := streamSocketWithCtxSetIpv6MulticastHopsResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketGetIpv6MulticastHopsOrdinal:
		result, err_ := s_.Impl.GetIpv6MulticastHops(args_.Ctx)
		out_ := streamSocketWithCtxGetIpv6MulticastHopsResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketSetIpv6MulticastLoopbackOrdinal:
		in_ := streamSocketWithCtxSetIpv6MulticastLoopbackRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.SetIpv6MulticastLoopback(args_.Ctx, in_.Value)
		out_ := streamSocketWithCtxSetIpv6MulticastLoopbackResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketGetIpv6MulticastLoopbackOrdinal:
		result, err_ := s_.Impl.GetIpv6MulticastLoopback(args_.Ctx)
		out_ := streamSocketWithCtxGetIpv6MulticastLoopbackResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketSetIpv6OnlyOrdinal:
		in_ := streamSocketWithCtxSetIpv6OnlyRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.SetIpv6Only(args_.Ctx, in_.Value)
		out_ := streamSocketWithCtxSetIpv6OnlyResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketGetIpv6OnlyOrdinal:
		result, err_ := s_.Impl.GetIpv6Only(args_.Ctx)
		out_ := streamSocketWithCtxGetIpv6OnlyResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketSetIpv6ReceiveTrafficClassOrdinal:
		in_ := streamSocketWithCtxSetIpv6ReceiveTrafficClassRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.SetIpv6ReceiveTrafficClass(args_.Ctx, in_.Value)
		out_ := streamSocketWithCtxSetIpv6ReceiveTrafficClassResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketGetIpv6ReceiveTrafficClassOrdinal:
		result, err_ := s_.Impl.GetIpv6ReceiveTrafficClass(args_.Ctx)
		out_ := streamSocketWithCtxGetIpv6ReceiveTrafficClassResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketSetIpv6TrafficClassOrdinal:
		in_ := streamSocketWithCtxSetIpv6TrafficClassRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.SetIpv6TrafficClass(args_.Ctx, in_.Value)
		out_ := streamSocketWithCtxSetIpv6TrafficClassResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketGetIpv6TrafficClassOrdinal:
		result, err_ := s_.Impl.GetIpv6TrafficClass(args_.Ctx)
		out_ := streamSocketWithCtxGetIpv6TrafficClassResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketListenOrdinal:
		in_ := streamSocketWithCtxListenRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.Listen(args_.Ctx, in_.Backlog)
		out_ := streamSocketWithCtxListenResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketAcceptOrdinal:
		in_ := streamSocketWithCtxAcceptRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.Accept(args_.Ctx, in_.WantAddr)
		out_ := streamSocketWithCtxAcceptResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketGetInfoOrdinal:
		result, err_ := s_.Impl.GetInfo(args_.Ctx)
		out_ := streamSocketWithCtxGetInfoResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketSetTcpNoDelayOrdinal:
		in_ := streamSocketWithCtxSetTcpNoDelayRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.SetTcpNoDelay(args_.Ctx, in_.Value)
		out_ := streamSocketWithCtxSetTcpNoDelayResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketGetTcpNoDelayOrdinal:
		result, err_ := s_.Impl.GetTcpNoDelay(args_.Ctx)
		out_ := streamSocketWithCtxGetTcpNoDelayResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketSetTcpMaxSegmentOrdinal:
		in_ := streamSocketWithCtxSetTcpMaxSegmentRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.SetTcpMaxSegment(args_.Ctx, in_.ValueBytes)
		out_ := streamSocketWithCtxSetTcpMaxSegmentResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketGetTcpMaxSegmentOrdinal:
		result, err_ := s_.Impl.GetTcpMaxSegment(args_.Ctx)
		out_ := streamSocketWithCtxGetTcpMaxSegmentResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketSetTcpCorkOrdinal:
		in_ := streamSocketWithCtxSetTcpCorkRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.SetTcpCork(args_.Ctx, in_.Value)
		out_ := streamSocketWithCtxSetTcpCorkResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketGetTcpCorkOrdinal:
		result, err_ := s_.Impl.GetTcpCork(args_.Ctx)
		out_ := streamSocketWithCtxGetTcpCorkResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketSetTcpKeepAliveIdleOrdinal:
		in_ := streamSocketWithCtxSetTcpKeepAliveIdleRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.SetTcpKeepAliveIdle(args_.Ctx, in_.ValueSecs)
		out_ := streamSocketWithCtxSetTcpKeepAliveIdleResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketGetTcpKeepAliveIdleOrdinal:
		result, err_ := s_.Impl.GetTcpKeepAliveIdle(args_.Ctx)
		out_ := streamSocketWithCtxGetTcpKeepAliveIdleResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketSetTcpKeepAliveIntervalOrdinal:
		in_ := streamSocketWithCtxSetTcpKeepAliveIntervalRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.SetTcpKeepAliveInterval(args_.Ctx, in_.ValueSecs)
		out_ := streamSocketWithCtxSetTcpKeepAliveIntervalResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketGetTcpKeepAliveIntervalOrdinal:
		result, err_ := s_.Impl.GetTcpKeepAliveInterval(args_.Ctx)
		out_ := streamSocketWithCtxGetTcpKeepAliveIntervalResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketSetTcpKeepAliveCountOrdinal:
		in_ := streamSocketWithCtxSetTcpKeepAliveCountRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.SetTcpKeepAliveCount(args_.Ctx, in_.Value)
		out_ := streamSocketWithCtxSetTcpKeepAliveCountResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketGetTcpKeepAliveCountOrdinal:
		result, err_ := s_.Impl.GetTcpKeepAliveCount(args_.Ctx)
		out_ := streamSocketWithCtxGetTcpKeepAliveCountResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketSetTcpSynCountOrdinal:
		in_ := streamSocketWithCtxSetTcpSynCountRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.SetTcpSynCount(args_.Ctx, in_.Value)
		out_ := streamSocketWithCtxSetTcpSynCountResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketGetTcpSynCountOrdinal:
		result, err_ := s_.Impl.GetTcpSynCount(args_.Ctx)
		out_ := streamSocketWithCtxGetTcpSynCountResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketSetTcpLingerOrdinal:
		in_ := streamSocketWithCtxSetTcpLingerRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.SetTcpLinger(args_.Ctx, in_.ValueSecs)
		out_ := streamSocketWithCtxSetTcpLingerResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketGetTcpLingerOrdinal:
		result, err_ := s_.Impl.GetTcpLinger(args_.Ctx)
		out_ := streamSocketWithCtxGetTcpLingerResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketSetTcpDeferAcceptOrdinal:
		in_ := streamSocketWithCtxSetTcpDeferAcceptRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.SetTcpDeferAccept(args_.Ctx, in_.ValueSecs)
		out_ := streamSocketWithCtxSetTcpDeferAcceptResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketGetTcpDeferAcceptOrdinal:
		result, err_ := s_.Impl.GetTcpDeferAccept(args_.Ctx)
		out_ := streamSocketWithCtxGetTcpDeferAcceptResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketSetTcpWindowClampOrdinal:
		in_ := streamSocketWithCtxSetTcpWindowClampRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.SetTcpWindowClamp(args_.Ctx, in_.Value)
		out_ := streamSocketWithCtxSetTcpWindowClampResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketGetTcpWindowClampOrdinal:
		result, err_ := s_.Impl.GetTcpWindowClamp(args_.Ctx)
		out_ := streamSocketWithCtxGetTcpWindowClampResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketGetTcpInfoOrdinal:
		result, err_ := s_.Impl.GetTcpInfo(args_.Ctx)
		out_ := streamSocketWithCtxGetTcpInfoResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketSetTcpQuickAckOrdinal:
		in_ := streamSocketWithCtxSetTcpQuickAckRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.SetTcpQuickAck(args_.Ctx, in_.Value)
		out_ := streamSocketWithCtxSetTcpQuickAckResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketGetTcpQuickAckOrdinal:
		result, err_ := s_.Impl.GetTcpQuickAck(args_.Ctx)
		out_ := streamSocketWithCtxGetTcpQuickAckResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketSetTcpCongestionOrdinal:
		in_ := streamSocketWithCtxSetTcpCongestionRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.SetTcpCongestion(args_.Ctx, in_.Value)
		out_ := streamSocketWithCtxSetTcpCongestionResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketGetTcpCongestionOrdinal:
		result, err_ := s_.Impl.GetTcpCongestion(args_.Ctx)
		out_ := streamSocketWithCtxGetTcpCongestionResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketSetTcpUserTimeoutOrdinal:
		in_ := streamSocketWithCtxSetTcpUserTimeoutRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.SetTcpUserTimeout(args_.Ctx, in_.ValueMillis)
		out_ := streamSocketWithCtxSetTcpUserTimeoutResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketGetTcpUserTimeoutOrdinal:
		result, err_ := s_.Impl.GetTcpUserTimeout(args_.Ctx)
		out_ := streamSocketWithCtxGetTcpUserTimeoutResponse{}
		out_.Result = result
		return &out_, true, err_
	}
	return nil, false, _bindings.ErrUnknownOrdinal
}

type StreamSocketEventProxy _bindings.ChannelProxy

func (p *StreamSocketEventProxy) OnOpen(s int32, info *fuchsiaio.NodeInfo) error {
	event_ := &streamSocketWithCtxOnOpenResponse{
		S:    s,
		Info: info,
	}
	return ((*_bindings.ChannelProxy)(p)).Send(StreamSocketOnOpenOrdinal, event_)
}

const (
	ProviderStreamSocketOrdinal          uint64 = 0x27c3581da2155545
	ProviderDatagramSocketOrdinal        uint64 = 0x38876c87cf031cb1
	ProviderInterfaceIndexToNameOrdinal  uint64 = 0x4d59a64fce98272f
	ProviderInterfaceNameToIndexOrdinal  uint64 = 0x690cd8d2f2d650f8
	ProviderInterfaceNameToFlagsOrdinal  uint64 = 0x25d0efcdb6671a0b
	ProviderGetInterfaceAddressesOrdinal uint64 = 0x2e7b9aaf327c870
)

type ProviderWithCtxInterface _bindings.ChannelProxy

// Requests a stream socket with the specified parameters.
func (p *ProviderWithCtxInterface) StreamSocket(ctx_ _bindings.Context, domain Domain, proto StreamSocketProtocol) (ProviderStreamSocketResult, error) {
	req_ := &providerWithCtxStreamSocketRequest{
		Domain: domain,
		Proto:  proto,
	}
	resp_ := &providerWithCtxStreamSocketResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(ProviderStreamSocketOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Requests a datagram socket with the specified parameters.
func (p *ProviderWithCtxInterface) DatagramSocket(ctx_ _bindings.Context, domain Domain, proto DatagramSocketProtocol) (ProviderDatagramSocketResult, error) {
	req_ := &providerWithCtxDatagramSocketRequest{
		Domain: domain,
		Proto:  proto,
	}
	resp_ := &providerWithCtxDatagramSocketResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(ProviderDatagramSocketOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Looks up an interface by its index and returns its name. Returns `ZX_ERR_NOT_FOUND` if the
// specified index doesn't exist.
func (p *ProviderWithCtxInterface) InterfaceIndexToName(ctx_ _bindings.Context, index uint64) (ProviderInterfaceIndexToNameResult, error) {
	req_ := &providerWithCtxInterfaceIndexToNameRequest{
		Index: index,
	}
	resp_ := &providerWithCtxInterfaceIndexToNameResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(ProviderInterfaceIndexToNameOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Looks up an interface by its name and returns its index. Returns `ZX_ERR_NOT_FOUND` if the
// specified name doesn't exist.
func (p *ProviderWithCtxInterface) InterfaceNameToIndex(ctx_ _bindings.Context, name string) (ProviderInterfaceNameToIndexResult, error) {
	req_ := &providerWithCtxInterfaceNameToIndexRequest{
		Name: name,
	}
	resp_ := &providerWithCtxInterfaceNameToIndexResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(ProviderInterfaceNameToIndexOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Looks up an interface by its name and returns its flags. Returns `ZX_ERR_NOT_FOUND` if the
// specified name doesn't exist.
func (p *ProviderWithCtxInterface) InterfaceNameToFlags(ctx_ _bindings.Context, name string) (ProviderInterfaceNameToFlagsResult, error) {
	req_ := &providerWithCtxInterfaceNameToFlagsRequest{
		Name: name,
	}
	resp_ := &providerWithCtxInterfaceNameToFlagsResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(ProviderInterfaceNameToFlagsOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Requests a list of [`fuchsia.posix.socket.InterfaceAddresses`]
// describing the network interfaces on the system.
func (p *ProviderWithCtxInterface) GetInterfaceAddresses(ctx_ _bindings.Context) ([]InterfaceAddresses, error) {
	var req_ _bindings.Message
	resp_ := &providerWithCtxGetInterfaceAddressesResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(ProviderGetInterfaceAddressesOrdinal, req_, resp_)
	return resp_.Interfaces, err_
}

// Provider implements the POSIX sockets API.
type ProviderWithCtx interface {
	// Requests a stream socket with the specified parameters.
	StreamSocket(ctx_ _bindings.Context, domain Domain, proto StreamSocketProtocol) (ProviderStreamSocketResult, error)
	// Requests a datagram socket with the specified parameters.
	DatagramSocket(ctx_ _bindings.Context, domain Domain, proto DatagramSocketProtocol) (ProviderDatagramSocketResult, error)
	// Looks up an interface by its index and returns its name. Returns `ZX_ERR_NOT_FOUND` if the
	// specified index doesn't exist.
	InterfaceIndexToName(ctx_ _bindings.Context, index uint64) (ProviderInterfaceIndexToNameResult, error)
	// Looks up an interface by its name and returns its index. Returns `ZX_ERR_NOT_FOUND` if the
	// specified name doesn't exist.
	InterfaceNameToIndex(ctx_ _bindings.Context, name string) (ProviderInterfaceNameToIndexResult, error)
	// Looks up an interface by its name and returns its flags. Returns `ZX_ERR_NOT_FOUND` if the
	// specified name doesn't exist.
	InterfaceNameToFlags(ctx_ _bindings.Context, name string) (ProviderInterfaceNameToFlagsResult, error)
	// Requests a list of [`fuchsia.posix.socket.InterfaceAddresses`]
	// describing the network interfaces on the system.
	GetInterfaceAddresses(ctx_ _bindings.Context) ([]InterfaceAddresses, error)
}

type ProviderWithCtxTransitionalBase struct{}

type ProviderWithCtxInterfaceRequest _bindings.InterfaceRequest

func NewProviderWithCtxInterfaceRequest() (ProviderWithCtxInterfaceRequest, *ProviderWithCtxInterface, error) {
	req, cli, err := _bindings.NewInterfaceRequest()
	return ProviderWithCtxInterfaceRequest(req), (*ProviderWithCtxInterface)(cli), err
}

// Implements ServiceRequest.
func (_ ProviderWithCtxInterfaceRequest) Name() string {
	return "fuchsia.posix.socket.Provider"
}
func (c ProviderWithCtxInterfaceRequest) ToChannel() _zx.Channel {
	return c.Channel
}

const ProviderName = "fuchsia.posix.socket.Provider"

type ProviderWithCtxStub struct {
	Impl ProviderWithCtx
}

func (s_ *ProviderWithCtxStub) Dispatch(args_ _bindings.DispatchArgs) (_bindings.Message, bool, error) {
	switch args_.Ordinal {
	case ProviderStreamSocketOrdinal:
		in_ := providerWithCtxStreamSocketRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.StreamSocket(args_.Ctx, in_.Domain, in_.Proto)
		out_ := providerWithCtxStreamSocketResponse{}
		out_.Result = result
		return &out_, true, err_
	case ProviderDatagramSocketOrdinal:
		in_ := providerWithCtxDatagramSocketRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.DatagramSocket(args_.Ctx, in_.Domain, in_.Proto)
		out_ := providerWithCtxDatagramSocketResponse{}
		out_.Result = result
		return &out_, true, err_
	case ProviderInterfaceIndexToNameOrdinal:
		in_ := providerWithCtxInterfaceIndexToNameRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.InterfaceIndexToName(args_.Ctx, in_.Index)
		out_ := providerWithCtxInterfaceIndexToNameResponse{}
		out_.Result = result
		return &out_, true, err_
	case ProviderInterfaceNameToIndexOrdinal:
		in_ := providerWithCtxInterfaceNameToIndexRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.InterfaceNameToIndex(args_.Ctx, in_.Name)
		out_ := providerWithCtxInterfaceNameToIndexResponse{}
		out_.Result = result
		return &out_, true, err_
	case ProviderInterfaceNameToFlagsOrdinal:
		in_ := providerWithCtxInterfaceNameToFlagsRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.InterfaceNameToFlags(args_.Ctx, in_.Name)
		out_ := providerWithCtxInterfaceNameToFlagsResponse{}
		out_.Result = result
		return &out_, true, err_
	case ProviderGetInterfaceAddressesOrdinal:
		interfaces, err_ := s_.Impl.GetInterfaceAddresses(args_.Ctx)
		out_ := providerWithCtxGetInterfaceAddressesResponse{}
		out_.Interfaces = interfaces
		return &out_, true, err_
	}
	return nil, false, _bindings.ErrUnknownOrdinal
}

type ProviderEventProxy _bindings.ChannelProxy