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 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 BaseNetworkSocketBindResponse struct {
	_ struct{} `fidl:"s" fidl_size_v1:"1" fidl_alignment_v1:"1" fidl_size_v2:"1" fidl_alignment_v2:"1"`
}

var _mBaseNetworkSocketBindResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketBindResponse{})

func (msg *BaseNetworkSocketBindResponse) Marshaler() _bindings.Marshaler {
	return _mBaseNetworkSocketBindResponse
}

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

var _mBaseNetworkSocketConnectResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketConnectResponse{})

func (msg *BaseNetworkSocketConnectResponse) Marshaler() _bindings.Marshaler {
	return _mBaseNetworkSocketConnectResponse
}

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

var _mBaseNetworkSocketDisconnectResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketDisconnectResponse{})

func (msg *BaseNetworkSocketDisconnectResponse) Marshaler() _bindings.Marshaler {
	return _mBaseNetworkSocketDisconnectResponse
}

type BaseNetworkSocketGetSockNameResponse 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 _mBaseNetworkSocketGetSockNameResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketGetSockNameResponse{})

func (msg *BaseNetworkSocketGetSockNameResponse) Marshaler() _bindings.Marshaler {
	return _mBaseNetworkSocketGetSockNameResponse
}

type BaseNetworkSocketGetPeerNameResponse 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 _mBaseNetworkSocketGetPeerNameResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketGetPeerNameResponse{})

func (msg *BaseNetworkSocketGetPeerNameResponse) Marshaler() _bindings.Marshaler {
	return _mBaseNetworkSocketGetPeerNameResponse
}

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

var _mBaseNetworkSocketShutdownResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketShutdownResponse{})

func (msg *BaseNetworkSocketShutdownResponse) Marshaler() _bindings.Marshaler {
	return _mBaseNetworkSocketShutdownResponse
}

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

var _mBaseNetworkSocketShutdown2Response = _bindings.CreateLazyMarshaler(BaseNetworkSocketShutdown2Response{})

func (msg *BaseNetworkSocketShutdown2Response) Marshaler() _bindings.Marshaler {
	return _mBaseNetworkSocketShutdown2Response
}

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

var _mBaseNetworkSocketSetIpTypeOfServiceResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketSetIpTypeOfServiceResponse{})

func (msg *BaseNetworkSocketSetIpTypeOfServiceResponse) Marshaler() _bindings.Marshaler {
	return _mBaseNetworkSocketSetIpTypeOfServiceResponse
}

type BaseNetworkSocketGetIpTypeOfServiceResponse 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 _mBaseNetworkSocketGetIpTypeOfServiceResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketGetIpTypeOfServiceResponse{})

func (msg *BaseNetworkSocketGetIpTypeOfServiceResponse) Marshaler() _bindings.Marshaler {
	return _mBaseNetworkSocketGetIpTypeOfServiceResponse
}

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

var _mBaseNetworkSocketSetIpTtlResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketSetIpTtlResponse{})

func (msg *BaseNetworkSocketSetIpTtlResponse) Marshaler() _bindings.Marshaler {
	return _mBaseNetworkSocketSetIpTtlResponse
}

type BaseNetworkSocketGetIpTtlResponse 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 _mBaseNetworkSocketGetIpTtlResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketGetIpTtlResponse{})

func (msg *BaseNetworkSocketGetIpTtlResponse) Marshaler() _bindings.Marshaler {
	return _mBaseNetworkSocketGetIpTtlResponse
}

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

var _mBaseNetworkSocketSetIpPacketInfoResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketSetIpPacketInfoResponse{})

func (msg *BaseNetworkSocketSetIpPacketInfoResponse) Marshaler() _bindings.Marshaler {
	return _mBaseNetworkSocketSetIpPacketInfoResponse
}

type BaseNetworkSocketGetIpPacketInfoResponse 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 _mBaseNetworkSocketGetIpPacketInfoResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketGetIpPacketInfoResponse{})

func (msg *BaseNetworkSocketGetIpPacketInfoResponse) Marshaler() _bindings.Marshaler {
	return _mBaseNetworkSocketGetIpPacketInfoResponse
}

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

var _mBaseNetworkSocketSetIpReceiveTypeOfServiceResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketSetIpReceiveTypeOfServiceResponse{})

func (msg *BaseNetworkSocketSetIpReceiveTypeOfServiceResponse) Marshaler() _bindings.Marshaler {
	return _mBaseNetworkSocketSetIpReceiveTypeOfServiceResponse
}

type BaseNetworkSocketGetIpReceiveTypeOfServiceResponse 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 _mBaseNetworkSocketGetIpReceiveTypeOfServiceResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketGetIpReceiveTypeOfServiceResponse{})

func (msg *BaseNetworkSocketGetIpReceiveTypeOfServiceResponse) Marshaler() _bindings.Marshaler {
	return _mBaseNetworkSocketGetIpReceiveTypeOfServiceResponse
}

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

var _mBaseNetworkSocketSetIpMulticastInterfaceResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketSetIpMulticastInterfaceResponse{})

func (msg *BaseNetworkSocketSetIpMulticastInterfaceResponse) Marshaler() _bindings.Marshaler {
	return _mBaseNetworkSocketSetIpMulticastInterfaceResponse
}

type BaseNetworkSocketGetIpMulticastInterfaceResponse 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 _mBaseNetworkSocketGetIpMulticastInterfaceResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketGetIpMulticastInterfaceResponse{})

func (msg *BaseNetworkSocketGetIpMulticastInterfaceResponse) Marshaler() _bindings.Marshaler {
	return _mBaseNetworkSocketGetIpMulticastInterfaceResponse
}

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

var _mBaseNetworkSocketSetIpMulticastTtlResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketSetIpMulticastTtlResponse{})

func (msg *BaseNetworkSocketSetIpMulticastTtlResponse) Marshaler() _bindings.Marshaler {
	return _mBaseNetworkSocketSetIpMulticastTtlResponse
}

type BaseNetworkSocketGetIpMulticastTtlResponse 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 _mBaseNetworkSocketGetIpMulticastTtlResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketGetIpMulticastTtlResponse{})

func (msg *BaseNetworkSocketGetIpMulticastTtlResponse) Marshaler() _bindings.Marshaler {
	return _mBaseNetworkSocketGetIpMulticastTtlResponse
}

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

var _mBaseNetworkSocketSetIpMulticastLoopbackResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketSetIpMulticastLoopbackResponse{})

func (msg *BaseNetworkSocketSetIpMulticastLoopbackResponse) Marshaler() _bindings.Marshaler {
	return _mBaseNetworkSocketSetIpMulticastLoopbackResponse
}

type BaseNetworkSocketGetIpMulticastLoopbackResponse 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 _mBaseNetworkSocketGetIpMulticastLoopbackResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketGetIpMulticastLoopbackResponse{})

func (msg *BaseNetworkSocketGetIpMulticastLoopbackResponse) Marshaler() _bindings.Marshaler {
	return _mBaseNetworkSocketGetIpMulticastLoopbackResponse
}

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

var _mBaseNetworkSocketAddIpMembershipResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketAddIpMembershipResponse{})

func (msg *BaseNetworkSocketAddIpMembershipResponse) Marshaler() _bindings.Marshaler {
	return _mBaseNetworkSocketAddIpMembershipResponse
}

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

var _mBaseNetworkSocketDropIpMembershipResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketDropIpMembershipResponse{})

func (msg *BaseNetworkSocketDropIpMembershipResponse) Marshaler() _bindings.Marshaler {
	return _mBaseNetworkSocketDropIpMembershipResponse
}

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

var _mBaseNetworkSocketAddIpv6MembershipResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketAddIpv6MembershipResponse{})

func (msg *BaseNetworkSocketAddIpv6MembershipResponse) Marshaler() _bindings.Marshaler {
	return _mBaseNetworkSocketAddIpv6MembershipResponse
}

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

var _mBaseNetworkSocketDropIpv6MembershipResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketDropIpv6MembershipResponse{})

func (msg *BaseNetworkSocketDropIpv6MembershipResponse) Marshaler() _bindings.Marshaler {
	return _mBaseNetworkSocketDropIpv6MembershipResponse
}

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

var _mBaseNetworkSocketSetIpv6MulticastInterfaceResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketSetIpv6MulticastInterfaceResponse{})

func (msg *BaseNetworkSocketSetIpv6MulticastInterfaceResponse) Marshaler() _bindings.Marshaler {
	return _mBaseNetworkSocketSetIpv6MulticastInterfaceResponse
}

type BaseNetworkSocketGetIpv6MulticastInterfaceResponse 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 _mBaseNetworkSocketGetIpv6MulticastInterfaceResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketGetIpv6MulticastInterfaceResponse{})

func (msg *BaseNetworkSocketGetIpv6MulticastInterfaceResponse) Marshaler() _bindings.Marshaler {
	return _mBaseNetworkSocketGetIpv6MulticastInterfaceResponse
}

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

var _mBaseNetworkSocketSetIpv6MulticastHopsResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketSetIpv6MulticastHopsResponse{})

func (msg *BaseNetworkSocketSetIpv6MulticastHopsResponse) Marshaler() _bindings.Marshaler {
	return _mBaseNetworkSocketSetIpv6MulticastHopsResponse
}

type BaseNetworkSocketGetIpv6MulticastHopsResponse 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 _mBaseNetworkSocketGetIpv6MulticastHopsResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketGetIpv6MulticastHopsResponse{})

func (msg *BaseNetworkSocketGetIpv6MulticastHopsResponse) Marshaler() _bindings.Marshaler {
	return _mBaseNetworkSocketGetIpv6MulticastHopsResponse
}

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

var _mBaseNetworkSocketSetIpv6MulticastLoopbackResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketSetIpv6MulticastLoopbackResponse{})

func (msg *BaseNetworkSocketSetIpv6MulticastLoopbackResponse) Marshaler() _bindings.Marshaler {
	return _mBaseNetworkSocketSetIpv6MulticastLoopbackResponse
}

type BaseNetworkSocketGetIpv6MulticastLoopbackResponse 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 _mBaseNetworkSocketGetIpv6MulticastLoopbackResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketGetIpv6MulticastLoopbackResponse{})

func (msg *BaseNetworkSocketGetIpv6MulticastLoopbackResponse) Marshaler() _bindings.Marshaler {
	return _mBaseNetworkSocketGetIpv6MulticastLoopbackResponse
}

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

var _mBaseNetworkSocketSetIpv6OnlyResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketSetIpv6OnlyResponse{})

func (msg *BaseNetworkSocketSetIpv6OnlyResponse) Marshaler() _bindings.Marshaler {
	return _mBaseNetworkSocketSetIpv6OnlyResponse
}

type BaseNetworkSocketGetIpv6OnlyResponse 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 _mBaseNetworkSocketGetIpv6OnlyResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketGetIpv6OnlyResponse{})

func (msg *BaseNetworkSocketGetIpv6OnlyResponse) Marshaler() _bindings.Marshaler {
	return _mBaseNetworkSocketGetIpv6OnlyResponse
}

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

var _mBaseNetworkSocketSetIpv6ReceiveTrafficClassResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketSetIpv6ReceiveTrafficClassResponse{})

func (msg *BaseNetworkSocketSetIpv6ReceiveTrafficClassResponse) Marshaler() _bindings.Marshaler {
	return _mBaseNetworkSocketSetIpv6ReceiveTrafficClassResponse
}

type BaseNetworkSocketGetIpv6ReceiveTrafficClassResponse 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 _mBaseNetworkSocketGetIpv6ReceiveTrafficClassResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketGetIpv6ReceiveTrafficClassResponse{})

func (msg *BaseNetworkSocketGetIpv6ReceiveTrafficClassResponse) Marshaler() _bindings.Marshaler {
	return _mBaseNetworkSocketGetIpv6ReceiveTrafficClassResponse
}

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

var _mBaseNetworkSocketSetIpv6TrafficClassResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketSetIpv6TrafficClassResponse{})

func (msg *BaseNetworkSocketSetIpv6TrafficClassResponse) Marshaler() _bindings.Marshaler {
	return _mBaseNetworkSocketSetIpv6TrafficClassResponse
}

type BaseNetworkSocketGetIpv6TrafficClassResponse 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 _mBaseNetworkSocketGetIpv6TrafficClassResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketGetIpv6TrafficClassResponse{})

func (msg *BaseNetworkSocketGetIpv6TrafficClassResponse) Marshaler() _bindings.Marshaler {
	return _mBaseNetworkSocketGetIpv6TrafficClassResponse
}

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

var _mBaseNetworkSocketBaseSocketBindResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketBaseSocketBindResponse{})

func (msg *BaseNetworkSocketBaseSocketBindResponse) Marshaler() _bindings.Marshaler {
	return _mBaseNetworkSocketBaseSocketBindResponse
}

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

var _mBaseNetworkSocketBaseSocketConnectResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketBaseSocketConnectResponse{})

func (msg *BaseNetworkSocketBaseSocketConnectResponse) Marshaler() _bindings.Marshaler {
	return _mBaseNetworkSocketBaseSocketConnectResponse
}

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

var _mBaseNetworkSocketBaseSocketDisconnectResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketBaseSocketDisconnectResponse{})

func (msg *BaseNetworkSocketBaseSocketDisconnectResponse) Marshaler() _bindings.Marshaler {
	return _mBaseNetworkSocketBaseSocketDisconnectResponse
}

type BaseNetworkSocketBaseSocketGetSockNameResponse 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 _mBaseNetworkSocketBaseSocketGetSockNameResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketBaseSocketGetSockNameResponse{})

func (msg *BaseNetworkSocketBaseSocketGetSockNameResponse) Marshaler() _bindings.Marshaler {
	return _mBaseNetworkSocketBaseSocketGetSockNameResponse
}

type BaseNetworkSocketBaseSocketGetPeerNameResponse 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 _mBaseNetworkSocketBaseSocketGetPeerNameResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketBaseSocketGetPeerNameResponse{})

func (msg *BaseNetworkSocketBaseSocketGetPeerNameResponse) Marshaler() _bindings.Marshaler {
	return _mBaseNetworkSocketBaseSocketGetPeerNameResponse
}

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

var _mBaseNetworkSocketBaseSocketShutdownResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketBaseSocketShutdownResponse{})

func (msg *BaseNetworkSocketBaseSocketShutdownResponse) Marshaler() _bindings.Marshaler {
	return _mBaseNetworkSocketBaseSocketShutdownResponse
}

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

var _mBaseNetworkSocketBaseSocketShutdown2Response = _bindings.CreateLazyMarshaler(BaseNetworkSocketBaseSocketShutdown2Response{})

func (msg *BaseNetworkSocketBaseSocketShutdown2Response) Marshaler() _bindings.Marshaler {
	return _mBaseNetworkSocketBaseSocketShutdown2Response
}

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

var _mBaseNetworkSocketBaseSocketSetIpTypeOfServiceResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketBaseSocketSetIpTypeOfServiceResponse{})

func (msg *BaseNetworkSocketBaseSocketSetIpTypeOfServiceResponse) Marshaler() _bindings.Marshaler {
	return _mBaseNetworkSocketBaseSocketSetIpTypeOfServiceResponse
}

type BaseNetworkSocketBaseSocketGetIpTypeOfServiceResponse 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 _mBaseNetworkSocketBaseSocketGetIpTypeOfServiceResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketBaseSocketGetIpTypeOfServiceResponse{})

func (msg *BaseNetworkSocketBaseSocketGetIpTypeOfServiceResponse) Marshaler() _bindings.Marshaler {
	return _mBaseNetworkSocketBaseSocketGetIpTypeOfServiceResponse
}

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

var _mBaseNetworkSocketBaseSocketSetIpTtlResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketBaseSocketSetIpTtlResponse{})

func (msg *BaseNetworkSocketBaseSocketSetIpTtlResponse) Marshaler() _bindings.Marshaler {
	return _mBaseNetworkSocketBaseSocketSetIpTtlResponse
}

type BaseNetworkSocketBaseSocketGetIpTtlResponse 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 _mBaseNetworkSocketBaseSocketGetIpTtlResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketBaseSocketGetIpTtlResponse{})

func (msg *BaseNetworkSocketBaseSocketGetIpTtlResponse) Marshaler() _bindings.Marshaler {
	return _mBaseNetworkSocketBaseSocketGetIpTtlResponse
}

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

var _mBaseNetworkSocketBaseSocketSetIpPacketInfoResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketBaseSocketSetIpPacketInfoResponse{})

func (msg *BaseNetworkSocketBaseSocketSetIpPacketInfoResponse) Marshaler() _bindings.Marshaler {
	return _mBaseNetworkSocketBaseSocketSetIpPacketInfoResponse
}

type BaseNetworkSocketBaseSocketGetIpPacketInfoResponse 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 _mBaseNetworkSocketBaseSocketGetIpPacketInfoResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketBaseSocketGetIpPacketInfoResponse{})

func (msg *BaseNetworkSocketBaseSocketGetIpPacketInfoResponse) Marshaler() _bindings.Marshaler {
	return _mBaseNetworkSocketBaseSocketGetIpPacketInfoResponse
}

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

var _mBaseNetworkSocketBaseSocketSetIpReceiveTypeOfServiceResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketBaseSocketSetIpReceiveTypeOfServiceResponse{})

func (msg *BaseNetworkSocketBaseSocketSetIpReceiveTypeOfServiceResponse) Marshaler() _bindings.Marshaler {
	return _mBaseNetworkSocketBaseSocketSetIpReceiveTypeOfServiceResponse
}

type BaseNetworkSocketBaseSocketGetIpReceiveTypeOfServiceResponse 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 _mBaseNetworkSocketBaseSocketGetIpReceiveTypeOfServiceResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketBaseSocketGetIpReceiveTypeOfServiceResponse{})

func (msg *BaseNetworkSocketBaseSocketGetIpReceiveTypeOfServiceResponse) Marshaler() _bindings.Marshaler {
	return _mBaseNetworkSocketBaseSocketGetIpReceiveTypeOfServiceResponse
}

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

var _mBaseNetworkSocketBaseSocketSetIpMulticastInterfaceResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketBaseSocketSetIpMulticastInterfaceResponse{})

func (msg *BaseNetworkSocketBaseSocketSetIpMulticastInterfaceResponse) Marshaler() _bindings.Marshaler {
	return _mBaseNetworkSocketBaseSocketSetIpMulticastInterfaceResponse
}

type BaseNetworkSocketBaseSocketGetIpMulticastInterfaceResponse 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 _mBaseNetworkSocketBaseSocketGetIpMulticastInterfaceResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketBaseSocketGetIpMulticastInterfaceResponse{})

func (msg *BaseNetworkSocketBaseSocketGetIpMulticastInterfaceResponse) Marshaler() _bindings.Marshaler {
	return _mBaseNetworkSocketBaseSocketGetIpMulticastInterfaceResponse
}

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

var _mBaseNetworkSocketBaseSocketSetIpMulticastTtlResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketBaseSocketSetIpMulticastTtlResponse{})

func (msg *BaseNetworkSocketBaseSocketSetIpMulticastTtlResponse) Marshaler() _bindings.Marshaler {
	return _mBaseNetworkSocketBaseSocketSetIpMulticastTtlResponse
}

type BaseNetworkSocketBaseSocketGetIpMulticastTtlResponse 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 _mBaseNetworkSocketBaseSocketGetIpMulticastTtlResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketBaseSocketGetIpMulticastTtlResponse{})

func (msg *BaseNetworkSocketBaseSocketGetIpMulticastTtlResponse) Marshaler() _bindings.Marshaler {
	return _mBaseNetworkSocketBaseSocketGetIpMulticastTtlResponse
}

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

var _mBaseNetworkSocketBaseSocketSetIpMulticastLoopbackResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketBaseSocketSetIpMulticastLoopbackResponse{})

func (msg *BaseNetworkSocketBaseSocketSetIpMulticastLoopbackResponse) Marshaler() _bindings.Marshaler {
	return _mBaseNetworkSocketBaseSocketSetIpMulticastLoopbackResponse
}

type BaseNetworkSocketBaseSocketGetIpMulticastLoopbackResponse 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 _mBaseNetworkSocketBaseSocketGetIpMulticastLoopbackResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketBaseSocketGetIpMulticastLoopbackResponse{})

func (msg *BaseNetworkSocketBaseSocketGetIpMulticastLoopbackResponse) Marshaler() _bindings.Marshaler {
	return _mBaseNetworkSocketBaseSocketGetIpMulticastLoopbackResponse
}

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

var _mBaseNetworkSocketBaseSocketAddIpMembershipResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketBaseSocketAddIpMembershipResponse{})

func (msg *BaseNetworkSocketBaseSocketAddIpMembershipResponse) Marshaler() _bindings.Marshaler {
	return _mBaseNetworkSocketBaseSocketAddIpMembershipResponse
}

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

var _mBaseNetworkSocketBaseSocketDropIpMembershipResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketBaseSocketDropIpMembershipResponse{})

func (msg *BaseNetworkSocketBaseSocketDropIpMembershipResponse) Marshaler() _bindings.Marshaler {
	return _mBaseNetworkSocketBaseSocketDropIpMembershipResponse
}

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

var _mBaseNetworkSocketBaseSocketAddIpv6MembershipResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketBaseSocketAddIpv6MembershipResponse{})

func (msg *BaseNetworkSocketBaseSocketAddIpv6MembershipResponse) Marshaler() _bindings.Marshaler {
	return _mBaseNetworkSocketBaseSocketAddIpv6MembershipResponse
}

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

var _mBaseNetworkSocketBaseSocketDropIpv6MembershipResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketBaseSocketDropIpv6MembershipResponse{})

func (msg *BaseNetworkSocketBaseSocketDropIpv6MembershipResponse) Marshaler() _bindings.Marshaler {
	return _mBaseNetworkSocketBaseSocketDropIpv6MembershipResponse
}

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

var _mBaseNetworkSocketBaseSocketSetIpv6MulticastInterfaceResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketBaseSocketSetIpv6MulticastInterfaceResponse{})

func (msg *BaseNetworkSocketBaseSocketSetIpv6MulticastInterfaceResponse) Marshaler() _bindings.Marshaler {
	return _mBaseNetworkSocketBaseSocketSetIpv6MulticastInterfaceResponse
}

type BaseNetworkSocketBaseSocketGetIpv6MulticastInterfaceResponse 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 _mBaseNetworkSocketBaseSocketGetIpv6MulticastInterfaceResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketBaseSocketGetIpv6MulticastInterfaceResponse{})

func (msg *BaseNetworkSocketBaseSocketGetIpv6MulticastInterfaceResponse) Marshaler() _bindings.Marshaler {
	return _mBaseNetworkSocketBaseSocketGetIpv6MulticastInterfaceResponse
}

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

var _mBaseNetworkSocketBaseSocketSetIpv6MulticastHopsResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketBaseSocketSetIpv6MulticastHopsResponse{})

func (msg *BaseNetworkSocketBaseSocketSetIpv6MulticastHopsResponse) Marshaler() _bindings.Marshaler {
	return _mBaseNetworkSocketBaseSocketSetIpv6MulticastHopsResponse
}

type BaseNetworkSocketBaseSocketGetIpv6MulticastHopsResponse 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 _mBaseNetworkSocketBaseSocketGetIpv6MulticastHopsResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketBaseSocketGetIpv6MulticastHopsResponse{})

func (msg *BaseNetworkSocketBaseSocketGetIpv6MulticastHopsResponse) Marshaler() _bindings.Marshaler {
	return _mBaseNetworkSocketBaseSocketGetIpv6MulticastHopsResponse
}

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

var _mBaseNetworkSocketBaseSocketSetIpv6MulticastLoopbackResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketBaseSocketSetIpv6MulticastLoopbackResponse{})

func (msg *BaseNetworkSocketBaseSocketSetIpv6MulticastLoopbackResponse) Marshaler() _bindings.Marshaler {
	return _mBaseNetworkSocketBaseSocketSetIpv6MulticastLoopbackResponse
}

type BaseNetworkSocketBaseSocketGetIpv6MulticastLoopbackResponse 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 _mBaseNetworkSocketBaseSocketGetIpv6MulticastLoopbackResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketBaseSocketGetIpv6MulticastLoopbackResponse{})

func (msg *BaseNetworkSocketBaseSocketGetIpv6MulticastLoopbackResponse) Marshaler() _bindings.Marshaler {
	return _mBaseNetworkSocketBaseSocketGetIpv6MulticastLoopbackResponse
}

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

var _mBaseNetworkSocketBaseSocketSetIpv6OnlyResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketBaseSocketSetIpv6OnlyResponse{})

func (msg *BaseNetworkSocketBaseSocketSetIpv6OnlyResponse) Marshaler() _bindings.Marshaler {
	return _mBaseNetworkSocketBaseSocketSetIpv6OnlyResponse
}

type BaseNetworkSocketBaseSocketGetIpv6OnlyResponse 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 _mBaseNetworkSocketBaseSocketGetIpv6OnlyResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketBaseSocketGetIpv6OnlyResponse{})

func (msg *BaseNetworkSocketBaseSocketGetIpv6OnlyResponse) Marshaler() _bindings.Marshaler {
	return _mBaseNetworkSocketBaseSocketGetIpv6OnlyResponse
}

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

var _mBaseNetworkSocketBaseSocketSetIpv6ReceiveTrafficClassResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketBaseSocketSetIpv6ReceiveTrafficClassResponse{})

func (msg *BaseNetworkSocketBaseSocketSetIpv6ReceiveTrafficClassResponse) Marshaler() _bindings.Marshaler {
	return _mBaseNetworkSocketBaseSocketSetIpv6ReceiveTrafficClassResponse
}

type BaseNetworkSocketBaseSocketGetIpv6ReceiveTrafficClassResponse 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 _mBaseNetworkSocketBaseSocketGetIpv6ReceiveTrafficClassResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketBaseSocketGetIpv6ReceiveTrafficClassResponse{})

func (msg *BaseNetworkSocketBaseSocketGetIpv6ReceiveTrafficClassResponse) Marshaler() _bindings.Marshaler {
	return _mBaseNetworkSocketBaseSocketGetIpv6ReceiveTrafficClassResponse
}

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

var _mBaseNetworkSocketBaseSocketSetIpv6TrafficClassResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketBaseSocketSetIpv6TrafficClassResponse{})

func (msg *BaseNetworkSocketBaseSocketSetIpv6TrafficClassResponse) Marshaler() _bindings.Marshaler {
	return _mBaseNetworkSocketBaseSocketSetIpv6TrafficClassResponse
}

type BaseNetworkSocketBaseSocketGetIpv6TrafficClassResponse 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 _mBaseNetworkSocketBaseSocketGetIpv6TrafficClassResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketBaseSocketGetIpv6TrafficClassResponse{})

func (msg *BaseNetworkSocketBaseSocketGetIpv6TrafficClassResponse) Marshaler() _bindings.Marshaler {
	return _mBaseNetworkSocketBaseSocketGetIpv6TrafficClassResponse
}

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 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 baseNetworkSocketWithCtxCloneRequest 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 _mbaseNetworkSocketWithCtxCloneRequest = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxCloneRequest{})

func (msg *baseNetworkSocketWithCtxCloneRequest) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxCloneRequest
}

type baseNetworkSocketWithCtxCloseResponse 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 _mbaseNetworkSocketWithCtxCloseResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxCloseResponse{})

func (msg *baseNetworkSocketWithCtxCloseResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxCloseResponse
}

type baseNetworkSocketWithCtxDescribeResponse 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 _mbaseNetworkSocketWithCtxDescribeResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxDescribeResponse{})

func (msg *baseNetworkSocketWithCtxDescribeResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxDescribeResponse
}

type baseNetworkSocketWithCtxOnOpenResponse 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 _mbaseNetworkSocketWithCtxOnOpenResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxOnOpenResponse{})

func (msg *baseNetworkSocketWithCtxOnOpenResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxOnOpenResponse
}

type baseNetworkSocketWithCtxSyncResponse 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 _mbaseNetworkSocketWithCtxSyncResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxSyncResponse{})

func (msg *baseNetworkSocketWithCtxSyncResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxSyncResponse
}

type baseNetworkSocketWithCtxGetAttrResponse 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 _mbaseNetworkSocketWithCtxGetAttrResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxGetAttrResponse{})

func (msg *baseNetworkSocketWithCtxGetAttrResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxGetAttrResponse
}

type baseNetworkSocketWithCtxSetAttrRequest 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 _mbaseNetworkSocketWithCtxSetAttrRequest = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxSetAttrRequest{})

func (msg *baseNetworkSocketWithCtxSetAttrRequest) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxSetAttrRequest
}

type baseNetworkSocketWithCtxSetAttrResponse 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 _mbaseNetworkSocketWithCtxSetAttrResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxSetAttrResponse{})

func (msg *baseNetworkSocketWithCtxSetAttrResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxSetAttrResponse
}

type baseNetworkSocketWithCtxNodeGetFlagsResponse 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 _mbaseNetworkSocketWithCtxNodeGetFlagsResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxNodeGetFlagsResponse{})

func (msg *baseNetworkSocketWithCtxNodeGetFlagsResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxNodeGetFlagsResponse
}

type baseNetworkSocketWithCtxNodeSetFlagsRequest 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 _mbaseNetworkSocketWithCtxNodeSetFlagsRequest = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxNodeSetFlagsRequest{})

func (msg *baseNetworkSocketWithCtxNodeSetFlagsRequest) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxNodeSetFlagsRequest
}

type baseNetworkSocketWithCtxNodeSetFlagsResponse 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 _mbaseNetworkSocketWithCtxNodeSetFlagsResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxNodeSetFlagsResponse{})

func (msg *baseNetworkSocketWithCtxNodeSetFlagsResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxNodeSetFlagsResponse
}

type baseNetworkSocketWithCtxSetReuseAddressRequest 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 _mbaseNetworkSocketWithCtxSetReuseAddressRequest = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxSetReuseAddressRequest{})

func (msg *baseNetworkSocketWithCtxSetReuseAddressRequest) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxSetReuseAddressRequest
}

type baseNetworkSocketWithCtxSetReuseAddressResponse 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 _mbaseNetworkSocketWithCtxSetReuseAddressResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxSetReuseAddressResponse{})

func (msg *baseNetworkSocketWithCtxSetReuseAddressResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxSetReuseAddressResponse
}

type baseNetworkSocketWithCtxGetReuseAddressResponse 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 _mbaseNetworkSocketWithCtxGetReuseAddressResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxGetReuseAddressResponse{})

func (msg *baseNetworkSocketWithCtxGetReuseAddressResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxGetReuseAddressResponse
}

type baseNetworkSocketWithCtxGetErrorResponse 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 _mbaseNetworkSocketWithCtxGetErrorResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxGetErrorResponse{})

func (msg *baseNetworkSocketWithCtxGetErrorResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxGetErrorResponse
}

type baseNetworkSocketWithCtxSetBroadcastRequest 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 _mbaseNetworkSocketWithCtxSetBroadcastRequest = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxSetBroadcastRequest{})

func (msg *baseNetworkSocketWithCtxSetBroadcastRequest) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxSetBroadcastRequest
}

type baseNetworkSocketWithCtxSetBroadcastResponse 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 _mbaseNetworkSocketWithCtxSetBroadcastResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxSetBroadcastResponse{})

func (msg *baseNetworkSocketWithCtxSetBroadcastResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxSetBroadcastResponse
}

type baseNetworkSocketWithCtxGetBroadcastResponse 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 _mbaseNetworkSocketWithCtxGetBroadcastResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxGetBroadcastResponse{})

func (msg *baseNetworkSocketWithCtxGetBroadcastResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxGetBroadcastResponse
}

type baseNetworkSocketWithCtxSetSendBufferRequest 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 _mbaseNetworkSocketWithCtxSetSendBufferRequest = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxSetSendBufferRequest{})

func (msg *baseNetworkSocketWithCtxSetSendBufferRequest) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxSetSendBufferRequest
}

type baseNetworkSocketWithCtxSetSendBufferResponse 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 _mbaseNetworkSocketWithCtxSetSendBufferResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxSetSendBufferResponse{})

func (msg *baseNetworkSocketWithCtxSetSendBufferResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxSetSendBufferResponse
}

type baseNetworkSocketWithCtxGetSendBufferResponse 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 _mbaseNetworkSocketWithCtxGetSendBufferResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxGetSendBufferResponse{})

func (msg *baseNetworkSocketWithCtxGetSendBufferResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxGetSendBufferResponse
}

type baseNetworkSocketWithCtxSetReceiveBufferRequest 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 _mbaseNetworkSocketWithCtxSetReceiveBufferRequest = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxSetReceiveBufferRequest{})

func (msg *baseNetworkSocketWithCtxSetReceiveBufferRequest) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxSetReceiveBufferRequest
}

type baseNetworkSocketWithCtxSetReceiveBufferResponse 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 _mbaseNetworkSocketWithCtxSetReceiveBufferResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxSetReceiveBufferResponse{})

func (msg *baseNetworkSocketWithCtxSetReceiveBufferResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxSetReceiveBufferResponse
}

type baseNetworkSocketWithCtxGetReceiveBufferResponse 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 _mbaseNetworkSocketWithCtxGetReceiveBufferResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxGetReceiveBufferResponse{})

func (msg *baseNetworkSocketWithCtxGetReceiveBufferResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxGetReceiveBufferResponse
}

type baseNetworkSocketWithCtxSetKeepAliveRequest 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 _mbaseNetworkSocketWithCtxSetKeepAliveRequest = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxSetKeepAliveRequest{})

func (msg *baseNetworkSocketWithCtxSetKeepAliveRequest) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxSetKeepAliveRequest
}

type baseNetworkSocketWithCtxSetKeepAliveResponse 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 _mbaseNetworkSocketWithCtxSetKeepAliveResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxSetKeepAliveResponse{})

func (msg *baseNetworkSocketWithCtxSetKeepAliveResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxSetKeepAliveResponse
}

type baseNetworkSocketWithCtxGetKeepAliveResponse 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 _mbaseNetworkSocketWithCtxGetKeepAliveResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxGetKeepAliveResponse{})

func (msg *baseNetworkSocketWithCtxGetKeepAliveResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxGetKeepAliveResponse
}

type baseNetworkSocketWithCtxSetOutOfBandInlineRequest 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 _mbaseNetworkSocketWithCtxSetOutOfBandInlineRequest = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxSetOutOfBandInlineRequest{})

func (msg *baseNetworkSocketWithCtxSetOutOfBandInlineRequest) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxSetOutOfBandInlineRequest
}

type baseNetworkSocketWithCtxSetOutOfBandInlineResponse 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 _mbaseNetworkSocketWithCtxSetOutOfBandInlineResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxSetOutOfBandInlineResponse{})

func (msg *baseNetworkSocketWithCtxSetOutOfBandInlineResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxSetOutOfBandInlineResponse
}

type baseNetworkSocketWithCtxGetOutOfBandInlineResponse 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 _mbaseNetworkSocketWithCtxGetOutOfBandInlineResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxGetOutOfBandInlineResponse{})

func (msg *baseNetworkSocketWithCtxGetOutOfBandInlineResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxGetOutOfBandInlineResponse
}

type baseNetworkSocketWithCtxSetNoCheckRequest 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 _mbaseNetworkSocketWithCtxSetNoCheckRequest = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxSetNoCheckRequest{})

func (msg *baseNetworkSocketWithCtxSetNoCheckRequest) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxSetNoCheckRequest
}

type baseNetworkSocketWithCtxSetNoCheckResponse 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 _mbaseNetworkSocketWithCtxSetNoCheckResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxSetNoCheckResponse{})

func (msg *baseNetworkSocketWithCtxSetNoCheckResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxSetNoCheckResponse
}

type baseNetworkSocketWithCtxGetNoCheckResponse 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 _mbaseNetworkSocketWithCtxGetNoCheckResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxGetNoCheckResponse{})

func (msg *baseNetworkSocketWithCtxGetNoCheckResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxGetNoCheckResponse
}

type baseNetworkSocketWithCtxSetLingerRequest 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 _mbaseNetworkSocketWithCtxSetLingerRequest = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxSetLingerRequest{})

func (msg *baseNetworkSocketWithCtxSetLingerRequest) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxSetLingerRequest
}

type baseNetworkSocketWithCtxSetLingerResponse 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 _mbaseNetworkSocketWithCtxSetLingerResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxSetLingerResponse{})

func (msg *baseNetworkSocketWithCtxSetLingerResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxSetLingerResponse
}

type baseNetworkSocketWithCtxGetLingerResponse 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 _mbaseNetworkSocketWithCtxGetLingerResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxGetLingerResponse{})

func (msg *baseNetworkSocketWithCtxGetLingerResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxGetLingerResponse
}

type baseNetworkSocketWithCtxSetReusePortRequest 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 _mbaseNetworkSocketWithCtxSetReusePortRequest = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxSetReusePortRequest{})

func (msg *baseNetworkSocketWithCtxSetReusePortRequest) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxSetReusePortRequest
}

type baseNetworkSocketWithCtxSetReusePortResponse 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 _mbaseNetworkSocketWithCtxSetReusePortResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxSetReusePortResponse{})

func (msg *baseNetworkSocketWithCtxSetReusePortResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxSetReusePortResponse
}

type baseNetworkSocketWithCtxGetReusePortResponse 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 _mbaseNetworkSocketWithCtxGetReusePortResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxGetReusePortResponse{})

func (msg *baseNetworkSocketWithCtxGetReusePortResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxGetReusePortResponse
}

type baseNetworkSocketWithCtxGetAcceptConnResponse 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 _mbaseNetworkSocketWithCtxGetAcceptConnResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxGetAcceptConnResponse{})

func (msg *baseNetworkSocketWithCtxGetAcceptConnResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxGetAcceptConnResponse
}

type baseNetworkSocketWithCtxSetBindToDeviceRequest 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 _mbaseNetworkSocketWithCtxSetBindToDeviceRequest = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxSetBindToDeviceRequest{})

func (msg *baseNetworkSocketWithCtxSetBindToDeviceRequest) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxSetBindToDeviceRequest
}

type baseNetworkSocketWithCtxSetBindToDeviceResponse 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 _mbaseNetworkSocketWithCtxSetBindToDeviceResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxSetBindToDeviceResponse{})

func (msg *baseNetworkSocketWithCtxSetBindToDeviceResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxSetBindToDeviceResponse
}

type baseNetworkSocketWithCtxGetBindToDeviceResponse 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 _mbaseNetworkSocketWithCtxGetBindToDeviceResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxGetBindToDeviceResponse{})

func (msg *baseNetworkSocketWithCtxGetBindToDeviceResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxGetBindToDeviceResponse
}

type baseNetworkSocketWithCtxSetTimestampRequest 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 _mbaseNetworkSocketWithCtxSetTimestampRequest = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxSetTimestampRequest{})

func (msg *baseNetworkSocketWithCtxSetTimestampRequest) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxSetTimestampRequest
}

type baseNetworkSocketWithCtxSetTimestampResponse 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 _mbaseNetworkSocketWithCtxSetTimestampResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxSetTimestampResponse{})

func (msg *baseNetworkSocketWithCtxSetTimestampResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxSetTimestampResponse
}

type baseNetworkSocketWithCtxGetTimestampResponse 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 _mbaseNetworkSocketWithCtxGetTimestampResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxGetTimestampResponse{})

func (msg *baseNetworkSocketWithCtxGetTimestampResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxGetTimestampResponse
}

type baseNetworkSocketWithCtxBindRequest 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 _mbaseNetworkSocketWithCtxBindRequest = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxBindRequest{})

func (msg *baseNetworkSocketWithCtxBindRequest) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxBindRequest
}

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

var _mbaseNetworkSocketWithCtxBindResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxBindResponse{})

func (msg *baseNetworkSocketWithCtxBindResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxBindResponse
}

type baseNetworkSocketWithCtxConnectRequest 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 _mbaseNetworkSocketWithCtxConnectRequest = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxConnectRequest{})

func (msg *baseNetworkSocketWithCtxConnectRequest) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxConnectRequest
}

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

var _mbaseNetworkSocketWithCtxConnectResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxConnectResponse{})

func (msg *baseNetworkSocketWithCtxConnectResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxConnectResponse
}

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

var _mbaseNetworkSocketWithCtxDisconnectResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxDisconnectResponse{})

func (msg *baseNetworkSocketWithCtxDisconnectResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxDisconnectResponse
}

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

var _mbaseNetworkSocketWithCtxGetSockNameResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxGetSockNameResponse{})

func (msg *baseNetworkSocketWithCtxGetSockNameResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxGetSockNameResponse
}

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

var _mbaseNetworkSocketWithCtxGetPeerNameResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxGetPeerNameResponse{})

func (msg *baseNetworkSocketWithCtxGetPeerNameResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxGetPeerNameResponse
}

type baseNetworkSocketWithCtxShutdownRequest 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 _mbaseNetworkSocketWithCtxShutdownRequest = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxShutdownRequest{})

func (msg *baseNetworkSocketWithCtxShutdownRequest) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxShutdownRequest
}

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

var _mbaseNetworkSocketWithCtxShutdownResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxShutdownResponse{})

func (msg *baseNetworkSocketWithCtxShutdownResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxShutdownResponse
}

type baseNetworkSocketWithCtxShutdown2Request 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 _mbaseNetworkSocketWithCtxShutdown2Request = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxShutdown2Request{})

func (msg *baseNetworkSocketWithCtxShutdown2Request) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxShutdown2Request
}

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

var _mbaseNetworkSocketWithCtxShutdown2Response = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxShutdown2Response{})

func (msg *baseNetworkSocketWithCtxShutdown2Response) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxShutdown2Response
}

type baseNetworkSocketWithCtxSetIpTypeOfServiceRequest 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 _mbaseNetworkSocketWithCtxSetIpTypeOfServiceRequest = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxSetIpTypeOfServiceRequest{})

func (msg *baseNetworkSocketWithCtxSetIpTypeOfServiceRequest) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxSetIpTypeOfServiceRequest
}

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

var _mbaseNetworkSocketWithCtxSetIpTypeOfServiceResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxSetIpTypeOfServiceResponse{})

func (msg *baseNetworkSocketWithCtxSetIpTypeOfServiceResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxSetIpTypeOfServiceResponse
}

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

var _mbaseNetworkSocketWithCtxGetIpTypeOfServiceResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxGetIpTypeOfServiceResponse{})

func (msg *baseNetworkSocketWithCtxGetIpTypeOfServiceResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxGetIpTypeOfServiceResponse
}

type baseNetworkSocketWithCtxSetIpTtlRequest 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 _mbaseNetworkSocketWithCtxSetIpTtlRequest = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxSetIpTtlRequest{})

func (msg *baseNetworkSocketWithCtxSetIpTtlRequest) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxSetIpTtlRequest
}

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

var _mbaseNetworkSocketWithCtxSetIpTtlResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxSetIpTtlResponse{})

func (msg *baseNetworkSocketWithCtxSetIpTtlResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxSetIpTtlResponse
}

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

var _mbaseNetworkSocketWithCtxGetIpTtlResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxGetIpTtlResponse{})

func (msg *baseNetworkSocketWithCtxGetIpTtlResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxGetIpTtlResponse
}

type baseNetworkSocketWithCtxSetIpPacketInfoRequest 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 _mbaseNetworkSocketWithCtxSetIpPacketInfoRequest = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxSetIpPacketInfoRequest{})

func (msg *baseNetworkSocketWithCtxSetIpPacketInfoRequest) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxSetIpPacketInfoRequest
}

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

var _mbaseNetworkSocketWithCtxSetIpPacketInfoResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxSetIpPacketInfoResponse{})

func (msg *baseNetworkSocketWithCtxSetIpPacketInfoResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxSetIpPacketInfoResponse
}

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

var _mbaseNetworkSocketWithCtxGetIpPacketInfoResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxGetIpPacketInfoResponse{})

func (msg *baseNetworkSocketWithCtxGetIpPacketInfoResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxGetIpPacketInfoResponse
}

type baseNetworkSocketWithCtxSetIpReceiveTypeOfServiceRequest 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 _mbaseNetworkSocketWithCtxSetIpReceiveTypeOfServiceRequest = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxSetIpReceiveTypeOfServiceRequest{})

func (msg *baseNetworkSocketWithCtxSetIpReceiveTypeOfServiceRequest) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxSetIpReceiveTypeOfServiceRequest
}

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

var _mbaseNetworkSocketWithCtxSetIpReceiveTypeOfServiceResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxSetIpReceiveTypeOfServiceResponse{})

func (msg *baseNetworkSocketWithCtxSetIpReceiveTypeOfServiceResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxSetIpReceiveTypeOfServiceResponse
}

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

var _mbaseNetworkSocketWithCtxGetIpReceiveTypeOfServiceResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxGetIpReceiveTypeOfServiceResponse{})

func (msg *baseNetworkSocketWithCtxGetIpReceiveTypeOfServiceResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxGetIpReceiveTypeOfServiceResponse
}

type baseNetworkSocketWithCtxSetIpMulticastInterfaceRequest 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 _mbaseNetworkSocketWithCtxSetIpMulticastInterfaceRequest = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxSetIpMulticastInterfaceRequest{})

func (msg *baseNetworkSocketWithCtxSetIpMulticastInterfaceRequest) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxSetIpMulticastInterfaceRequest
}

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

var _mbaseNetworkSocketWithCtxSetIpMulticastInterfaceResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxSetIpMulticastInterfaceResponse{})

func (msg *baseNetworkSocketWithCtxSetIpMulticastInterfaceResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxSetIpMulticastInterfaceResponse
}

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

var _mbaseNetworkSocketWithCtxGetIpMulticastInterfaceResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxGetIpMulticastInterfaceResponse{})

func (msg *baseNetworkSocketWithCtxGetIpMulticastInterfaceResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxGetIpMulticastInterfaceResponse
}

type baseNetworkSocketWithCtxSetIpMulticastTtlRequest 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 _mbaseNetworkSocketWithCtxSetIpMulticastTtlRequest = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxSetIpMulticastTtlRequest{})

func (msg *baseNetworkSocketWithCtxSetIpMulticastTtlRequest) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxSetIpMulticastTtlRequest
}

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

var _mbaseNetworkSocketWithCtxSetIpMulticastTtlResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxSetIpMulticastTtlResponse{})

func (msg *baseNetworkSocketWithCtxSetIpMulticastTtlResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxSetIpMulticastTtlResponse
}

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

var _mbaseNetworkSocketWithCtxGetIpMulticastTtlResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxGetIpMulticastTtlResponse{})

func (msg *baseNetworkSocketWithCtxGetIpMulticastTtlResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxGetIpMulticastTtlResponse
}

type baseNetworkSocketWithCtxSetIpMulticastLoopbackRequest 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 _mbaseNetworkSocketWithCtxSetIpMulticastLoopbackRequest = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxSetIpMulticastLoopbackRequest{})

func (msg *baseNetworkSocketWithCtxSetIpMulticastLoopbackRequest) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxSetIpMulticastLoopbackRequest
}

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

var _mbaseNetworkSocketWithCtxSetIpMulticastLoopbackResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxSetIpMulticastLoopbackResponse{})

func (msg *baseNetworkSocketWithCtxSetIpMulticastLoopbackResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxSetIpMulticastLoopbackResponse
}

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

var _mbaseNetworkSocketWithCtxGetIpMulticastLoopbackResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxGetIpMulticastLoopbackResponse{})

func (msg *baseNetworkSocketWithCtxGetIpMulticastLoopbackResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxGetIpMulticastLoopbackResponse
}

type baseNetworkSocketWithCtxAddIpMembershipRequest 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 _mbaseNetworkSocketWithCtxAddIpMembershipRequest = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxAddIpMembershipRequest{})

func (msg *baseNetworkSocketWithCtxAddIpMembershipRequest) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxAddIpMembershipRequest
}

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

var _mbaseNetworkSocketWithCtxAddIpMembershipResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxAddIpMembershipResponse{})

func (msg *baseNetworkSocketWithCtxAddIpMembershipResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxAddIpMembershipResponse
}

type baseNetworkSocketWithCtxDropIpMembershipRequest 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 _mbaseNetworkSocketWithCtxDropIpMembershipRequest = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxDropIpMembershipRequest{})

func (msg *baseNetworkSocketWithCtxDropIpMembershipRequest) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxDropIpMembershipRequest
}

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

var _mbaseNetworkSocketWithCtxDropIpMembershipResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxDropIpMembershipResponse{})

func (msg *baseNetworkSocketWithCtxDropIpMembershipResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxDropIpMembershipResponse
}

type baseNetworkSocketWithCtxAddIpv6MembershipRequest 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 _mbaseNetworkSocketWithCtxAddIpv6MembershipRequest = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxAddIpv6MembershipRequest{})

func (msg *baseNetworkSocketWithCtxAddIpv6MembershipRequest) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxAddIpv6MembershipRequest
}

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

var _mbaseNetworkSocketWithCtxAddIpv6MembershipResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxAddIpv6MembershipResponse{})

func (msg *baseNetworkSocketWithCtxAddIpv6MembershipResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxAddIpv6MembershipResponse
}

type baseNetworkSocketWithCtxDropIpv6MembershipRequest 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 _mbaseNetworkSocketWithCtxDropIpv6MembershipRequest = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxDropIpv6MembershipRequest{})

func (msg *baseNetworkSocketWithCtxDropIpv6MembershipRequest) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxDropIpv6MembershipRequest
}

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

var _mbaseNetworkSocketWithCtxDropIpv6MembershipResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxDropIpv6MembershipResponse{})

func (msg *baseNetworkSocketWithCtxDropIpv6MembershipResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxDropIpv6MembershipResponse
}

type baseNetworkSocketWithCtxSetIpv6MulticastInterfaceRequest 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 _mbaseNetworkSocketWithCtxSetIpv6MulticastInterfaceRequest = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxSetIpv6MulticastInterfaceRequest{})

func (msg *baseNetworkSocketWithCtxSetIpv6MulticastInterfaceRequest) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxSetIpv6MulticastInterfaceRequest
}

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

var _mbaseNetworkSocketWithCtxSetIpv6MulticastInterfaceResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxSetIpv6MulticastInterfaceResponse{})

func (msg *baseNetworkSocketWithCtxSetIpv6MulticastInterfaceResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxSetIpv6MulticastInterfaceResponse
}

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

var _mbaseNetworkSocketWithCtxGetIpv6MulticastInterfaceResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxGetIpv6MulticastInterfaceResponse{})

func (msg *baseNetworkSocketWithCtxGetIpv6MulticastInterfaceResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxGetIpv6MulticastInterfaceResponse
}

type baseNetworkSocketWithCtxSetIpv6MulticastHopsRequest 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 _mbaseNetworkSocketWithCtxSetIpv6MulticastHopsRequest = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxSetIpv6MulticastHopsRequest{})

func (msg *baseNetworkSocketWithCtxSetIpv6MulticastHopsRequest) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxSetIpv6MulticastHopsRequest
}

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

var _mbaseNetworkSocketWithCtxSetIpv6MulticastHopsResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxSetIpv6MulticastHopsResponse{})

func (msg *baseNetworkSocketWithCtxSetIpv6MulticastHopsResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxSetIpv6MulticastHopsResponse
}

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

var _mbaseNetworkSocketWithCtxGetIpv6MulticastHopsResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxGetIpv6MulticastHopsResponse{})

func (msg *baseNetworkSocketWithCtxGetIpv6MulticastHopsResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxGetIpv6MulticastHopsResponse
}

type baseNetworkSocketWithCtxSetIpv6MulticastLoopbackRequest 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 _mbaseNetworkSocketWithCtxSetIpv6MulticastLoopbackRequest = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxSetIpv6MulticastLoopbackRequest{})

func (msg *baseNetworkSocketWithCtxSetIpv6MulticastLoopbackRequest) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxSetIpv6MulticastLoopbackRequest
}

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

var _mbaseNetworkSocketWithCtxSetIpv6MulticastLoopbackResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxSetIpv6MulticastLoopbackResponse{})

func (msg *baseNetworkSocketWithCtxSetIpv6MulticastLoopbackResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxSetIpv6MulticastLoopbackResponse
}

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

var _mbaseNetworkSocketWithCtxGetIpv6MulticastLoopbackResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxGetIpv6MulticastLoopbackResponse{})

func (msg *baseNetworkSocketWithCtxGetIpv6MulticastLoopbackResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxGetIpv6MulticastLoopbackResponse
}

type baseNetworkSocketWithCtxSetIpv6OnlyRequest 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 _mbaseNetworkSocketWithCtxSetIpv6OnlyRequest = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxSetIpv6OnlyRequest{})

func (msg *baseNetworkSocketWithCtxSetIpv6OnlyRequest) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxSetIpv6OnlyRequest
}

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

var _mbaseNetworkSocketWithCtxSetIpv6OnlyResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxSetIpv6OnlyResponse{})

func (msg *baseNetworkSocketWithCtxSetIpv6OnlyResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxSetIpv6OnlyResponse
}

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

var _mbaseNetworkSocketWithCtxGetIpv6OnlyResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxGetIpv6OnlyResponse{})

func (msg *baseNetworkSocketWithCtxGetIpv6OnlyResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxGetIpv6OnlyResponse
}

type baseNetworkSocketWithCtxSetIpv6ReceiveTrafficClassRequest 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 _mbaseNetworkSocketWithCtxSetIpv6ReceiveTrafficClassRequest = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxSetIpv6ReceiveTrafficClassRequest{})

func (msg *baseNetworkSocketWithCtxSetIpv6ReceiveTrafficClassRequest) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxSetIpv6ReceiveTrafficClassRequest
}

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

var _mbaseNetworkSocketWithCtxSetIpv6ReceiveTrafficClassResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxSetIpv6ReceiveTrafficClassResponse{})

func (msg *baseNetworkSocketWithCtxSetIpv6ReceiveTrafficClassResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxSetIpv6ReceiveTrafficClassResponse
}

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

var _mbaseNetworkSocketWithCtxGetIpv6ReceiveTrafficClassResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxGetIpv6ReceiveTrafficClassResponse{})

func (msg *baseNetworkSocketWithCtxGetIpv6ReceiveTrafficClassResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxGetIpv6ReceiveTrafficClassResponse
}

type baseNetworkSocketWithCtxSetIpv6TrafficClassRequest 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 _mbaseNetworkSocketWithCtxSetIpv6TrafficClassRequest = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxSetIpv6TrafficClassRequest{})

func (msg *baseNetworkSocketWithCtxSetIpv6TrafficClassRequest) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxSetIpv6TrafficClassRequest
}

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

var _mbaseNetworkSocketWithCtxSetIpv6TrafficClassResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxSetIpv6TrafficClassResponse{})

func (msg *baseNetworkSocketWithCtxSetIpv6TrafficClassResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxSetIpv6TrafficClassResponse
}

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

var _mbaseNetworkSocketWithCtxGetIpv6TrafficClassResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxGetIpv6TrafficClassResponse{})

func (msg *baseNetworkSocketWithCtxGetIpv6TrafficClassResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxGetIpv6TrafficClassResponse
}

type baseNetworkSocketWithCtxBaseSocketBindRequest 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 _mbaseNetworkSocketWithCtxBaseSocketBindRequest = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxBaseSocketBindRequest{})

func (msg *baseNetworkSocketWithCtxBaseSocketBindRequest) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxBaseSocketBindRequest
}

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

var _mbaseNetworkSocketWithCtxBaseSocketBindResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxBaseSocketBindResponse{})

func (msg *baseNetworkSocketWithCtxBaseSocketBindResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxBaseSocketBindResponse
}

type baseNetworkSocketWithCtxBaseSocketConnectRequest 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 _mbaseNetworkSocketWithCtxBaseSocketConnectRequest = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxBaseSocketConnectRequest{})

func (msg *baseNetworkSocketWithCtxBaseSocketConnectRequest) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxBaseSocketConnectRequest
}

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

var _mbaseNetworkSocketWithCtxBaseSocketConnectResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxBaseSocketConnectResponse{})

func (msg *baseNetworkSocketWithCtxBaseSocketConnectResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxBaseSocketConnectResponse
}

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

var _mbaseNetworkSocketWithCtxBaseSocketDisconnectResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxBaseSocketDisconnectResponse{})

func (msg *baseNetworkSocketWithCtxBaseSocketDisconnectResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxBaseSocketDisconnectResponse
}

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

var _mbaseNetworkSocketWithCtxBaseSocketGetSockNameResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxBaseSocketGetSockNameResponse{})

func (msg *baseNetworkSocketWithCtxBaseSocketGetSockNameResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxBaseSocketGetSockNameResponse
}

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

var _mbaseNetworkSocketWithCtxBaseSocketGetPeerNameResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxBaseSocketGetPeerNameResponse{})

func (msg *baseNetworkSocketWithCtxBaseSocketGetPeerNameResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxBaseSocketGetPeerNameResponse
}

type baseNetworkSocketWithCtxBaseSocketShutdownRequest 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 _mbaseNetworkSocketWithCtxBaseSocketShutdownRequest = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxBaseSocketShutdownRequest{})

func (msg *baseNetworkSocketWithCtxBaseSocketShutdownRequest) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxBaseSocketShutdownRequest
}

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

var _mbaseNetworkSocketWithCtxBaseSocketShutdownResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxBaseSocketShutdownResponse{})

func (msg *baseNetworkSocketWithCtxBaseSocketShutdownResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxBaseSocketShutdownResponse
}

type baseNetworkSocketWithCtxBaseSocketShutdown2Request 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 _mbaseNetworkSocketWithCtxBaseSocketShutdown2Request = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxBaseSocketShutdown2Request{})

func (msg *baseNetworkSocketWithCtxBaseSocketShutdown2Request) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxBaseSocketShutdown2Request
}

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

var _mbaseNetworkSocketWithCtxBaseSocketShutdown2Response = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxBaseSocketShutdown2Response{})

func (msg *baseNetworkSocketWithCtxBaseSocketShutdown2Response) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxBaseSocketShutdown2Response
}

type baseNetworkSocketWithCtxBaseSocketSetIpTypeOfServiceRequest 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 _mbaseNetworkSocketWithCtxBaseSocketSetIpTypeOfServiceRequest = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxBaseSocketSetIpTypeOfServiceRequest{})

func (msg *baseNetworkSocketWithCtxBaseSocketSetIpTypeOfServiceRequest) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxBaseSocketSetIpTypeOfServiceRequest
}

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

var _mbaseNetworkSocketWithCtxBaseSocketSetIpTypeOfServiceResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxBaseSocketSetIpTypeOfServiceResponse{})

func (msg *baseNetworkSocketWithCtxBaseSocketSetIpTypeOfServiceResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxBaseSocketSetIpTypeOfServiceResponse
}

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

var _mbaseNetworkSocketWithCtxBaseSocketGetIpTypeOfServiceResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxBaseSocketGetIpTypeOfServiceResponse{})

func (msg *baseNetworkSocketWithCtxBaseSocketGetIpTypeOfServiceResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxBaseSocketGetIpTypeOfServiceResponse
}

type baseNetworkSocketWithCtxBaseSocketSetIpTtlRequest 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 _mbaseNetworkSocketWithCtxBaseSocketSetIpTtlRequest = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxBaseSocketSetIpTtlRequest{})

func (msg *baseNetworkSocketWithCtxBaseSocketSetIpTtlRequest) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxBaseSocketSetIpTtlRequest
}

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

var _mbaseNetworkSocketWithCtxBaseSocketSetIpTtlResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxBaseSocketSetIpTtlResponse{})

func (msg *baseNetworkSocketWithCtxBaseSocketSetIpTtlResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxBaseSocketSetIpTtlResponse
}

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

var _mbaseNetworkSocketWithCtxBaseSocketGetIpTtlResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxBaseSocketGetIpTtlResponse{})

func (msg *baseNetworkSocketWithCtxBaseSocketGetIpTtlResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxBaseSocketGetIpTtlResponse
}

type baseNetworkSocketWithCtxBaseSocketSetIpPacketInfoRequest 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 _mbaseNetworkSocketWithCtxBaseSocketSetIpPacketInfoRequest = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxBaseSocketSetIpPacketInfoRequest{})

func (msg *baseNetworkSocketWithCtxBaseSocketSetIpPacketInfoRequest) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxBaseSocketSetIpPacketInfoRequest
}

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

var _mbaseNetworkSocketWithCtxBaseSocketSetIpPacketInfoResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxBaseSocketSetIpPacketInfoResponse{})

func (msg *baseNetworkSocketWithCtxBaseSocketSetIpPacketInfoResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxBaseSocketSetIpPacketInfoResponse
}

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

var _mbaseNetworkSocketWithCtxBaseSocketGetIpPacketInfoResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxBaseSocketGetIpPacketInfoResponse{})

func (msg *baseNetworkSocketWithCtxBaseSocketGetIpPacketInfoResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxBaseSocketGetIpPacketInfoResponse
}

type baseNetworkSocketWithCtxBaseSocketSetIpReceiveTypeOfServiceRequest 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 _mbaseNetworkSocketWithCtxBaseSocketSetIpReceiveTypeOfServiceRequest = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxBaseSocketSetIpReceiveTypeOfServiceRequest{})

func (msg *baseNetworkSocketWithCtxBaseSocketSetIpReceiveTypeOfServiceRequest) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxBaseSocketSetIpReceiveTypeOfServiceRequest
}

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

var _mbaseNetworkSocketWithCtxBaseSocketSetIpReceiveTypeOfServiceResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxBaseSocketSetIpReceiveTypeOfServiceResponse{})

func (msg *baseNetworkSocketWithCtxBaseSocketSetIpReceiveTypeOfServiceResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxBaseSocketSetIpReceiveTypeOfServiceResponse
}

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

var _mbaseNetworkSocketWithCtxBaseSocketGetIpReceiveTypeOfServiceResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxBaseSocketGetIpReceiveTypeOfServiceResponse{})

func (msg *baseNetworkSocketWithCtxBaseSocketGetIpReceiveTypeOfServiceResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxBaseSocketGetIpReceiveTypeOfServiceResponse
}

type baseNetworkSocketWithCtxBaseSocketSetIpMulticastInterfaceRequest 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 _mbaseNetworkSocketWithCtxBaseSocketSetIpMulticastInterfaceRequest = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxBaseSocketSetIpMulticastInterfaceRequest{})

func (msg *baseNetworkSocketWithCtxBaseSocketSetIpMulticastInterfaceRequest) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxBaseSocketSetIpMulticastInterfaceRequest
}

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

var _mbaseNetworkSocketWithCtxBaseSocketSetIpMulticastInterfaceResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxBaseSocketSetIpMulticastInterfaceResponse{})

func (msg *baseNetworkSocketWithCtxBaseSocketSetIpMulticastInterfaceResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxBaseSocketSetIpMulticastInterfaceResponse
}

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

var _mbaseNetworkSocketWithCtxBaseSocketGetIpMulticastInterfaceResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxBaseSocketGetIpMulticastInterfaceResponse{})

func (msg *baseNetworkSocketWithCtxBaseSocketGetIpMulticastInterfaceResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxBaseSocketGetIpMulticastInterfaceResponse
}

type baseNetworkSocketWithCtxBaseSocketSetIpMulticastTtlRequest 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 _mbaseNetworkSocketWithCtxBaseSocketSetIpMulticastTtlRequest = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxBaseSocketSetIpMulticastTtlRequest{})

func (msg *baseNetworkSocketWithCtxBaseSocketSetIpMulticastTtlRequest) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxBaseSocketSetIpMulticastTtlRequest
}

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

var _mbaseNetworkSocketWithCtxBaseSocketSetIpMulticastTtlResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxBaseSocketSetIpMulticastTtlResponse{})

func (msg *baseNetworkSocketWithCtxBaseSocketSetIpMulticastTtlResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxBaseSocketSetIpMulticastTtlResponse
}

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

var _mbaseNetworkSocketWithCtxBaseSocketGetIpMulticastTtlResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxBaseSocketGetIpMulticastTtlResponse{})

func (msg *baseNetworkSocketWithCtxBaseSocketGetIpMulticastTtlResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxBaseSocketGetIpMulticastTtlResponse
}

type baseNetworkSocketWithCtxBaseSocketSetIpMulticastLoopbackRequest 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 _mbaseNetworkSocketWithCtxBaseSocketSetIpMulticastLoopbackRequest = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxBaseSocketSetIpMulticastLoopbackRequest{})

func (msg *baseNetworkSocketWithCtxBaseSocketSetIpMulticastLoopbackRequest) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxBaseSocketSetIpMulticastLoopbackRequest
}

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

var _mbaseNetworkSocketWithCtxBaseSocketSetIpMulticastLoopbackResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxBaseSocketSetIpMulticastLoopbackResponse{})

func (msg *baseNetworkSocketWithCtxBaseSocketSetIpMulticastLoopbackResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxBaseSocketSetIpMulticastLoopbackResponse
}

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

var _mbaseNetworkSocketWithCtxBaseSocketGetIpMulticastLoopbackResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxBaseSocketGetIpMulticastLoopbackResponse{})

func (msg *baseNetworkSocketWithCtxBaseSocketGetIpMulticastLoopbackResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxBaseSocketGetIpMulticastLoopbackResponse
}

type baseNetworkSocketWithCtxBaseSocketAddIpMembershipRequest 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 _mbaseNetworkSocketWithCtxBaseSocketAddIpMembershipRequest = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxBaseSocketAddIpMembershipRequest{})

func (msg *baseNetworkSocketWithCtxBaseSocketAddIpMembershipRequest) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxBaseSocketAddIpMembershipRequest
}

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

var _mbaseNetworkSocketWithCtxBaseSocketAddIpMembershipResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxBaseSocketAddIpMembershipResponse{})

func (msg *baseNetworkSocketWithCtxBaseSocketAddIpMembershipResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxBaseSocketAddIpMembershipResponse
}

type baseNetworkSocketWithCtxBaseSocketDropIpMembershipRequest 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 _mbaseNetworkSocketWithCtxBaseSocketDropIpMembershipRequest = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxBaseSocketDropIpMembershipRequest{})

func (msg *baseNetworkSocketWithCtxBaseSocketDropIpMembershipRequest) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxBaseSocketDropIpMembershipRequest
}

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

var _mbaseNetworkSocketWithCtxBaseSocketDropIpMembershipResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxBaseSocketDropIpMembershipResponse{})

func (msg *baseNetworkSocketWithCtxBaseSocketDropIpMembershipResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxBaseSocketDropIpMembershipResponse
}

type baseNetworkSocketWithCtxBaseSocketAddIpv6MembershipRequest 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 _mbaseNetworkSocketWithCtxBaseSocketAddIpv6MembershipRequest = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxBaseSocketAddIpv6MembershipRequest{})

func (msg *baseNetworkSocketWithCtxBaseSocketAddIpv6MembershipRequest) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxBaseSocketAddIpv6MembershipRequest
}

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

var _mbaseNetworkSocketWithCtxBaseSocketAddIpv6MembershipResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxBaseSocketAddIpv6MembershipResponse{})

func (msg *baseNetworkSocketWithCtxBaseSocketAddIpv6MembershipResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxBaseSocketAddIpv6MembershipResponse
}

type baseNetworkSocketWithCtxBaseSocketDropIpv6MembershipRequest 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 _mbaseNetworkSocketWithCtxBaseSocketDropIpv6MembershipRequest = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxBaseSocketDropIpv6MembershipRequest{})

func (msg *baseNetworkSocketWithCtxBaseSocketDropIpv6MembershipRequest) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxBaseSocketDropIpv6MembershipRequest
}

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

var _mbaseNetworkSocketWithCtxBaseSocketDropIpv6MembershipResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxBaseSocketDropIpv6MembershipResponse{})

func (msg *baseNetworkSocketWithCtxBaseSocketDropIpv6MembershipResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxBaseSocketDropIpv6MembershipResponse
}

type baseNetworkSocketWithCtxBaseSocketSetIpv6MulticastInterfaceRequest 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 _mbaseNetworkSocketWithCtxBaseSocketSetIpv6MulticastInterfaceRequest = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxBaseSocketSetIpv6MulticastInterfaceRequest{})

func (msg *baseNetworkSocketWithCtxBaseSocketSetIpv6MulticastInterfaceRequest) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxBaseSocketSetIpv6MulticastInterfaceRequest
}

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

var _mbaseNetworkSocketWithCtxBaseSocketSetIpv6MulticastInterfaceResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxBaseSocketSetIpv6MulticastInterfaceResponse{})

func (msg *baseNetworkSocketWithCtxBaseSocketSetIpv6MulticastInterfaceResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxBaseSocketSetIpv6MulticastInterfaceResponse
}

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

var _mbaseNetworkSocketWithCtxBaseSocketGetIpv6MulticastInterfaceResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxBaseSocketGetIpv6MulticastInterfaceResponse{})

func (msg *baseNetworkSocketWithCtxBaseSocketGetIpv6MulticastInterfaceResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxBaseSocketGetIpv6MulticastInterfaceResponse
}

type baseNetworkSocketWithCtxBaseSocketSetIpv6MulticastHopsRequest 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 _mbaseNetworkSocketWithCtxBaseSocketSetIpv6MulticastHopsRequest = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxBaseSocketSetIpv6MulticastHopsRequest{})

func (msg *baseNetworkSocketWithCtxBaseSocketSetIpv6MulticastHopsRequest) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxBaseSocketSetIpv6MulticastHopsRequest
}

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

var _mbaseNetworkSocketWithCtxBaseSocketSetIpv6MulticastHopsResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxBaseSocketSetIpv6MulticastHopsResponse{})

func (msg *baseNetworkSocketWithCtxBaseSocketSetIpv6MulticastHopsResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxBaseSocketSetIpv6MulticastHopsResponse
}

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

var _mbaseNetworkSocketWithCtxBaseSocketGetIpv6MulticastHopsResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxBaseSocketGetIpv6MulticastHopsResponse{})

func (msg *baseNetworkSocketWithCtxBaseSocketGetIpv6MulticastHopsResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxBaseSocketGetIpv6MulticastHopsResponse
}

type baseNetworkSocketWithCtxBaseSocketSetIpv6MulticastLoopbackRequest 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 _mbaseNetworkSocketWithCtxBaseSocketSetIpv6MulticastLoopbackRequest = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxBaseSocketSetIpv6MulticastLoopbackRequest{})

func (msg *baseNetworkSocketWithCtxBaseSocketSetIpv6MulticastLoopbackRequest) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxBaseSocketSetIpv6MulticastLoopbackRequest
}

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

var _mbaseNetworkSocketWithCtxBaseSocketSetIpv6MulticastLoopbackResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxBaseSocketSetIpv6MulticastLoopbackResponse{})

func (msg *baseNetworkSocketWithCtxBaseSocketSetIpv6MulticastLoopbackResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxBaseSocketSetIpv6MulticastLoopbackResponse
}

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

var _mbaseNetworkSocketWithCtxBaseSocketGetIpv6MulticastLoopbackResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxBaseSocketGetIpv6MulticastLoopbackResponse{})

func (msg *baseNetworkSocketWithCtxBaseSocketGetIpv6MulticastLoopbackResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxBaseSocketGetIpv6MulticastLoopbackResponse
}

type baseNetworkSocketWithCtxBaseSocketSetIpv6OnlyRequest 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 _mbaseNetworkSocketWithCtxBaseSocketSetIpv6OnlyRequest = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxBaseSocketSetIpv6OnlyRequest{})

func (msg *baseNetworkSocketWithCtxBaseSocketSetIpv6OnlyRequest) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxBaseSocketSetIpv6OnlyRequest
}

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

var _mbaseNetworkSocketWithCtxBaseSocketSetIpv6OnlyResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxBaseSocketSetIpv6OnlyResponse{})

func (msg *baseNetworkSocketWithCtxBaseSocketSetIpv6OnlyResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxBaseSocketSetIpv6OnlyResponse
}

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

var _mbaseNetworkSocketWithCtxBaseSocketGetIpv6OnlyResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxBaseSocketGetIpv6OnlyResponse{})

func (msg *baseNetworkSocketWithCtxBaseSocketGetIpv6OnlyResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxBaseSocketGetIpv6OnlyResponse
}

type baseNetworkSocketWithCtxBaseSocketSetIpv6ReceiveTrafficClassRequest 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 _mbaseNetworkSocketWithCtxBaseSocketSetIpv6ReceiveTrafficClassRequest = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxBaseSocketSetIpv6ReceiveTrafficClassRequest{})

func (msg *baseNetworkSocketWithCtxBaseSocketSetIpv6ReceiveTrafficClassRequest) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxBaseSocketSetIpv6ReceiveTrafficClassRequest
}

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

var _mbaseNetworkSocketWithCtxBaseSocketSetIpv6ReceiveTrafficClassResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxBaseSocketSetIpv6ReceiveTrafficClassResponse{})

func (msg *baseNetworkSocketWithCtxBaseSocketSetIpv6ReceiveTrafficClassResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxBaseSocketSetIpv6ReceiveTrafficClassResponse
}

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

var _mbaseNetworkSocketWithCtxBaseSocketGetIpv6ReceiveTrafficClassResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxBaseSocketGetIpv6ReceiveTrafficClassResponse{})

func (msg *baseNetworkSocketWithCtxBaseSocketGetIpv6ReceiveTrafficClassResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxBaseSocketGetIpv6ReceiveTrafficClassResponse
}

type baseNetworkSocketWithCtxBaseSocketSetIpv6TrafficClassRequest 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 _mbaseNetworkSocketWithCtxBaseSocketSetIpv6TrafficClassRequest = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxBaseSocketSetIpv6TrafficClassRequest{})

func (msg *baseNetworkSocketWithCtxBaseSocketSetIpv6TrafficClassRequest) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxBaseSocketSetIpv6TrafficClassRequest
}

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

var _mbaseNetworkSocketWithCtxBaseSocketSetIpv6TrafficClassResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxBaseSocketSetIpv6TrafficClassResponse{})

func (msg *baseNetworkSocketWithCtxBaseSocketSetIpv6TrafficClassResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxBaseSocketSetIpv6TrafficClassResponse
}

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

var _mbaseNetworkSocketWithCtxBaseSocketGetIpv6TrafficClassResponse = _bindings.CreateLazyMarshaler(baseNetworkSocketWithCtxBaseSocketGetIpv6TrafficClassResponse{})

func (msg *baseNetworkSocketWithCtxBaseSocketGetIpv6TrafficClassResponse) Marshaler() _bindings.Marshaler {
	return _mbaseNetworkSocketWithCtxBaseSocketGetIpv6TrafficClassResponse
}

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 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 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 BaseNetworkSocketBindResult `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 BaseNetworkSocketConnectResult `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 BaseNetworkSocketDisconnectResult `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 BaseNetworkSocketGetSockNameResult `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 BaseNetworkSocketGetPeerNameResult `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 BaseNetworkSocketShutdownResult `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 BaseNetworkSocketShutdown2Result `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxShutdown2Response = _bindings.CreateLazyMarshaler(datagramSocketWithCtxShutdown2Response{})

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

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 BaseNetworkSocketSetIpTypeOfServiceResult `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 BaseNetworkSocketGetIpTypeOfServiceResult `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 BaseNetworkSocketSetIpTtlResult `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 BaseNetworkSocketGetIpTtlResult `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 BaseNetworkSocketSetIpPacketInfoResult `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 BaseNetworkSocketGetIpPacketInfoResult `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 BaseNetworkSocketSetIpReceiveTypeOfServiceResult `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 BaseNetworkSocketGetIpReceiveTypeOfServiceResult `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 BaseNetworkSocketSetIpMulticastInterfaceResult `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 BaseNetworkSocketGetIpMulticastInterfaceResult `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 BaseNetworkSocketSetIpMulticastTtlResult `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 BaseNetworkSocketGetIpMulticastTtlResult `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 BaseNetworkSocketSetIpMulticastLoopbackResult `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 BaseNetworkSocketGetIpMulticastLoopbackResult `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 BaseNetworkSocketAddIpMembershipResult `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 BaseNetworkSocketDropIpMembershipResult `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 BaseNetworkSocketAddIpv6MembershipResult `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 BaseNetworkSocketDropIpv6MembershipResult `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 BaseNetworkSocketSetIpv6MulticastInterfaceResult `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 BaseNetworkSocketGetIpv6MulticastInterfaceResult `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 BaseNetworkSocketSetIpv6MulticastHopsResult `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 BaseNetworkSocketGetIpv6MulticastHopsResult `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 BaseNetworkSocketSetIpv6MulticastLoopbackResult `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 BaseNetworkSocketGetIpv6MulticastLoopbackResult `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 BaseNetworkSocketSetIpv6OnlyResult `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 BaseNetworkSocketGetIpv6OnlyResult `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 BaseNetworkSocketSetIpv6ReceiveTrafficClassResult `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 BaseNetworkSocketGetIpv6ReceiveTrafficClassResult `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 BaseNetworkSocketSetIpv6TrafficClassResult `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 BaseNetworkSocketGetIpv6TrafficClassResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mdatagramSocketWithCtxGetIpv6TrafficClassResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxGetIpv6TrafficClassResponse{})

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

type datagramSocketWithCtxBaseSocketBindRequest 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 _mdatagramSocketWithCtxBaseSocketBindRequest = _bindings.CreateLazyMarshaler(datagramSocketWithCtxBaseSocketBindRequest{})

func (msg *datagramSocketWithCtxBaseSocketBindRequest) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxBaseSocketBindRequest
}

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

var _mdatagramSocketWithCtxBaseSocketBindResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxBaseSocketBindResponse{})

func (msg *datagramSocketWithCtxBaseSocketBindResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxBaseSocketBindResponse
}

type datagramSocketWithCtxBaseSocketConnectRequest 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 _mdatagramSocketWithCtxBaseSocketConnectRequest = _bindings.CreateLazyMarshaler(datagramSocketWithCtxBaseSocketConnectRequest{})

func (msg *datagramSocketWithCtxBaseSocketConnectRequest) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxBaseSocketConnectRequest
}

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

var _mdatagramSocketWithCtxBaseSocketConnectResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxBaseSocketConnectResponse{})

func (msg *datagramSocketWithCtxBaseSocketConnectResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxBaseSocketConnectResponse
}

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

var _mdatagramSocketWithCtxBaseSocketDisconnectResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxBaseSocketDisconnectResponse{})

func (msg *datagramSocketWithCtxBaseSocketDisconnectResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxBaseSocketDisconnectResponse
}

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

var _mdatagramSocketWithCtxBaseSocketGetSockNameResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxBaseSocketGetSockNameResponse{})

func (msg *datagramSocketWithCtxBaseSocketGetSockNameResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxBaseSocketGetSockNameResponse
}

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

var _mdatagramSocketWithCtxBaseSocketGetPeerNameResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxBaseSocketGetPeerNameResponse{})

func (msg *datagramSocketWithCtxBaseSocketGetPeerNameResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxBaseSocketGetPeerNameResponse
}

type datagramSocketWithCtxBaseSocketShutdownRequest 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 _mdatagramSocketWithCtxBaseSocketShutdownRequest = _bindings.CreateLazyMarshaler(datagramSocketWithCtxBaseSocketShutdownRequest{})

func (msg *datagramSocketWithCtxBaseSocketShutdownRequest) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxBaseSocketShutdownRequest
}

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

var _mdatagramSocketWithCtxBaseSocketShutdownResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxBaseSocketShutdownResponse{})

func (msg *datagramSocketWithCtxBaseSocketShutdownResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxBaseSocketShutdownResponse
}

type datagramSocketWithCtxBaseSocketShutdown2Request 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 _mdatagramSocketWithCtxBaseSocketShutdown2Request = _bindings.CreateLazyMarshaler(datagramSocketWithCtxBaseSocketShutdown2Request{})

func (msg *datagramSocketWithCtxBaseSocketShutdown2Request) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxBaseSocketShutdown2Request
}

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

var _mdatagramSocketWithCtxBaseSocketShutdown2Response = _bindings.CreateLazyMarshaler(datagramSocketWithCtxBaseSocketShutdown2Response{})

func (msg *datagramSocketWithCtxBaseSocketShutdown2Response) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxBaseSocketShutdown2Response
}

type datagramSocketWithCtxBaseSocketSetIpTypeOfServiceRequest 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 _mdatagramSocketWithCtxBaseSocketSetIpTypeOfServiceRequest = _bindings.CreateLazyMarshaler(datagramSocketWithCtxBaseSocketSetIpTypeOfServiceRequest{})

func (msg *datagramSocketWithCtxBaseSocketSetIpTypeOfServiceRequest) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxBaseSocketSetIpTypeOfServiceRequest
}

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

var _mdatagramSocketWithCtxBaseSocketSetIpTypeOfServiceResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxBaseSocketSetIpTypeOfServiceResponse{})

func (msg *datagramSocketWithCtxBaseSocketSetIpTypeOfServiceResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxBaseSocketSetIpTypeOfServiceResponse
}

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

var _mdatagramSocketWithCtxBaseSocketGetIpTypeOfServiceResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxBaseSocketGetIpTypeOfServiceResponse{})

func (msg *datagramSocketWithCtxBaseSocketGetIpTypeOfServiceResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxBaseSocketGetIpTypeOfServiceResponse
}

type datagramSocketWithCtxBaseSocketSetIpTtlRequest 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 _mdatagramSocketWithCtxBaseSocketSetIpTtlRequest = _bindings.CreateLazyMarshaler(datagramSocketWithCtxBaseSocketSetIpTtlRequest{})

func (msg *datagramSocketWithCtxBaseSocketSetIpTtlRequest) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxBaseSocketSetIpTtlRequest
}

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

var _mdatagramSocketWithCtxBaseSocketSetIpTtlResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxBaseSocketSetIpTtlResponse{})

func (msg *datagramSocketWithCtxBaseSocketSetIpTtlResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxBaseSocketSetIpTtlResponse
}

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

var _mdatagramSocketWithCtxBaseSocketGetIpTtlResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxBaseSocketGetIpTtlResponse{})

func (msg *datagramSocketWithCtxBaseSocketGetIpTtlResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxBaseSocketGetIpTtlResponse
}

type datagramSocketWithCtxBaseSocketSetIpPacketInfoRequest 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 _mdatagramSocketWithCtxBaseSocketSetIpPacketInfoRequest = _bindings.CreateLazyMarshaler(datagramSocketWithCtxBaseSocketSetIpPacketInfoRequest{})

func (msg *datagramSocketWithCtxBaseSocketSetIpPacketInfoRequest) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxBaseSocketSetIpPacketInfoRequest
}

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

var _mdatagramSocketWithCtxBaseSocketSetIpPacketInfoResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxBaseSocketSetIpPacketInfoResponse{})

func (msg *datagramSocketWithCtxBaseSocketSetIpPacketInfoResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxBaseSocketSetIpPacketInfoResponse
}

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

var _mdatagramSocketWithCtxBaseSocketGetIpPacketInfoResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxBaseSocketGetIpPacketInfoResponse{})

func (msg *datagramSocketWithCtxBaseSocketGetIpPacketInfoResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxBaseSocketGetIpPacketInfoResponse
}

type datagramSocketWithCtxBaseSocketSetIpReceiveTypeOfServiceRequest 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 _mdatagramSocketWithCtxBaseSocketSetIpReceiveTypeOfServiceRequest = _bindings.CreateLazyMarshaler(datagramSocketWithCtxBaseSocketSetIpReceiveTypeOfServiceRequest{})

func (msg *datagramSocketWithCtxBaseSocketSetIpReceiveTypeOfServiceRequest) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxBaseSocketSetIpReceiveTypeOfServiceRequest
}

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

var _mdatagramSocketWithCtxBaseSocketSetIpReceiveTypeOfServiceResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxBaseSocketSetIpReceiveTypeOfServiceResponse{})

func (msg *datagramSocketWithCtxBaseSocketSetIpReceiveTypeOfServiceResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxBaseSocketSetIpReceiveTypeOfServiceResponse
}

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

var _mdatagramSocketWithCtxBaseSocketGetIpReceiveTypeOfServiceResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxBaseSocketGetIpReceiveTypeOfServiceResponse{})

func (msg *datagramSocketWithCtxBaseSocketGetIpReceiveTypeOfServiceResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxBaseSocketGetIpReceiveTypeOfServiceResponse
}

type datagramSocketWithCtxBaseSocketSetIpMulticastInterfaceRequest 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 _mdatagramSocketWithCtxBaseSocketSetIpMulticastInterfaceRequest = _bindings.CreateLazyMarshaler(datagramSocketWithCtxBaseSocketSetIpMulticastInterfaceRequest{})

func (msg *datagramSocketWithCtxBaseSocketSetIpMulticastInterfaceRequest) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxBaseSocketSetIpMulticastInterfaceRequest
}

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

var _mdatagramSocketWithCtxBaseSocketSetIpMulticastInterfaceResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxBaseSocketSetIpMulticastInterfaceResponse{})

func (msg *datagramSocketWithCtxBaseSocketSetIpMulticastInterfaceResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxBaseSocketSetIpMulticastInterfaceResponse
}

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

var _mdatagramSocketWithCtxBaseSocketGetIpMulticastInterfaceResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxBaseSocketGetIpMulticastInterfaceResponse{})

func (msg *datagramSocketWithCtxBaseSocketGetIpMulticastInterfaceResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxBaseSocketGetIpMulticastInterfaceResponse
}

type datagramSocketWithCtxBaseSocketSetIpMulticastTtlRequest 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 _mdatagramSocketWithCtxBaseSocketSetIpMulticastTtlRequest = _bindings.CreateLazyMarshaler(datagramSocketWithCtxBaseSocketSetIpMulticastTtlRequest{})

func (msg *datagramSocketWithCtxBaseSocketSetIpMulticastTtlRequest) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxBaseSocketSetIpMulticastTtlRequest
}

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

var _mdatagramSocketWithCtxBaseSocketSetIpMulticastTtlResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxBaseSocketSetIpMulticastTtlResponse{})

func (msg *datagramSocketWithCtxBaseSocketSetIpMulticastTtlResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxBaseSocketSetIpMulticastTtlResponse
}

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

var _mdatagramSocketWithCtxBaseSocketGetIpMulticastTtlResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxBaseSocketGetIpMulticastTtlResponse{})

func (msg *datagramSocketWithCtxBaseSocketGetIpMulticastTtlResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxBaseSocketGetIpMulticastTtlResponse
}

type datagramSocketWithCtxBaseSocketSetIpMulticastLoopbackRequest 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 _mdatagramSocketWithCtxBaseSocketSetIpMulticastLoopbackRequest = _bindings.CreateLazyMarshaler(datagramSocketWithCtxBaseSocketSetIpMulticastLoopbackRequest{})

func (msg *datagramSocketWithCtxBaseSocketSetIpMulticastLoopbackRequest) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxBaseSocketSetIpMulticastLoopbackRequest
}

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

var _mdatagramSocketWithCtxBaseSocketSetIpMulticastLoopbackResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxBaseSocketSetIpMulticastLoopbackResponse{})

func (msg *datagramSocketWithCtxBaseSocketSetIpMulticastLoopbackResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxBaseSocketSetIpMulticastLoopbackResponse
}

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

var _mdatagramSocketWithCtxBaseSocketGetIpMulticastLoopbackResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxBaseSocketGetIpMulticastLoopbackResponse{})

func (msg *datagramSocketWithCtxBaseSocketGetIpMulticastLoopbackResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxBaseSocketGetIpMulticastLoopbackResponse
}

type datagramSocketWithCtxBaseSocketAddIpMembershipRequest 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 _mdatagramSocketWithCtxBaseSocketAddIpMembershipRequest = _bindings.CreateLazyMarshaler(datagramSocketWithCtxBaseSocketAddIpMembershipRequest{})

func (msg *datagramSocketWithCtxBaseSocketAddIpMembershipRequest) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxBaseSocketAddIpMembershipRequest
}

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

var _mdatagramSocketWithCtxBaseSocketAddIpMembershipResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxBaseSocketAddIpMembershipResponse{})

func (msg *datagramSocketWithCtxBaseSocketAddIpMembershipResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxBaseSocketAddIpMembershipResponse
}

type datagramSocketWithCtxBaseSocketDropIpMembershipRequest 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 _mdatagramSocketWithCtxBaseSocketDropIpMembershipRequest = _bindings.CreateLazyMarshaler(datagramSocketWithCtxBaseSocketDropIpMembershipRequest{})

func (msg *datagramSocketWithCtxBaseSocketDropIpMembershipRequest) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxBaseSocketDropIpMembershipRequest
}

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

var _mdatagramSocketWithCtxBaseSocketDropIpMembershipResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxBaseSocketDropIpMembershipResponse{})

func (msg *datagramSocketWithCtxBaseSocketDropIpMembershipResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxBaseSocketDropIpMembershipResponse
}

type datagramSocketWithCtxBaseSocketAddIpv6MembershipRequest 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 _mdatagramSocketWithCtxBaseSocketAddIpv6MembershipRequest = _bindings.CreateLazyMarshaler(datagramSocketWithCtxBaseSocketAddIpv6MembershipRequest{})

func (msg *datagramSocketWithCtxBaseSocketAddIpv6MembershipRequest) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxBaseSocketAddIpv6MembershipRequest
}

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

var _mdatagramSocketWithCtxBaseSocketAddIpv6MembershipResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxBaseSocketAddIpv6MembershipResponse{})

func (msg *datagramSocketWithCtxBaseSocketAddIpv6MembershipResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxBaseSocketAddIpv6MembershipResponse
}

type datagramSocketWithCtxBaseSocketDropIpv6MembershipRequest 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 _mdatagramSocketWithCtxBaseSocketDropIpv6MembershipRequest = _bindings.CreateLazyMarshaler(datagramSocketWithCtxBaseSocketDropIpv6MembershipRequest{})

func (msg *datagramSocketWithCtxBaseSocketDropIpv6MembershipRequest) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxBaseSocketDropIpv6MembershipRequest
}

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

var _mdatagramSocketWithCtxBaseSocketDropIpv6MembershipResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxBaseSocketDropIpv6MembershipResponse{})

func (msg *datagramSocketWithCtxBaseSocketDropIpv6MembershipResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxBaseSocketDropIpv6MembershipResponse
}

type datagramSocketWithCtxBaseSocketSetIpv6MulticastInterfaceRequest 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 _mdatagramSocketWithCtxBaseSocketSetIpv6MulticastInterfaceRequest = _bindings.CreateLazyMarshaler(datagramSocketWithCtxBaseSocketSetIpv6MulticastInterfaceRequest{})

func (msg *datagramSocketWithCtxBaseSocketSetIpv6MulticastInterfaceRequest) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxBaseSocketSetIpv6MulticastInterfaceRequest
}

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

var _mdatagramSocketWithCtxBaseSocketSetIpv6MulticastInterfaceResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxBaseSocketSetIpv6MulticastInterfaceResponse{})

func (msg *datagramSocketWithCtxBaseSocketSetIpv6MulticastInterfaceResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxBaseSocketSetIpv6MulticastInterfaceResponse
}

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

var _mdatagramSocketWithCtxBaseSocketGetIpv6MulticastInterfaceResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxBaseSocketGetIpv6MulticastInterfaceResponse{})

func (msg *datagramSocketWithCtxBaseSocketGetIpv6MulticastInterfaceResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxBaseSocketGetIpv6MulticastInterfaceResponse
}

type datagramSocketWithCtxBaseSocketSetIpv6MulticastHopsRequest 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 _mdatagramSocketWithCtxBaseSocketSetIpv6MulticastHopsRequest = _bindings.CreateLazyMarshaler(datagramSocketWithCtxBaseSocketSetIpv6MulticastHopsRequest{})

func (msg *datagramSocketWithCtxBaseSocketSetIpv6MulticastHopsRequest) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxBaseSocketSetIpv6MulticastHopsRequest
}

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

var _mdatagramSocketWithCtxBaseSocketSetIpv6MulticastHopsResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxBaseSocketSetIpv6MulticastHopsResponse{})

func (msg *datagramSocketWithCtxBaseSocketSetIpv6MulticastHopsResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxBaseSocketSetIpv6MulticastHopsResponse
}

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

var _mdatagramSocketWithCtxBaseSocketGetIpv6MulticastHopsResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxBaseSocketGetIpv6MulticastHopsResponse{})

func (msg *datagramSocketWithCtxBaseSocketGetIpv6MulticastHopsResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxBaseSocketGetIpv6MulticastHopsResponse
}

type datagramSocketWithCtxBaseSocketSetIpv6MulticastLoopbackRequest 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 _mdatagramSocketWithCtxBaseSocketSetIpv6MulticastLoopbackRequest = _bindings.CreateLazyMarshaler(datagramSocketWithCtxBaseSocketSetIpv6MulticastLoopbackRequest{})

func (msg *datagramSocketWithCtxBaseSocketSetIpv6MulticastLoopbackRequest) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxBaseSocketSetIpv6MulticastLoopbackRequest
}

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

var _mdatagramSocketWithCtxBaseSocketSetIpv6MulticastLoopbackResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxBaseSocketSetIpv6MulticastLoopbackResponse{})

func (msg *datagramSocketWithCtxBaseSocketSetIpv6MulticastLoopbackResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxBaseSocketSetIpv6MulticastLoopbackResponse
}

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

var _mdatagramSocketWithCtxBaseSocketGetIpv6MulticastLoopbackResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxBaseSocketGetIpv6MulticastLoopbackResponse{})

func (msg *datagramSocketWithCtxBaseSocketGetIpv6MulticastLoopbackResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxBaseSocketGetIpv6MulticastLoopbackResponse
}

type datagramSocketWithCtxBaseSocketSetIpv6OnlyRequest 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 _mdatagramSocketWithCtxBaseSocketSetIpv6OnlyRequest = _bindings.CreateLazyMarshaler(datagramSocketWithCtxBaseSocketSetIpv6OnlyRequest{})

func (msg *datagramSocketWithCtxBaseSocketSetIpv6OnlyRequest) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxBaseSocketSetIpv6OnlyRequest
}

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

var _mdatagramSocketWithCtxBaseSocketSetIpv6OnlyResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxBaseSocketSetIpv6OnlyResponse{})

func (msg *datagramSocketWithCtxBaseSocketSetIpv6OnlyResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxBaseSocketSetIpv6OnlyResponse
}

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

var _mdatagramSocketWithCtxBaseSocketGetIpv6OnlyResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxBaseSocketGetIpv6OnlyResponse{})

func (msg *datagramSocketWithCtxBaseSocketGetIpv6OnlyResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxBaseSocketGetIpv6OnlyResponse
}

type datagramSocketWithCtxBaseSocketSetIpv6ReceiveTrafficClassRequest 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 _mdatagramSocketWithCtxBaseSocketSetIpv6ReceiveTrafficClassRequest = _bindings.CreateLazyMarshaler(datagramSocketWithCtxBaseSocketSetIpv6ReceiveTrafficClassRequest{})

func (msg *datagramSocketWithCtxBaseSocketSetIpv6ReceiveTrafficClassRequest) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxBaseSocketSetIpv6ReceiveTrafficClassRequest
}

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

var _mdatagramSocketWithCtxBaseSocketSetIpv6ReceiveTrafficClassResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxBaseSocketSetIpv6ReceiveTrafficClassResponse{})

func (msg *datagramSocketWithCtxBaseSocketSetIpv6ReceiveTrafficClassResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxBaseSocketSetIpv6ReceiveTrafficClassResponse
}

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

var _mdatagramSocketWithCtxBaseSocketGetIpv6ReceiveTrafficClassResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxBaseSocketGetIpv6ReceiveTrafficClassResponse{})

func (msg *datagramSocketWithCtxBaseSocketGetIpv6ReceiveTrafficClassResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxBaseSocketGetIpv6ReceiveTrafficClassResponse
}

type datagramSocketWithCtxBaseSocketSetIpv6TrafficClassRequest 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 _mdatagramSocketWithCtxBaseSocketSetIpv6TrafficClassRequest = _bindings.CreateLazyMarshaler(datagramSocketWithCtxBaseSocketSetIpv6TrafficClassRequest{})

func (msg *datagramSocketWithCtxBaseSocketSetIpv6TrafficClassRequest) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxBaseSocketSetIpv6TrafficClassRequest
}

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

var _mdatagramSocketWithCtxBaseSocketSetIpv6TrafficClassResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxBaseSocketSetIpv6TrafficClassResponse{})

func (msg *datagramSocketWithCtxBaseSocketSetIpv6TrafficClassResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxBaseSocketSetIpv6TrafficClassResponse
}

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

var _mdatagramSocketWithCtxBaseSocketGetIpv6TrafficClassResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxBaseSocketGetIpv6TrafficClassResponse{})

func (msg *datagramSocketWithCtxBaseSocketGetIpv6TrafficClassResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxBaseSocketGetIpv6TrafficClassResponse
}

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 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 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 BaseNetworkSocketBindResult `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 BaseNetworkSocketConnectResult `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 BaseNetworkSocketDisconnectResult `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 BaseNetworkSocketGetSockNameResult `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 BaseNetworkSocketGetPeerNameResult `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 BaseNetworkSocketShutdownResult `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 BaseNetworkSocketShutdown2Result `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxShutdown2Response = _bindings.CreateLazyMarshaler(streamSocketWithCtxShutdown2Response{})

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

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 BaseNetworkSocketSetIpTypeOfServiceResult `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 BaseNetworkSocketGetIpTypeOfServiceResult `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 BaseNetworkSocketSetIpTtlResult `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 BaseNetworkSocketGetIpTtlResult `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 BaseNetworkSocketSetIpPacketInfoResult `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 BaseNetworkSocketGetIpPacketInfoResult `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 BaseNetworkSocketSetIpReceiveTypeOfServiceResult `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 BaseNetworkSocketGetIpReceiveTypeOfServiceResult `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 BaseNetworkSocketSetIpMulticastInterfaceResult `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 BaseNetworkSocketGetIpMulticastInterfaceResult `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 BaseNetworkSocketSetIpMulticastTtlResult `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 BaseNetworkSocketGetIpMulticastTtlResult `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 BaseNetworkSocketSetIpMulticastLoopbackResult `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 BaseNetworkSocketGetIpMulticastLoopbackResult `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 BaseNetworkSocketAddIpMembershipResult `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 BaseNetworkSocketDropIpMembershipResult `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 BaseNetworkSocketAddIpv6MembershipResult `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 BaseNetworkSocketDropIpv6MembershipResult `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 BaseNetworkSocketSetIpv6MulticastInterfaceResult `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 BaseNetworkSocketGetIpv6MulticastInterfaceResult `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 BaseNetworkSocketSetIpv6MulticastHopsResult `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 BaseNetworkSocketGetIpv6MulticastHopsResult `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 BaseNetworkSocketSetIpv6MulticastLoopbackResult `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 BaseNetworkSocketGetIpv6MulticastLoopbackResult `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 BaseNetworkSocketSetIpv6OnlyResult `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 BaseNetworkSocketGetIpv6OnlyResult `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 BaseNetworkSocketSetIpv6ReceiveTrafficClassResult `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 BaseNetworkSocketGetIpv6ReceiveTrafficClassResult `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 BaseNetworkSocketSetIpv6TrafficClassResult `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 BaseNetworkSocketGetIpv6TrafficClassResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstreamSocketWithCtxGetIpv6TrafficClassResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxGetIpv6TrafficClassResponse{})

func (msg *streamSocketWithCtxGetIpv6TrafficClassResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxGetIpv6TrafficClassResponse
}

type streamSocketWithCtxBaseSocketBindRequest 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 _mstreamSocketWithCtxBaseSocketBindRequest = _bindings.CreateLazyMarshaler(streamSocketWithCtxBaseSocketBindRequest{})

func (msg *streamSocketWithCtxBaseSocketBindRequest) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxBaseSocketBindRequest
}

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

var _mstreamSocketWithCtxBaseSocketBindResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxBaseSocketBindResponse{})

func (msg *streamSocketWithCtxBaseSocketBindResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxBaseSocketBindResponse
}

type streamSocketWithCtxBaseSocketConnectRequest 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 _mstreamSocketWithCtxBaseSocketConnectRequest = _bindings.CreateLazyMarshaler(streamSocketWithCtxBaseSocketConnectRequest{})

func (msg *streamSocketWithCtxBaseSocketConnectRequest) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxBaseSocketConnectRequest
}

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

var _mstreamSocketWithCtxBaseSocketConnectResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxBaseSocketConnectResponse{})

func (msg *streamSocketWithCtxBaseSocketConnectResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxBaseSocketConnectResponse
}

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

var _mstreamSocketWithCtxBaseSocketDisconnectResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxBaseSocketDisconnectResponse{})

func (msg *streamSocketWithCtxBaseSocketDisconnectResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxBaseSocketDisconnectResponse
}

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

var _mstreamSocketWithCtxBaseSocketGetSockNameResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxBaseSocketGetSockNameResponse{})

func (msg *streamSocketWithCtxBaseSocketGetSockNameResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxBaseSocketGetSockNameResponse
}

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

var _mstreamSocketWithCtxBaseSocketGetPeerNameResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxBaseSocketGetPeerNameResponse{})

func (msg *streamSocketWithCtxBaseSocketGetPeerNameResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxBaseSocketGetPeerNameResponse
}

type streamSocketWithCtxBaseSocketShutdownRequest 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 _mstreamSocketWithCtxBaseSocketShutdownRequest = _bindings.CreateLazyMarshaler(streamSocketWithCtxBaseSocketShutdownRequest{})

func (msg *streamSocketWithCtxBaseSocketShutdownRequest) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxBaseSocketShutdownRequest
}

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

var _mstreamSocketWithCtxBaseSocketShutdownResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxBaseSocketShutdownResponse{})

func (msg *streamSocketWithCtxBaseSocketShutdownResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxBaseSocketShutdownResponse
}

type streamSocketWithCtxBaseSocketShutdown2Request 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 _mstreamSocketWithCtxBaseSocketShutdown2Request = _bindings.CreateLazyMarshaler(streamSocketWithCtxBaseSocketShutdown2Request{})

func (msg *streamSocketWithCtxBaseSocketShutdown2Request) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxBaseSocketShutdown2Request
}

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

var _mstreamSocketWithCtxBaseSocketShutdown2Response = _bindings.CreateLazyMarshaler(streamSocketWithCtxBaseSocketShutdown2Response{})

func (msg *streamSocketWithCtxBaseSocketShutdown2Response) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxBaseSocketShutdown2Response
}

type streamSocketWithCtxBaseSocketSetIpTypeOfServiceRequest 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 _mstreamSocketWithCtxBaseSocketSetIpTypeOfServiceRequest = _bindings.CreateLazyMarshaler(streamSocketWithCtxBaseSocketSetIpTypeOfServiceRequest{})

func (msg *streamSocketWithCtxBaseSocketSetIpTypeOfServiceRequest) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxBaseSocketSetIpTypeOfServiceRequest
}

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

var _mstreamSocketWithCtxBaseSocketSetIpTypeOfServiceResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxBaseSocketSetIpTypeOfServiceResponse{})

func (msg *streamSocketWithCtxBaseSocketSetIpTypeOfServiceResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxBaseSocketSetIpTypeOfServiceResponse
}

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

var _mstreamSocketWithCtxBaseSocketGetIpTypeOfServiceResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxBaseSocketGetIpTypeOfServiceResponse{})

func (msg *streamSocketWithCtxBaseSocketGetIpTypeOfServiceResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxBaseSocketGetIpTypeOfServiceResponse
}

type streamSocketWithCtxBaseSocketSetIpTtlRequest 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 _mstreamSocketWithCtxBaseSocketSetIpTtlRequest = _bindings.CreateLazyMarshaler(streamSocketWithCtxBaseSocketSetIpTtlRequest{})

func (msg *streamSocketWithCtxBaseSocketSetIpTtlRequest) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxBaseSocketSetIpTtlRequest
}

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

var _mstreamSocketWithCtxBaseSocketSetIpTtlResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxBaseSocketSetIpTtlResponse{})

func (msg *streamSocketWithCtxBaseSocketSetIpTtlResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxBaseSocketSetIpTtlResponse
}

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

var _mstreamSocketWithCtxBaseSocketGetIpTtlResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxBaseSocketGetIpTtlResponse{})

func (msg *streamSocketWithCtxBaseSocketGetIpTtlResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxBaseSocketGetIpTtlResponse
}

type streamSocketWithCtxBaseSocketSetIpPacketInfoRequest 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 _mstreamSocketWithCtxBaseSocketSetIpPacketInfoRequest = _bindings.CreateLazyMarshaler(streamSocketWithCtxBaseSocketSetIpPacketInfoRequest{})

func (msg *streamSocketWithCtxBaseSocketSetIpPacketInfoRequest) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxBaseSocketSetIpPacketInfoRequest
}

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

var _mstreamSocketWithCtxBaseSocketSetIpPacketInfoResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxBaseSocketSetIpPacketInfoResponse{})

func (msg *streamSocketWithCtxBaseSocketSetIpPacketInfoResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxBaseSocketSetIpPacketInfoResponse
}

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

var _mstreamSocketWithCtxBaseSocketGetIpPacketInfoResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxBaseSocketGetIpPacketInfoResponse{})

func (msg *streamSocketWithCtxBaseSocketGetIpPacketInfoResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxBaseSocketGetIpPacketInfoResponse
}

type streamSocketWithCtxBaseSocketSetIpReceiveTypeOfServiceRequest 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 _mstreamSocketWithCtxBaseSocketSetIpReceiveTypeOfServiceRequest = _bindings.CreateLazyMarshaler(streamSocketWithCtxBaseSocketSetIpReceiveTypeOfServiceRequest{})

func (msg *streamSocketWithCtxBaseSocketSetIpReceiveTypeOfServiceRequest) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxBaseSocketSetIpReceiveTypeOfServiceRequest
}

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

var _mstreamSocketWithCtxBaseSocketSetIpReceiveTypeOfServiceResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxBaseSocketSetIpReceiveTypeOfServiceResponse{})

func (msg *streamSocketWithCtxBaseSocketSetIpReceiveTypeOfServiceResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxBaseSocketSetIpReceiveTypeOfServiceResponse
}

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

var _mstreamSocketWithCtxBaseSocketGetIpReceiveTypeOfServiceResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxBaseSocketGetIpReceiveTypeOfServiceResponse{})

func (msg *streamSocketWithCtxBaseSocketGetIpReceiveTypeOfServiceResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxBaseSocketGetIpReceiveTypeOfServiceResponse
}

type streamSocketWithCtxBaseSocketSetIpMulticastInterfaceRequest 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 _mstreamSocketWithCtxBaseSocketSetIpMulticastInterfaceRequest = _bindings.CreateLazyMarshaler(streamSocketWithCtxBaseSocketSetIpMulticastInterfaceRequest{})

func (msg *streamSocketWithCtxBaseSocketSetIpMulticastInterfaceRequest) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxBaseSocketSetIpMulticastInterfaceRequest
}

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

var _mstreamSocketWithCtxBaseSocketSetIpMulticastInterfaceResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxBaseSocketSetIpMulticastInterfaceResponse{})

func (msg *streamSocketWithCtxBaseSocketSetIpMulticastInterfaceResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxBaseSocketSetIpMulticastInterfaceResponse
}

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

var _mstreamSocketWithCtxBaseSocketGetIpMulticastInterfaceResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxBaseSocketGetIpMulticastInterfaceResponse{})

func (msg *streamSocketWithCtxBaseSocketGetIpMulticastInterfaceResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxBaseSocketGetIpMulticastInterfaceResponse
}

type streamSocketWithCtxBaseSocketSetIpMulticastTtlRequest 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 _mstreamSocketWithCtxBaseSocketSetIpMulticastTtlRequest = _bindings.CreateLazyMarshaler(streamSocketWithCtxBaseSocketSetIpMulticastTtlRequest{})

func (msg *streamSocketWithCtxBaseSocketSetIpMulticastTtlRequest) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxBaseSocketSetIpMulticastTtlRequest
}

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

var _mstreamSocketWithCtxBaseSocketSetIpMulticastTtlResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxBaseSocketSetIpMulticastTtlResponse{})

func (msg *streamSocketWithCtxBaseSocketSetIpMulticastTtlResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxBaseSocketSetIpMulticastTtlResponse
}

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

var _mstreamSocketWithCtxBaseSocketGetIpMulticastTtlResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxBaseSocketGetIpMulticastTtlResponse{})

func (msg *streamSocketWithCtxBaseSocketGetIpMulticastTtlResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxBaseSocketGetIpMulticastTtlResponse
}

type streamSocketWithCtxBaseSocketSetIpMulticastLoopbackRequest 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 _mstreamSocketWithCtxBaseSocketSetIpMulticastLoopbackRequest = _bindings.CreateLazyMarshaler(streamSocketWithCtxBaseSocketSetIpMulticastLoopbackRequest{})

func (msg *streamSocketWithCtxBaseSocketSetIpMulticastLoopbackRequest) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxBaseSocketSetIpMulticastLoopbackRequest
}

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

var _mstreamSocketWithCtxBaseSocketSetIpMulticastLoopbackResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxBaseSocketSetIpMulticastLoopbackResponse{})

func (msg *streamSocketWithCtxBaseSocketSetIpMulticastLoopbackResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxBaseSocketSetIpMulticastLoopbackResponse
}

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

var _mstreamSocketWithCtxBaseSocketGetIpMulticastLoopbackResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxBaseSocketGetIpMulticastLoopbackResponse{})

func (msg *streamSocketWithCtxBaseSocketGetIpMulticastLoopbackResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxBaseSocketGetIpMulticastLoopbackResponse
}

type streamSocketWithCtxBaseSocketAddIpMembershipRequest 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 _mstreamSocketWithCtxBaseSocketAddIpMembershipRequest = _bindings.CreateLazyMarshaler(streamSocketWithCtxBaseSocketAddIpMembershipRequest{})

func (msg *streamSocketWithCtxBaseSocketAddIpMembershipRequest) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxBaseSocketAddIpMembershipRequest
}

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

var _mstreamSocketWithCtxBaseSocketAddIpMembershipResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxBaseSocketAddIpMembershipResponse{})

func (msg *streamSocketWithCtxBaseSocketAddIpMembershipResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxBaseSocketAddIpMembershipResponse
}

type streamSocketWithCtxBaseSocketDropIpMembershipRequest 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 _mstreamSocketWithCtxBaseSocketDropIpMembershipRequest = _bindings.CreateLazyMarshaler(streamSocketWithCtxBaseSocketDropIpMembershipRequest{})

func (msg *streamSocketWithCtxBaseSocketDropIpMembershipRequest) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxBaseSocketDropIpMembershipRequest
}

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

var _mstreamSocketWithCtxBaseSocketDropIpMembershipResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxBaseSocketDropIpMembershipResponse{})

func (msg *streamSocketWithCtxBaseSocketDropIpMembershipResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxBaseSocketDropIpMembershipResponse
}

type streamSocketWithCtxBaseSocketAddIpv6MembershipRequest 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 _mstreamSocketWithCtxBaseSocketAddIpv6MembershipRequest = _bindings.CreateLazyMarshaler(streamSocketWithCtxBaseSocketAddIpv6MembershipRequest{})

func (msg *streamSocketWithCtxBaseSocketAddIpv6MembershipRequest) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxBaseSocketAddIpv6MembershipRequest
}

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

var _mstreamSocketWithCtxBaseSocketAddIpv6MembershipResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxBaseSocketAddIpv6MembershipResponse{})

func (msg *streamSocketWithCtxBaseSocketAddIpv6MembershipResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxBaseSocketAddIpv6MembershipResponse
}

type streamSocketWithCtxBaseSocketDropIpv6MembershipRequest 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 _mstreamSocketWithCtxBaseSocketDropIpv6MembershipRequest = _bindings.CreateLazyMarshaler(streamSocketWithCtxBaseSocketDropIpv6MembershipRequest{})

func (msg *streamSocketWithCtxBaseSocketDropIpv6MembershipRequest) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxBaseSocketDropIpv6MembershipRequest
}

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

var _mstreamSocketWithCtxBaseSocketDropIpv6MembershipResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxBaseSocketDropIpv6MembershipResponse{})

func (msg *streamSocketWithCtxBaseSocketDropIpv6MembershipResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxBaseSocketDropIpv6MembershipResponse
}

type streamSocketWithCtxBaseSocketSetIpv6MulticastInterfaceRequest 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 _mstreamSocketWithCtxBaseSocketSetIpv6MulticastInterfaceRequest = _bindings.CreateLazyMarshaler(streamSocketWithCtxBaseSocketSetIpv6MulticastInterfaceRequest{})

func (msg *streamSocketWithCtxBaseSocketSetIpv6MulticastInterfaceRequest) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxBaseSocketSetIpv6MulticastInterfaceRequest
}

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

var _mstreamSocketWithCtxBaseSocketSetIpv6MulticastInterfaceResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxBaseSocketSetIpv6MulticastInterfaceResponse{})

func (msg *streamSocketWithCtxBaseSocketSetIpv6MulticastInterfaceResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxBaseSocketSetIpv6MulticastInterfaceResponse
}

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

var _mstreamSocketWithCtxBaseSocketGetIpv6MulticastInterfaceResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxBaseSocketGetIpv6MulticastInterfaceResponse{})

func (msg *streamSocketWithCtxBaseSocketGetIpv6MulticastInterfaceResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxBaseSocketGetIpv6MulticastInterfaceResponse
}

type streamSocketWithCtxBaseSocketSetIpv6MulticastHopsRequest 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 _mstreamSocketWithCtxBaseSocketSetIpv6MulticastHopsRequest = _bindings.CreateLazyMarshaler(streamSocketWithCtxBaseSocketSetIpv6MulticastHopsRequest{})

func (msg *streamSocketWithCtxBaseSocketSetIpv6MulticastHopsRequest) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxBaseSocketSetIpv6MulticastHopsRequest
}

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

var _mstreamSocketWithCtxBaseSocketSetIpv6MulticastHopsResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxBaseSocketSetIpv6MulticastHopsResponse{})

func (msg *streamSocketWithCtxBaseSocketSetIpv6MulticastHopsResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxBaseSocketSetIpv6MulticastHopsResponse
}

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

var _mstreamSocketWithCtxBaseSocketGetIpv6MulticastHopsResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxBaseSocketGetIpv6MulticastHopsResponse{})

func (msg *streamSocketWithCtxBaseSocketGetIpv6MulticastHopsResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxBaseSocketGetIpv6MulticastHopsResponse
}

type streamSocketWithCtxBaseSocketSetIpv6MulticastLoopbackRequest 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 _mstreamSocketWithCtxBaseSocketSetIpv6MulticastLoopbackRequest = _bindings.CreateLazyMarshaler(streamSocketWithCtxBaseSocketSetIpv6MulticastLoopbackRequest{})

func (msg *streamSocketWithCtxBaseSocketSetIpv6MulticastLoopbackRequest) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxBaseSocketSetIpv6MulticastLoopbackRequest
}

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

var _mstreamSocketWithCtxBaseSocketSetIpv6MulticastLoopbackResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxBaseSocketSetIpv6MulticastLoopbackResponse{})

func (msg *streamSocketWithCtxBaseSocketSetIpv6MulticastLoopbackResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxBaseSocketSetIpv6MulticastLoopbackResponse
}

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

var _mstreamSocketWithCtxBaseSocketGetIpv6MulticastLoopbackResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxBaseSocketGetIpv6MulticastLoopbackResponse{})

func (msg *streamSocketWithCtxBaseSocketGetIpv6MulticastLoopbackResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxBaseSocketGetIpv6MulticastLoopbackResponse
}

type streamSocketWithCtxBaseSocketSetIpv6OnlyRequest 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 _mstreamSocketWithCtxBaseSocketSetIpv6OnlyRequest = _bindings.CreateLazyMarshaler(streamSocketWithCtxBaseSocketSetIpv6OnlyRequest{})

func (msg *streamSocketWithCtxBaseSocketSetIpv6OnlyRequest) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxBaseSocketSetIpv6OnlyRequest
}

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

var _mstreamSocketWithCtxBaseSocketSetIpv6OnlyResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxBaseSocketSetIpv6OnlyResponse{})

func (msg *streamSocketWithCtxBaseSocketSetIpv6OnlyResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxBaseSocketSetIpv6OnlyResponse
}

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

var _mstreamSocketWithCtxBaseSocketGetIpv6OnlyResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxBaseSocketGetIpv6OnlyResponse{})

func (msg *streamSocketWithCtxBaseSocketGetIpv6OnlyResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxBaseSocketGetIpv6OnlyResponse
}

type streamSocketWithCtxBaseSocketSetIpv6ReceiveTrafficClassRequest 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 _mstreamSocketWithCtxBaseSocketSetIpv6ReceiveTrafficClassRequest = _bindings.CreateLazyMarshaler(streamSocketWithCtxBaseSocketSetIpv6ReceiveTrafficClassRequest{})

func (msg *streamSocketWithCtxBaseSocketSetIpv6ReceiveTrafficClassRequest) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxBaseSocketSetIpv6ReceiveTrafficClassRequest
}

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

var _mstreamSocketWithCtxBaseSocketSetIpv6ReceiveTrafficClassResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxBaseSocketSetIpv6ReceiveTrafficClassResponse{})

func (msg *streamSocketWithCtxBaseSocketSetIpv6ReceiveTrafficClassResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxBaseSocketSetIpv6ReceiveTrafficClassResponse
}

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

var _mstreamSocketWithCtxBaseSocketGetIpv6ReceiveTrafficClassResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxBaseSocketGetIpv6ReceiveTrafficClassResponse{})

func (msg *streamSocketWithCtxBaseSocketGetIpv6ReceiveTrafficClassResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxBaseSocketGetIpv6ReceiveTrafficClassResponse
}

type streamSocketWithCtxBaseSocketSetIpv6TrafficClassRequest 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 _mstreamSocketWithCtxBaseSocketSetIpv6TrafficClassRequest = _bindings.CreateLazyMarshaler(streamSocketWithCtxBaseSocketSetIpv6TrafficClassRequest{})

func (msg *streamSocketWithCtxBaseSocketSetIpv6TrafficClassRequest) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxBaseSocketSetIpv6TrafficClassRequest
}

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

var _mstreamSocketWithCtxBaseSocketSetIpv6TrafficClassResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxBaseSocketSetIpv6TrafficClassResponse{})

func (msg *streamSocketWithCtxBaseSocketSetIpv6TrafficClassResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxBaseSocketSetIpv6TrafficClassResponse
}

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

var _mstreamSocketWithCtxBaseSocketGetIpv6TrafficClassResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxBaseSocketGetIpv6TrafficClassResponse{})

func (msg *streamSocketWithCtxBaseSocketGetIpv6TrafficClassResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxBaseSocketGetIpv6TrafficClassResponse
}

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_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_baseNetworkSocketBindResultTag uint64

const (
	BaseNetworkSocketBindResultResponse = 1 // 0x00000001
	BaseNetworkSocketBindResultErr      = 2 // 0x00000002
)

type BaseNetworkSocketBindResult struct {
	I_baseNetworkSocketBindResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                         BaseNetworkSocketBindResponse `fidl_ordinal:"1"`
	Err                              fuchsiaposix.Errno            `fidl_ordinal:"2"`
}

func (_m *BaseNetworkSocketBindResult) reset() {
	switch _m.I_baseNetworkSocketBindResultTag {
	case 1:
		var _zeroed BaseNetworkSocketBindResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseNetworkSocketBindResult) Which() I_baseNetworkSocketBindResultTag {
	return _m.I_baseNetworkSocketBindResultTag
}

func (_m *BaseNetworkSocketBindResult) Ordinal() uint64 {
	return uint64(_m.I_baseNetworkSocketBindResultTag)
}

func (_m *BaseNetworkSocketBindResult) SetResponse(response BaseNetworkSocketBindResponse) {
	_m.reset()
	_m.I_baseNetworkSocketBindResultTag = BaseNetworkSocketBindResultResponse
	_m.Response = response
}

func BaseNetworkSocketBindResultWithResponse(response BaseNetworkSocketBindResponse) BaseNetworkSocketBindResult {
	var _u BaseNetworkSocketBindResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseNetworkSocketBindResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseNetworkSocketBindResultTag = BaseNetworkSocketBindResultErr
	_m.Err = err
}

func BaseNetworkSocketBindResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketBindResult {
	var _u BaseNetworkSocketBindResult
	_u.SetErr(err)
	return _u
}

type I_baseNetworkSocketConnectResultTag uint64

const (
	BaseNetworkSocketConnectResultResponse = 1 // 0x00000001
	BaseNetworkSocketConnectResultErr      = 2 // 0x00000002
)

type BaseNetworkSocketConnectResult struct {
	I_baseNetworkSocketConnectResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                            BaseNetworkSocketConnectResponse `fidl_ordinal:"1"`
	Err                                 fuchsiaposix.Errno               `fidl_ordinal:"2"`
}

func (_m *BaseNetworkSocketConnectResult) reset() {
	switch _m.I_baseNetworkSocketConnectResultTag {
	case 1:
		var _zeroed BaseNetworkSocketConnectResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseNetworkSocketConnectResult) Which() I_baseNetworkSocketConnectResultTag {
	return _m.I_baseNetworkSocketConnectResultTag
}

func (_m *BaseNetworkSocketConnectResult) Ordinal() uint64 {
	return uint64(_m.I_baseNetworkSocketConnectResultTag)
}

func (_m *BaseNetworkSocketConnectResult) SetResponse(response BaseNetworkSocketConnectResponse) {
	_m.reset()
	_m.I_baseNetworkSocketConnectResultTag = BaseNetworkSocketConnectResultResponse
	_m.Response = response
}

func BaseNetworkSocketConnectResultWithResponse(response BaseNetworkSocketConnectResponse) BaseNetworkSocketConnectResult {
	var _u BaseNetworkSocketConnectResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseNetworkSocketConnectResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseNetworkSocketConnectResultTag = BaseNetworkSocketConnectResultErr
	_m.Err = err
}

func BaseNetworkSocketConnectResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketConnectResult {
	var _u BaseNetworkSocketConnectResult
	_u.SetErr(err)
	return _u
}

type I_baseNetworkSocketDisconnectResultTag uint64

const (
	BaseNetworkSocketDisconnectResultResponse = 1 // 0x00000001
	BaseNetworkSocketDisconnectResultErr      = 2 // 0x00000002
)

type BaseNetworkSocketDisconnectResult struct {
	I_baseNetworkSocketDisconnectResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                               BaseNetworkSocketDisconnectResponse `fidl_ordinal:"1"`
	Err                                    fuchsiaposix.Errno                  `fidl_ordinal:"2"`
}

func (_m *BaseNetworkSocketDisconnectResult) reset() {
	switch _m.I_baseNetworkSocketDisconnectResultTag {
	case 1:
		var _zeroed BaseNetworkSocketDisconnectResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseNetworkSocketDisconnectResult) Which() I_baseNetworkSocketDisconnectResultTag {
	return _m.I_baseNetworkSocketDisconnectResultTag
}

func (_m *BaseNetworkSocketDisconnectResult) Ordinal() uint64 {
	return uint64(_m.I_baseNetworkSocketDisconnectResultTag)
}

func (_m *BaseNetworkSocketDisconnectResult) SetResponse(response BaseNetworkSocketDisconnectResponse) {
	_m.reset()
	_m.I_baseNetworkSocketDisconnectResultTag = BaseNetworkSocketDisconnectResultResponse
	_m.Response = response
}

func BaseNetworkSocketDisconnectResultWithResponse(response BaseNetworkSocketDisconnectResponse) BaseNetworkSocketDisconnectResult {
	var _u BaseNetworkSocketDisconnectResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseNetworkSocketDisconnectResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseNetworkSocketDisconnectResultTag = BaseNetworkSocketDisconnectResultErr
	_m.Err = err
}

func BaseNetworkSocketDisconnectResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketDisconnectResult {
	var _u BaseNetworkSocketDisconnectResult
	_u.SetErr(err)
	return _u
}

type I_baseNetworkSocketGetSockNameResultTag uint64

const (
	BaseNetworkSocketGetSockNameResultResponse = 1 // 0x00000001
	BaseNetworkSocketGetSockNameResultErr      = 2 // 0x00000002
)

type BaseNetworkSocketGetSockNameResult struct {
	I_baseNetworkSocketGetSockNameResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                BaseNetworkSocketGetSockNameResponse `fidl_ordinal:"1"`
	Err                                     fuchsiaposix.Errno                   `fidl_ordinal:"2"`
}

func (_m *BaseNetworkSocketGetSockNameResult) reset() {
	switch _m.I_baseNetworkSocketGetSockNameResultTag {
	case 1:
		var _zeroed BaseNetworkSocketGetSockNameResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseNetworkSocketGetSockNameResult) Which() I_baseNetworkSocketGetSockNameResultTag {
	return _m.I_baseNetworkSocketGetSockNameResultTag
}

func (_m *BaseNetworkSocketGetSockNameResult) Ordinal() uint64 {
	return uint64(_m.I_baseNetworkSocketGetSockNameResultTag)
}

func (_m *BaseNetworkSocketGetSockNameResult) SetResponse(response BaseNetworkSocketGetSockNameResponse) {
	_m.reset()
	_m.I_baseNetworkSocketGetSockNameResultTag = BaseNetworkSocketGetSockNameResultResponse
	_m.Response = response
}

func BaseNetworkSocketGetSockNameResultWithResponse(response BaseNetworkSocketGetSockNameResponse) BaseNetworkSocketGetSockNameResult {
	var _u BaseNetworkSocketGetSockNameResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseNetworkSocketGetSockNameResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseNetworkSocketGetSockNameResultTag = BaseNetworkSocketGetSockNameResultErr
	_m.Err = err
}

func BaseNetworkSocketGetSockNameResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketGetSockNameResult {
	var _u BaseNetworkSocketGetSockNameResult
	_u.SetErr(err)
	return _u
}

type I_baseNetworkSocketGetPeerNameResultTag uint64

const (
	BaseNetworkSocketGetPeerNameResultResponse = 1 // 0x00000001
	BaseNetworkSocketGetPeerNameResultErr      = 2 // 0x00000002
)

type BaseNetworkSocketGetPeerNameResult struct {
	I_baseNetworkSocketGetPeerNameResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                BaseNetworkSocketGetPeerNameResponse `fidl_ordinal:"1"`
	Err                                     fuchsiaposix.Errno                   `fidl_ordinal:"2"`
}

func (_m *BaseNetworkSocketGetPeerNameResult) reset() {
	switch _m.I_baseNetworkSocketGetPeerNameResultTag {
	case 1:
		var _zeroed BaseNetworkSocketGetPeerNameResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseNetworkSocketGetPeerNameResult) Which() I_baseNetworkSocketGetPeerNameResultTag {
	return _m.I_baseNetworkSocketGetPeerNameResultTag
}

func (_m *BaseNetworkSocketGetPeerNameResult) Ordinal() uint64 {
	return uint64(_m.I_baseNetworkSocketGetPeerNameResultTag)
}

func (_m *BaseNetworkSocketGetPeerNameResult) SetResponse(response BaseNetworkSocketGetPeerNameResponse) {
	_m.reset()
	_m.I_baseNetworkSocketGetPeerNameResultTag = BaseNetworkSocketGetPeerNameResultResponse
	_m.Response = response
}

func BaseNetworkSocketGetPeerNameResultWithResponse(response BaseNetworkSocketGetPeerNameResponse) BaseNetworkSocketGetPeerNameResult {
	var _u BaseNetworkSocketGetPeerNameResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseNetworkSocketGetPeerNameResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseNetworkSocketGetPeerNameResultTag = BaseNetworkSocketGetPeerNameResultErr
	_m.Err = err
}

func BaseNetworkSocketGetPeerNameResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketGetPeerNameResult {
	var _u BaseNetworkSocketGetPeerNameResult
	_u.SetErr(err)
	return _u
}

type I_baseNetworkSocketShutdownResultTag uint64

const (
	BaseNetworkSocketShutdownResultResponse = 1 // 0x00000001
	BaseNetworkSocketShutdownResultErr      = 2 // 0x00000002
)

type BaseNetworkSocketShutdownResult struct {
	I_baseNetworkSocketShutdownResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                             BaseNetworkSocketShutdownResponse `fidl_ordinal:"1"`
	Err                                  fuchsiaposix.Errno                `fidl_ordinal:"2"`
}

func (_m *BaseNetworkSocketShutdownResult) reset() {
	switch _m.I_baseNetworkSocketShutdownResultTag {
	case 1:
		var _zeroed BaseNetworkSocketShutdownResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseNetworkSocketShutdownResult) Which() I_baseNetworkSocketShutdownResultTag {
	return _m.I_baseNetworkSocketShutdownResultTag
}

func (_m *BaseNetworkSocketShutdownResult) Ordinal() uint64 {
	return uint64(_m.I_baseNetworkSocketShutdownResultTag)
}

func (_m *BaseNetworkSocketShutdownResult) SetResponse(response BaseNetworkSocketShutdownResponse) {
	_m.reset()
	_m.I_baseNetworkSocketShutdownResultTag = BaseNetworkSocketShutdownResultResponse
	_m.Response = response
}

func BaseNetworkSocketShutdownResultWithResponse(response BaseNetworkSocketShutdownResponse) BaseNetworkSocketShutdownResult {
	var _u BaseNetworkSocketShutdownResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseNetworkSocketShutdownResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseNetworkSocketShutdownResultTag = BaseNetworkSocketShutdownResultErr
	_m.Err = err
}

func BaseNetworkSocketShutdownResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketShutdownResult {
	var _u BaseNetworkSocketShutdownResult
	_u.SetErr(err)
	return _u
}

type I_baseNetworkSocketShutdown2ResultTag uint64

const (
	BaseNetworkSocketShutdown2ResultResponse = 1 // 0x00000001
	BaseNetworkSocketShutdown2ResultErr      = 2 // 0x00000002
)

type BaseNetworkSocketShutdown2Result struct {
	I_baseNetworkSocketShutdown2ResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                              BaseNetworkSocketShutdown2Response `fidl_ordinal:"1"`
	Err                                   fuchsiaposix.Errno                 `fidl_ordinal:"2"`
}

func (_m *BaseNetworkSocketShutdown2Result) reset() {
	switch _m.I_baseNetworkSocketShutdown2ResultTag {
	case 1:
		var _zeroed BaseNetworkSocketShutdown2Response
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseNetworkSocketShutdown2Result) Which() I_baseNetworkSocketShutdown2ResultTag {
	return _m.I_baseNetworkSocketShutdown2ResultTag
}

func (_m *BaseNetworkSocketShutdown2Result) Ordinal() uint64 {
	return uint64(_m.I_baseNetworkSocketShutdown2ResultTag)
}

func (_m *BaseNetworkSocketShutdown2Result) SetResponse(response BaseNetworkSocketShutdown2Response) {
	_m.reset()
	_m.I_baseNetworkSocketShutdown2ResultTag = BaseNetworkSocketShutdown2ResultResponse
	_m.Response = response
}

func BaseNetworkSocketShutdown2ResultWithResponse(response BaseNetworkSocketShutdown2Response) BaseNetworkSocketShutdown2Result {
	var _u BaseNetworkSocketShutdown2Result
	_u.SetResponse(response)
	return _u
}

func (_m *BaseNetworkSocketShutdown2Result) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseNetworkSocketShutdown2ResultTag = BaseNetworkSocketShutdown2ResultErr
	_m.Err = err
}

func BaseNetworkSocketShutdown2ResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketShutdown2Result {
	var _u BaseNetworkSocketShutdown2Result
	_u.SetErr(err)
	return _u
}

type I_baseNetworkSocketSetIpTypeOfServiceResultTag uint64

const (
	BaseNetworkSocketSetIpTypeOfServiceResultResponse = 1 // 0x00000001
	BaseNetworkSocketSetIpTypeOfServiceResultErr      = 2 // 0x00000002
)

type BaseNetworkSocketSetIpTypeOfServiceResult struct {
	I_baseNetworkSocketSetIpTypeOfServiceResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                       BaseNetworkSocketSetIpTypeOfServiceResponse `fidl_ordinal:"1"`
	Err                                            fuchsiaposix.Errno                          `fidl_ordinal:"2"`
}

func (_m *BaseNetworkSocketSetIpTypeOfServiceResult) reset() {
	switch _m.I_baseNetworkSocketSetIpTypeOfServiceResultTag {
	case 1:
		var _zeroed BaseNetworkSocketSetIpTypeOfServiceResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseNetworkSocketSetIpTypeOfServiceResult) Which() I_baseNetworkSocketSetIpTypeOfServiceResultTag {
	return _m.I_baseNetworkSocketSetIpTypeOfServiceResultTag
}

func (_m *BaseNetworkSocketSetIpTypeOfServiceResult) Ordinal() uint64 {
	return uint64(_m.I_baseNetworkSocketSetIpTypeOfServiceResultTag)
}

func (_m *BaseNetworkSocketSetIpTypeOfServiceResult) SetResponse(response BaseNetworkSocketSetIpTypeOfServiceResponse) {
	_m.reset()
	_m.I_baseNetworkSocketSetIpTypeOfServiceResultTag = BaseNetworkSocketSetIpTypeOfServiceResultResponse
	_m.Response = response
}

func BaseNetworkSocketSetIpTypeOfServiceResultWithResponse(response BaseNetworkSocketSetIpTypeOfServiceResponse) BaseNetworkSocketSetIpTypeOfServiceResult {
	var _u BaseNetworkSocketSetIpTypeOfServiceResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseNetworkSocketSetIpTypeOfServiceResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseNetworkSocketSetIpTypeOfServiceResultTag = BaseNetworkSocketSetIpTypeOfServiceResultErr
	_m.Err = err
}

func BaseNetworkSocketSetIpTypeOfServiceResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketSetIpTypeOfServiceResult {
	var _u BaseNetworkSocketSetIpTypeOfServiceResult
	_u.SetErr(err)
	return _u
}

type I_baseNetworkSocketGetIpTypeOfServiceResultTag uint64

const (
	BaseNetworkSocketGetIpTypeOfServiceResultResponse = 1 // 0x00000001
	BaseNetworkSocketGetIpTypeOfServiceResultErr      = 2 // 0x00000002
)

type BaseNetworkSocketGetIpTypeOfServiceResult struct {
	I_baseNetworkSocketGetIpTypeOfServiceResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                       BaseNetworkSocketGetIpTypeOfServiceResponse `fidl_ordinal:"1"`
	Err                                            fuchsiaposix.Errno                          `fidl_ordinal:"2"`
}

func (_m *BaseNetworkSocketGetIpTypeOfServiceResult) reset() {
	switch _m.I_baseNetworkSocketGetIpTypeOfServiceResultTag {
	case 1:
		var _zeroed BaseNetworkSocketGetIpTypeOfServiceResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseNetworkSocketGetIpTypeOfServiceResult) Which() I_baseNetworkSocketGetIpTypeOfServiceResultTag {
	return _m.I_baseNetworkSocketGetIpTypeOfServiceResultTag
}

func (_m *BaseNetworkSocketGetIpTypeOfServiceResult) Ordinal() uint64 {
	return uint64(_m.I_baseNetworkSocketGetIpTypeOfServiceResultTag)
}

func (_m *BaseNetworkSocketGetIpTypeOfServiceResult) SetResponse(response BaseNetworkSocketGetIpTypeOfServiceResponse) {
	_m.reset()
	_m.I_baseNetworkSocketGetIpTypeOfServiceResultTag = BaseNetworkSocketGetIpTypeOfServiceResultResponse
	_m.Response = response
}

func BaseNetworkSocketGetIpTypeOfServiceResultWithResponse(response BaseNetworkSocketGetIpTypeOfServiceResponse) BaseNetworkSocketGetIpTypeOfServiceResult {
	var _u BaseNetworkSocketGetIpTypeOfServiceResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseNetworkSocketGetIpTypeOfServiceResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseNetworkSocketGetIpTypeOfServiceResultTag = BaseNetworkSocketGetIpTypeOfServiceResultErr
	_m.Err = err
}

func BaseNetworkSocketGetIpTypeOfServiceResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketGetIpTypeOfServiceResult {
	var _u BaseNetworkSocketGetIpTypeOfServiceResult
	_u.SetErr(err)
	return _u
}

type I_baseNetworkSocketSetIpTtlResultTag uint64

const (
	BaseNetworkSocketSetIpTtlResultResponse = 1 // 0x00000001
	BaseNetworkSocketSetIpTtlResultErr      = 2 // 0x00000002
)

type BaseNetworkSocketSetIpTtlResult struct {
	I_baseNetworkSocketSetIpTtlResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                             BaseNetworkSocketSetIpTtlResponse `fidl_ordinal:"1"`
	Err                                  fuchsiaposix.Errno                `fidl_ordinal:"2"`
}

func (_m *BaseNetworkSocketSetIpTtlResult) reset() {
	switch _m.I_baseNetworkSocketSetIpTtlResultTag {
	case 1:
		var _zeroed BaseNetworkSocketSetIpTtlResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseNetworkSocketSetIpTtlResult) Which() I_baseNetworkSocketSetIpTtlResultTag {
	return _m.I_baseNetworkSocketSetIpTtlResultTag
}

func (_m *BaseNetworkSocketSetIpTtlResult) Ordinal() uint64 {
	return uint64(_m.I_baseNetworkSocketSetIpTtlResultTag)
}

func (_m *BaseNetworkSocketSetIpTtlResult) SetResponse(response BaseNetworkSocketSetIpTtlResponse) {
	_m.reset()
	_m.I_baseNetworkSocketSetIpTtlResultTag = BaseNetworkSocketSetIpTtlResultResponse
	_m.Response = response
}

func BaseNetworkSocketSetIpTtlResultWithResponse(response BaseNetworkSocketSetIpTtlResponse) BaseNetworkSocketSetIpTtlResult {
	var _u BaseNetworkSocketSetIpTtlResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseNetworkSocketSetIpTtlResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseNetworkSocketSetIpTtlResultTag = BaseNetworkSocketSetIpTtlResultErr
	_m.Err = err
}

func BaseNetworkSocketSetIpTtlResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketSetIpTtlResult {
	var _u BaseNetworkSocketSetIpTtlResult
	_u.SetErr(err)
	return _u
}

type I_baseNetworkSocketGetIpTtlResultTag uint64

const (
	BaseNetworkSocketGetIpTtlResultResponse = 1 // 0x00000001
	BaseNetworkSocketGetIpTtlResultErr      = 2 // 0x00000002
)

type BaseNetworkSocketGetIpTtlResult struct {
	I_baseNetworkSocketGetIpTtlResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                             BaseNetworkSocketGetIpTtlResponse `fidl_ordinal:"1"`
	Err                                  fuchsiaposix.Errno                `fidl_ordinal:"2"`
}

func (_m *BaseNetworkSocketGetIpTtlResult) reset() {
	switch _m.I_baseNetworkSocketGetIpTtlResultTag {
	case 1:
		var _zeroed BaseNetworkSocketGetIpTtlResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseNetworkSocketGetIpTtlResult) Which() I_baseNetworkSocketGetIpTtlResultTag {
	return _m.I_baseNetworkSocketGetIpTtlResultTag
}

func (_m *BaseNetworkSocketGetIpTtlResult) Ordinal() uint64 {
	return uint64(_m.I_baseNetworkSocketGetIpTtlResultTag)
}

func (_m *BaseNetworkSocketGetIpTtlResult) SetResponse(response BaseNetworkSocketGetIpTtlResponse) {
	_m.reset()
	_m.I_baseNetworkSocketGetIpTtlResultTag = BaseNetworkSocketGetIpTtlResultResponse
	_m.Response = response
}

func BaseNetworkSocketGetIpTtlResultWithResponse(response BaseNetworkSocketGetIpTtlResponse) BaseNetworkSocketGetIpTtlResult {
	var _u BaseNetworkSocketGetIpTtlResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseNetworkSocketGetIpTtlResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseNetworkSocketGetIpTtlResultTag = BaseNetworkSocketGetIpTtlResultErr
	_m.Err = err
}

func BaseNetworkSocketGetIpTtlResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketGetIpTtlResult {
	var _u BaseNetworkSocketGetIpTtlResult
	_u.SetErr(err)
	return _u
}

type I_baseNetworkSocketSetIpPacketInfoResultTag uint64

const (
	BaseNetworkSocketSetIpPacketInfoResultResponse = 1 // 0x00000001
	BaseNetworkSocketSetIpPacketInfoResultErr      = 2 // 0x00000002
)

type BaseNetworkSocketSetIpPacketInfoResult struct {
	I_baseNetworkSocketSetIpPacketInfoResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                    BaseNetworkSocketSetIpPacketInfoResponse `fidl_ordinal:"1"`
	Err                                         fuchsiaposix.Errno                       `fidl_ordinal:"2"`
}

func (_m *BaseNetworkSocketSetIpPacketInfoResult) reset() {
	switch _m.I_baseNetworkSocketSetIpPacketInfoResultTag {
	case 1:
		var _zeroed BaseNetworkSocketSetIpPacketInfoResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseNetworkSocketSetIpPacketInfoResult) Which() I_baseNetworkSocketSetIpPacketInfoResultTag {
	return _m.I_baseNetworkSocketSetIpPacketInfoResultTag
}

func (_m *BaseNetworkSocketSetIpPacketInfoResult) Ordinal() uint64 {
	return uint64(_m.I_baseNetworkSocketSetIpPacketInfoResultTag)
}

func (_m *BaseNetworkSocketSetIpPacketInfoResult) SetResponse(response BaseNetworkSocketSetIpPacketInfoResponse) {
	_m.reset()
	_m.I_baseNetworkSocketSetIpPacketInfoResultTag = BaseNetworkSocketSetIpPacketInfoResultResponse
	_m.Response = response
}

func BaseNetworkSocketSetIpPacketInfoResultWithResponse(response BaseNetworkSocketSetIpPacketInfoResponse) BaseNetworkSocketSetIpPacketInfoResult {
	var _u BaseNetworkSocketSetIpPacketInfoResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseNetworkSocketSetIpPacketInfoResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseNetworkSocketSetIpPacketInfoResultTag = BaseNetworkSocketSetIpPacketInfoResultErr
	_m.Err = err
}

func BaseNetworkSocketSetIpPacketInfoResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketSetIpPacketInfoResult {
	var _u BaseNetworkSocketSetIpPacketInfoResult
	_u.SetErr(err)
	return _u
}

type I_baseNetworkSocketGetIpPacketInfoResultTag uint64

const (
	BaseNetworkSocketGetIpPacketInfoResultResponse = 1 // 0x00000001
	BaseNetworkSocketGetIpPacketInfoResultErr      = 2 // 0x00000002
)

type BaseNetworkSocketGetIpPacketInfoResult struct {
	I_baseNetworkSocketGetIpPacketInfoResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                    BaseNetworkSocketGetIpPacketInfoResponse `fidl_ordinal:"1"`
	Err                                         fuchsiaposix.Errno                       `fidl_ordinal:"2"`
}

func (_m *BaseNetworkSocketGetIpPacketInfoResult) reset() {
	switch _m.I_baseNetworkSocketGetIpPacketInfoResultTag {
	case 1:
		var _zeroed BaseNetworkSocketGetIpPacketInfoResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseNetworkSocketGetIpPacketInfoResult) Which() I_baseNetworkSocketGetIpPacketInfoResultTag {
	return _m.I_baseNetworkSocketGetIpPacketInfoResultTag
}

func (_m *BaseNetworkSocketGetIpPacketInfoResult) Ordinal() uint64 {
	return uint64(_m.I_baseNetworkSocketGetIpPacketInfoResultTag)
}

func (_m *BaseNetworkSocketGetIpPacketInfoResult) SetResponse(response BaseNetworkSocketGetIpPacketInfoResponse) {
	_m.reset()
	_m.I_baseNetworkSocketGetIpPacketInfoResultTag = BaseNetworkSocketGetIpPacketInfoResultResponse
	_m.Response = response
}

func BaseNetworkSocketGetIpPacketInfoResultWithResponse(response BaseNetworkSocketGetIpPacketInfoResponse) BaseNetworkSocketGetIpPacketInfoResult {
	var _u BaseNetworkSocketGetIpPacketInfoResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseNetworkSocketGetIpPacketInfoResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseNetworkSocketGetIpPacketInfoResultTag = BaseNetworkSocketGetIpPacketInfoResultErr
	_m.Err = err
}

func BaseNetworkSocketGetIpPacketInfoResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketGetIpPacketInfoResult {
	var _u BaseNetworkSocketGetIpPacketInfoResult
	_u.SetErr(err)
	return _u
}

type I_baseNetworkSocketSetIpReceiveTypeOfServiceResultTag uint64

const (
	BaseNetworkSocketSetIpReceiveTypeOfServiceResultResponse = 1 // 0x00000001
	BaseNetworkSocketSetIpReceiveTypeOfServiceResultErr      = 2 // 0x00000002
)

type BaseNetworkSocketSetIpReceiveTypeOfServiceResult struct {
	I_baseNetworkSocketSetIpReceiveTypeOfServiceResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                              BaseNetworkSocketSetIpReceiveTypeOfServiceResponse `fidl_ordinal:"1"`
	Err                                                   fuchsiaposix.Errno                                 `fidl_ordinal:"2"`
}

func (_m *BaseNetworkSocketSetIpReceiveTypeOfServiceResult) reset() {
	switch _m.I_baseNetworkSocketSetIpReceiveTypeOfServiceResultTag {
	case 1:
		var _zeroed BaseNetworkSocketSetIpReceiveTypeOfServiceResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseNetworkSocketSetIpReceiveTypeOfServiceResult) Which() I_baseNetworkSocketSetIpReceiveTypeOfServiceResultTag {
	return _m.I_baseNetworkSocketSetIpReceiveTypeOfServiceResultTag
}

func (_m *BaseNetworkSocketSetIpReceiveTypeOfServiceResult) Ordinal() uint64 {
	return uint64(_m.I_baseNetworkSocketSetIpReceiveTypeOfServiceResultTag)
}

func (_m *BaseNetworkSocketSetIpReceiveTypeOfServiceResult) SetResponse(response BaseNetworkSocketSetIpReceiveTypeOfServiceResponse) {
	_m.reset()
	_m.I_baseNetworkSocketSetIpReceiveTypeOfServiceResultTag = BaseNetworkSocketSetIpReceiveTypeOfServiceResultResponse
	_m.Response = response
}

func BaseNetworkSocketSetIpReceiveTypeOfServiceResultWithResponse(response BaseNetworkSocketSetIpReceiveTypeOfServiceResponse) BaseNetworkSocketSetIpReceiveTypeOfServiceResult {
	var _u BaseNetworkSocketSetIpReceiveTypeOfServiceResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseNetworkSocketSetIpReceiveTypeOfServiceResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseNetworkSocketSetIpReceiveTypeOfServiceResultTag = BaseNetworkSocketSetIpReceiveTypeOfServiceResultErr
	_m.Err = err
}

func BaseNetworkSocketSetIpReceiveTypeOfServiceResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketSetIpReceiveTypeOfServiceResult {
	var _u BaseNetworkSocketSetIpReceiveTypeOfServiceResult
	_u.SetErr(err)
	return _u
}

type I_baseNetworkSocketGetIpReceiveTypeOfServiceResultTag uint64

const (
	BaseNetworkSocketGetIpReceiveTypeOfServiceResultResponse = 1 // 0x00000001
	BaseNetworkSocketGetIpReceiveTypeOfServiceResultErr      = 2 // 0x00000002
)

type BaseNetworkSocketGetIpReceiveTypeOfServiceResult struct {
	I_baseNetworkSocketGetIpReceiveTypeOfServiceResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                              BaseNetworkSocketGetIpReceiveTypeOfServiceResponse `fidl_ordinal:"1"`
	Err                                                   fuchsiaposix.Errno                                 `fidl_ordinal:"2"`
}

func (_m *BaseNetworkSocketGetIpReceiveTypeOfServiceResult) reset() {
	switch _m.I_baseNetworkSocketGetIpReceiveTypeOfServiceResultTag {
	case 1:
		var _zeroed BaseNetworkSocketGetIpReceiveTypeOfServiceResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseNetworkSocketGetIpReceiveTypeOfServiceResult) Which() I_baseNetworkSocketGetIpReceiveTypeOfServiceResultTag {
	return _m.I_baseNetworkSocketGetIpReceiveTypeOfServiceResultTag
}

func (_m *BaseNetworkSocketGetIpReceiveTypeOfServiceResult) Ordinal() uint64 {
	return uint64(_m.I_baseNetworkSocketGetIpReceiveTypeOfServiceResultTag)
}

func (_m *BaseNetworkSocketGetIpReceiveTypeOfServiceResult) SetResponse(response BaseNetworkSocketGetIpReceiveTypeOfServiceResponse) {
	_m.reset()
	_m.I_baseNetworkSocketGetIpReceiveTypeOfServiceResultTag = BaseNetworkSocketGetIpReceiveTypeOfServiceResultResponse
	_m.Response = response
}

func BaseNetworkSocketGetIpReceiveTypeOfServiceResultWithResponse(response BaseNetworkSocketGetIpReceiveTypeOfServiceResponse) BaseNetworkSocketGetIpReceiveTypeOfServiceResult {
	var _u BaseNetworkSocketGetIpReceiveTypeOfServiceResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseNetworkSocketGetIpReceiveTypeOfServiceResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseNetworkSocketGetIpReceiveTypeOfServiceResultTag = BaseNetworkSocketGetIpReceiveTypeOfServiceResultErr
	_m.Err = err
}

func BaseNetworkSocketGetIpReceiveTypeOfServiceResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketGetIpReceiveTypeOfServiceResult {
	var _u BaseNetworkSocketGetIpReceiveTypeOfServiceResult
	_u.SetErr(err)
	return _u
}

type I_baseNetworkSocketSetIpMulticastInterfaceResultTag uint64

const (
	BaseNetworkSocketSetIpMulticastInterfaceResultResponse = 1 // 0x00000001
	BaseNetworkSocketSetIpMulticastInterfaceResultErr      = 2 // 0x00000002
)

type BaseNetworkSocketSetIpMulticastInterfaceResult struct {
	I_baseNetworkSocketSetIpMulticastInterfaceResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                            BaseNetworkSocketSetIpMulticastInterfaceResponse `fidl_ordinal:"1"`
	Err                                                 fuchsiaposix.Errno                               `fidl_ordinal:"2"`
}

func (_m *BaseNetworkSocketSetIpMulticastInterfaceResult) reset() {
	switch _m.I_baseNetworkSocketSetIpMulticastInterfaceResultTag {
	case 1:
		var _zeroed BaseNetworkSocketSetIpMulticastInterfaceResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseNetworkSocketSetIpMulticastInterfaceResult) Which() I_baseNetworkSocketSetIpMulticastInterfaceResultTag {
	return _m.I_baseNetworkSocketSetIpMulticastInterfaceResultTag
}

func (_m *BaseNetworkSocketSetIpMulticastInterfaceResult) Ordinal() uint64 {
	return uint64(_m.I_baseNetworkSocketSetIpMulticastInterfaceResultTag)
}

func (_m *BaseNetworkSocketSetIpMulticastInterfaceResult) SetResponse(response BaseNetworkSocketSetIpMulticastInterfaceResponse) {
	_m.reset()
	_m.I_baseNetworkSocketSetIpMulticastInterfaceResultTag = BaseNetworkSocketSetIpMulticastInterfaceResultResponse
	_m.Response = response
}

func BaseNetworkSocketSetIpMulticastInterfaceResultWithResponse(response BaseNetworkSocketSetIpMulticastInterfaceResponse) BaseNetworkSocketSetIpMulticastInterfaceResult {
	var _u BaseNetworkSocketSetIpMulticastInterfaceResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseNetworkSocketSetIpMulticastInterfaceResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseNetworkSocketSetIpMulticastInterfaceResultTag = BaseNetworkSocketSetIpMulticastInterfaceResultErr
	_m.Err = err
}

func BaseNetworkSocketSetIpMulticastInterfaceResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketSetIpMulticastInterfaceResult {
	var _u BaseNetworkSocketSetIpMulticastInterfaceResult
	_u.SetErr(err)
	return _u
}

type I_baseNetworkSocketGetIpMulticastInterfaceResultTag uint64

const (
	BaseNetworkSocketGetIpMulticastInterfaceResultResponse = 1 // 0x00000001
	BaseNetworkSocketGetIpMulticastInterfaceResultErr      = 2 // 0x00000002
)

type BaseNetworkSocketGetIpMulticastInterfaceResult struct {
	I_baseNetworkSocketGetIpMulticastInterfaceResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                            BaseNetworkSocketGetIpMulticastInterfaceResponse `fidl_ordinal:"1"`
	Err                                                 fuchsiaposix.Errno                               `fidl_ordinal:"2"`
}

func (_m *BaseNetworkSocketGetIpMulticastInterfaceResult) reset() {
	switch _m.I_baseNetworkSocketGetIpMulticastInterfaceResultTag {
	case 1:
		var _zeroed BaseNetworkSocketGetIpMulticastInterfaceResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseNetworkSocketGetIpMulticastInterfaceResult) Which() I_baseNetworkSocketGetIpMulticastInterfaceResultTag {
	return _m.I_baseNetworkSocketGetIpMulticastInterfaceResultTag
}

func (_m *BaseNetworkSocketGetIpMulticastInterfaceResult) Ordinal() uint64 {
	return uint64(_m.I_baseNetworkSocketGetIpMulticastInterfaceResultTag)
}

func (_m *BaseNetworkSocketGetIpMulticastInterfaceResult) SetResponse(response BaseNetworkSocketGetIpMulticastInterfaceResponse) {
	_m.reset()
	_m.I_baseNetworkSocketGetIpMulticastInterfaceResultTag = BaseNetworkSocketGetIpMulticastInterfaceResultResponse
	_m.Response = response
}

func BaseNetworkSocketGetIpMulticastInterfaceResultWithResponse(response BaseNetworkSocketGetIpMulticastInterfaceResponse) BaseNetworkSocketGetIpMulticastInterfaceResult {
	var _u BaseNetworkSocketGetIpMulticastInterfaceResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseNetworkSocketGetIpMulticastInterfaceResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseNetworkSocketGetIpMulticastInterfaceResultTag = BaseNetworkSocketGetIpMulticastInterfaceResultErr
	_m.Err = err
}

func BaseNetworkSocketGetIpMulticastInterfaceResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketGetIpMulticastInterfaceResult {
	var _u BaseNetworkSocketGetIpMulticastInterfaceResult
	_u.SetErr(err)
	return _u
}

type I_baseNetworkSocketSetIpMulticastTtlResultTag uint64

const (
	BaseNetworkSocketSetIpMulticastTtlResultResponse = 1 // 0x00000001
	BaseNetworkSocketSetIpMulticastTtlResultErr      = 2 // 0x00000002
)

type BaseNetworkSocketSetIpMulticastTtlResult struct {
	I_baseNetworkSocketSetIpMulticastTtlResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                      BaseNetworkSocketSetIpMulticastTtlResponse `fidl_ordinal:"1"`
	Err                                           fuchsiaposix.Errno                         `fidl_ordinal:"2"`
}

func (_m *BaseNetworkSocketSetIpMulticastTtlResult) reset() {
	switch _m.I_baseNetworkSocketSetIpMulticastTtlResultTag {
	case 1:
		var _zeroed BaseNetworkSocketSetIpMulticastTtlResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseNetworkSocketSetIpMulticastTtlResult) Which() I_baseNetworkSocketSetIpMulticastTtlResultTag {
	return _m.I_baseNetworkSocketSetIpMulticastTtlResultTag
}

func (_m *BaseNetworkSocketSetIpMulticastTtlResult) Ordinal() uint64 {
	return uint64(_m.I_baseNetworkSocketSetIpMulticastTtlResultTag)
}

func (_m *BaseNetworkSocketSetIpMulticastTtlResult) SetResponse(response BaseNetworkSocketSetIpMulticastTtlResponse) {
	_m.reset()
	_m.I_baseNetworkSocketSetIpMulticastTtlResultTag = BaseNetworkSocketSetIpMulticastTtlResultResponse
	_m.Response = response
}

func BaseNetworkSocketSetIpMulticastTtlResultWithResponse(response BaseNetworkSocketSetIpMulticastTtlResponse) BaseNetworkSocketSetIpMulticastTtlResult {
	var _u BaseNetworkSocketSetIpMulticastTtlResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseNetworkSocketSetIpMulticastTtlResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseNetworkSocketSetIpMulticastTtlResultTag = BaseNetworkSocketSetIpMulticastTtlResultErr
	_m.Err = err
}

func BaseNetworkSocketSetIpMulticastTtlResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketSetIpMulticastTtlResult {
	var _u BaseNetworkSocketSetIpMulticastTtlResult
	_u.SetErr(err)
	return _u
}

type I_baseNetworkSocketGetIpMulticastTtlResultTag uint64

const (
	BaseNetworkSocketGetIpMulticastTtlResultResponse = 1 // 0x00000001
	BaseNetworkSocketGetIpMulticastTtlResultErr      = 2 // 0x00000002
)

type BaseNetworkSocketGetIpMulticastTtlResult struct {
	I_baseNetworkSocketGetIpMulticastTtlResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                      BaseNetworkSocketGetIpMulticastTtlResponse `fidl_ordinal:"1"`
	Err                                           fuchsiaposix.Errno                         `fidl_ordinal:"2"`
}

func (_m *BaseNetworkSocketGetIpMulticastTtlResult) reset() {
	switch _m.I_baseNetworkSocketGetIpMulticastTtlResultTag {
	case 1:
		var _zeroed BaseNetworkSocketGetIpMulticastTtlResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseNetworkSocketGetIpMulticastTtlResult) Which() I_baseNetworkSocketGetIpMulticastTtlResultTag {
	return _m.I_baseNetworkSocketGetIpMulticastTtlResultTag
}

func (_m *BaseNetworkSocketGetIpMulticastTtlResult) Ordinal() uint64 {
	return uint64(_m.I_baseNetworkSocketGetIpMulticastTtlResultTag)
}

func (_m *BaseNetworkSocketGetIpMulticastTtlResult) SetResponse(response BaseNetworkSocketGetIpMulticastTtlResponse) {
	_m.reset()
	_m.I_baseNetworkSocketGetIpMulticastTtlResultTag = BaseNetworkSocketGetIpMulticastTtlResultResponse
	_m.Response = response
}

func BaseNetworkSocketGetIpMulticastTtlResultWithResponse(response BaseNetworkSocketGetIpMulticastTtlResponse) BaseNetworkSocketGetIpMulticastTtlResult {
	var _u BaseNetworkSocketGetIpMulticastTtlResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseNetworkSocketGetIpMulticastTtlResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseNetworkSocketGetIpMulticastTtlResultTag = BaseNetworkSocketGetIpMulticastTtlResultErr
	_m.Err = err
}

func BaseNetworkSocketGetIpMulticastTtlResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketGetIpMulticastTtlResult {
	var _u BaseNetworkSocketGetIpMulticastTtlResult
	_u.SetErr(err)
	return _u
}

type I_baseNetworkSocketSetIpMulticastLoopbackResultTag uint64

const (
	BaseNetworkSocketSetIpMulticastLoopbackResultResponse = 1 // 0x00000001
	BaseNetworkSocketSetIpMulticastLoopbackResultErr      = 2 // 0x00000002
)

type BaseNetworkSocketSetIpMulticastLoopbackResult struct {
	I_baseNetworkSocketSetIpMulticastLoopbackResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                           BaseNetworkSocketSetIpMulticastLoopbackResponse `fidl_ordinal:"1"`
	Err                                                fuchsiaposix.Errno                              `fidl_ordinal:"2"`
}

func (_m *BaseNetworkSocketSetIpMulticastLoopbackResult) reset() {
	switch _m.I_baseNetworkSocketSetIpMulticastLoopbackResultTag {
	case 1:
		var _zeroed BaseNetworkSocketSetIpMulticastLoopbackResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseNetworkSocketSetIpMulticastLoopbackResult) Which() I_baseNetworkSocketSetIpMulticastLoopbackResultTag {
	return _m.I_baseNetworkSocketSetIpMulticastLoopbackResultTag
}

func (_m *BaseNetworkSocketSetIpMulticastLoopbackResult) Ordinal() uint64 {
	return uint64(_m.I_baseNetworkSocketSetIpMulticastLoopbackResultTag)
}

func (_m *BaseNetworkSocketSetIpMulticastLoopbackResult) SetResponse(response BaseNetworkSocketSetIpMulticastLoopbackResponse) {
	_m.reset()
	_m.I_baseNetworkSocketSetIpMulticastLoopbackResultTag = BaseNetworkSocketSetIpMulticastLoopbackResultResponse
	_m.Response = response
}

func BaseNetworkSocketSetIpMulticastLoopbackResultWithResponse(response BaseNetworkSocketSetIpMulticastLoopbackResponse) BaseNetworkSocketSetIpMulticastLoopbackResult {
	var _u BaseNetworkSocketSetIpMulticastLoopbackResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseNetworkSocketSetIpMulticastLoopbackResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseNetworkSocketSetIpMulticastLoopbackResultTag = BaseNetworkSocketSetIpMulticastLoopbackResultErr
	_m.Err = err
}

func BaseNetworkSocketSetIpMulticastLoopbackResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketSetIpMulticastLoopbackResult {
	var _u BaseNetworkSocketSetIpMulticastLoopbackResult
	_u.SetErr(err)
	return _u
}

type I_baseNetworkSocketGetIpMulticastLoopbackResultTag uint64

const (
	BaseNetworkSocketGetIpMulticastLoopbackResultResponse = 1 // 0x00000001
	BaseNetworkSocketGetIpMulticastLoopbackResultErr      = 2 // 0x00000002
)

type BaseNetworkSocketGetIpMulticastLoopbackResult struct {
	I_baseNetworkSocketGetIpMulticastLoopbackResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                           BaseNetworkSocketGetIpMulticastLoopbackResponse `fidl_ordinal:"1"`
	Err                                                fuchsiaposix.Errno                              `fidl_ordinal:"2"`
}

func (_m *BaseNetworkSocketGetIpMulticastLoopbackResult) reset() {
	switch _m.I_baseNetworkSocketGetIpMulticastLoopbackResultTag {
	case 1:
		var _zeroed BaseNetworkSocketGetIpMulticastLoopbackResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseNetworkSocketGetIpMulticastLoopbackResult) Which() I_baseNetworkSocketGetIpMulticastLoopbackResultTag {
	return _m.I_baseNetworkSocketGetIpMulticastLoopbackResultTag
}

func (_m *BaseNetworkSocketGetIpMulticastLoopbackResult) Ordinal() uint64 {
	return uint64(_m.I_baseNetworkSocketGetIpMulticastLoopbackResultTag)
}

func (_m *BaseNetworkSocketGetIpMulticastLoopbackResult) SetResponse(response BaseNetworkSocketGetIpMulticastLoopbackResponse) {
	_m.reset()
	_m.I_baseNetworkSocketGetIpMulticastLoopbackResultTag = BaseNetworkSocketGetIpMulticastLoopbackResultResponse
	_m.Response = response
}

func BaseNetworkSocketGetIpMulticastLoopbackResultWithResponse(response BaseNetworkSocketGetIpMulticastLoopbackResponse) BaseNetworkSocketGetIpMulticastLoopbackResult {
	var _u BaseNetworkSocketGetIpMulticastLoopbackResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseNetworkSocketGetIpMulticastLoopbackResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseNetworkSocketGetIpMulticastLoopbackResultTag = BaseNetworkSocketGetIpMulticastLoopbackResultErr
	_m.Err = err
}

func BaseNetworkSocketGetIpMulticastLoopbackResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketGetIpMulticastLoopbackResult {
	var _u BaseNetworkSocketGetIpMulticastLoopbackResult
	_u.SetErr(err)
	return _u
}

type I_baseNetworkSocketAddIpMembershipResultTag uint64

const (
	BaseNetworkSocketAddIpMembershipResultResponse = 1 // 0x00000001
	BaseNetworkSocketAddIpMembershipResultErr      = 2 // 0x00000002
)

type BaseNetworkSocketAddIpMembershipResult struct {
	I_baseNetworkSocketAddIpMembershipResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                    BaseNetworkSocketAddIpMembershipResponse `fidl_ordinal:"1"`
	Err                                         fuchsiaposix.Errno                       `fidl_ordinal:"2"`
}

func (_m *BaseNetworkSocketAddIpMembershipResult) reset() {
	switch _m.I_baseNetworkSocketAddIpMembershipResultTag {
	case 1:
		var _zeroed BaseNetworkSocketAddIpMembershipResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseNetworkSocketAddIpMembershipResult) Which() I_baseNetworkSocketAddIpMembershipResultTag {
	return _m.I_baseNetworkSocketAddIpMembershipResultTag
}

func (_m *BaseNetworkSocketAddIpMembershipResult) Ordinal() uint64 {
	return uint64(_m.I_baseNetworkSocketAddIpMembershipResultTag)
}

func (_m *BaseNetworkSocketAddIpMembershipResult) SetResponse(response BaseNetworkSocketAddIpMembershipResponse) {
	_m.reset()
	_m.I_baseNetworkSocketAddIpMembershipResultTag = BaseNetworkSocketAddIpMembershipResultResponse
	_m.Response = response
}

func BaseNetworkSocketAddIpMembershipResultWithResponse(response BaseNetworkSocketAddIpMembershipResponse) BaseNetworkSocketAddIpMembershipResult {
	var _u BaseNetworkSocketAddIpMembershipResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseNetworkSocketAddIpMembershipResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseNetworkSocketAddIpMembershipResultTag = BaseNetworkSocketAddIpMembershipResultErr
	_m.Err = err
}

func BaseNetworkSocketAddIpMembershipResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketAddIpMembershipResult {
	var _u BaseNetworkSocketAddIpMembershipResult
	_u.SetErr(err)
	return _u
}

type I_baseNetworkSocketDropIpMembershipResultTag uint64

const (
	BaseNetworkSocketDropIpMembershipResultResponse = 1 // 0x00000001
	BaseNetworkSocketDropIpMembershipResultErr      = 2 // 0x00000002
)

type BaseNetworkSocketDropIpMembershipResult struct {
	I_baseNetworkSocketDropIpMembershipResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                     BaseNetworkSocketDropIpMembershipResponse `fidl_ordinal:"1"`
	Err                                          fuchsiaposix.Errno                        `fidl_ordinal:"2"`
}

func (_m *BaseNetworkSocketDropIpMembershipResult) reset() {
	switch _m.I_baseNetworkSocketDropIpMembershipResultTag {
	case 1:
		var _zeroed BaseNetworkSocketDropIpMembershipResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseNetworkSocketDropIpMembershipResult) Which() I_baseNetworkSocketDropIpMembershipResultTag {
	return _m.I_baseNetworkSocketDropIpMembershipResultTag
}

func (_m *BaseNetworkSocketDropIpMembershipResult) Ordinal() uint64 {
	return uint64(_m.I_baseNetworkSocketDropIpMembershipResultTag)
}

func (_m *BaseNetworkSocketDropIpMembershipResult) SetResponse(response BaseNetworkSocketDropIpMembershipResponse) {
	_m.reset()
	_m.I_baseNetworkSocketDropIpMembershipResultTag = BaseNetworkSocketDropIpMembershipResultResponse
	_m.Response = response
}

func BaseNetworkSocketDropIpMembershipResultWithResponse(response BaseNetworkSocketDropIpMembershipResponse) BaseNetworkSocketDropIpMembershipResult {
	var _u BaseNetworkSocketDropIpMembershipResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseNetworkSocketDropIpMembershipResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseNetworkSocketDropIpMembershipResultTag = BaseNetworkSocketDropIpMembershipResultErr
	_m.Err = err
}

func BaseNetworkSocketDropIpMembershipResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketDropIpMembershipResult {
	var _u BaseNetworkSocketDropIpMembershipResult
	_u.SetErr(err)
	return _u
}

type I_baseNetworkSocketAddIpv6MembershipResultTag uint64

const (
	BaseNetworkSocketAddIpv6MembershipResultResponse = 1 // 0x00000001
	BaseNetworkSocketAddIpv6MembershipResultErr      = 2 // 0x00000002
)

type BaseNetworkSocketAddIpv6MembershipResult struct {
	I_baseNetworkSocketAddIpv6MembershipResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                      BaseNetworkSocketAddIpv6MembershipResponse `fidl_ordinal:"1"`
	Err                                           fuchsiaposix.Errno                         `fidl_ordinal:"2"`
}

func (_m *BaseNetworkSocketAddIpv6MembershipResult) reset() {
	switch _m.I_baseNetworkSocketAddIpv6MembershipResultTag {
	case 1:
		var _zeroed BaseNetworkSocketAddIpv6MembershipResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseNetworkSocketAddIpv6MembershipResult) Which() I_baseNetworkSocketAddIpv6MembershipResultTag {
	return _m.I_baseNetworkSocketAddIpv6MembershipResultTag
}

func (_m *BaseNetworkSocketAddIpv6MembershipResult) Ordinal() uint64 {
	return uint64(_m.I_baseNetworkSocketAddIpv6MembershipResultTag)
}

func (_m *BaseNetworkSocketAddIpv6MembershipResult) SetResponse(response BaseNetworkSocketAddIpv6MembershipResponse) {
	_m.reset()
	_m.I_baseNetworkSocketAddIpv6MembershipResultTag = BaseNetworkSocketAddIpv6MembershipResultResponse
	_m.Response = response
}

func BaseNetworkSocketAddIpv6MembershipResultWithResponse(response BaseNetworkSocketAddIpv6MembershipResponse) BaseNetworkSocketAddIpv6MembershipResult {
	var _u BaseNetworkSocketAddIpv6MembershipResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseNetworkSocketAddIpv6MembershipResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseNetworkSocketAddIpv6MembershipResultTag = BaseNetworkSocketAddIpv6MembershipResultErr
	_m.Err = err
}

func BaseNetworkSocketAddIpv6MembershipResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketAddIpv6MembershipResult {
	var _u BaseNetworkSocketAddIpv6MembershipResult
	_u.SetErr(err)
	return _u
}

type I_baseNetworkSocketDropIpv6MembershipResultTag uint64

const (
	BaseNetworkSocketDropIpv6MembershipResultResponse = 1 // 0x00000001
	BaseNetworkSocketDropIpv6MembershipResultErr      = 2 // 0x00000002
)

type BaseNetworkSocketDropIpv6MembershipResult struct {
	I_baseNetworkSocketDropIpv6MembershipResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                       BaseNetworkSocketDropIpv6MembershipResponse `fidl_ordinal:"1"`
	Err                                            fuchsiaposix.Errno                          `fidl_ordinal:"2"`
}

func (_m *BaseNetworkSocketDropIpv6MembershipResult) reset() {
	switch _m.I_baseNetworkSocketDropIpv6MembershipResultTag {
	case 1:
		var _zeroed BaseNetworkSocketDropIpv6MembershipResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseNetworkSocketDropIpv6MembershipResult) Which() I_baseNetworkSocketDropIpv6MembershipResultTag {
	return _m.I_baseNetworkSocketDropIpv6MembershipResultTag
}

func (_m *BaseNetworkSocketDropIpv6MembershipResult) Ordinal() uint64 {
	return uint64(_m.I_baseNetworkSocketDropIpv6MembershipResultTag)
}

func (_m *BaseNetworkSocketDropIpv6MembershipResult) SetResponse(response BaseNetworkSocketDropIpv6MembershipResponse) {
	_m.reset()
	_m.I_baseNetworkSocketDropIpv6MembershipResultTag = BaseNetworkSocketDropIpv6MembershipResultResponse
	_m.Response = response
}

func BaseNetworkSocketDropIpv6MembershipResultWithResponse(response BaseNetworkSocketDropIpv6MembershipResponse) BaseNetworkSocketDropIpv6MembershipResult {
	var _u BaseNetworkSocketDropIpv6MembershipResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseNetworkSocketDropIpv6MembershipResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseNetworkSocketDropIpv6MembershipResultTag = BaseNetworkSocketDropIpv6MembershipResultErr
	_m.Err = err
}

func BaseNetworkSocketDropIpv6MembershipResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketDropIpv6MembershipResult {
	var _u BaseNetworkSocketDropIpv6MembershipResult
	_u.SetErr(err)
	return _u
}

type I_baseNetworkSocketSetIpv6MulticastInterfaceResultTag uint64

const (
	BaseNetworkSocketSetIpv6MulticastInterfaceResultResponse = 1 // 0x00000001
	BaseNetworkSocketSetIpv6MulticastInterfaceResultErr      = 2 // 0x00000002
)

type BaseNetworkSocketSetIpv6MulticastInterfaceResult struct {
	I_baseNetworkSocketSetIpv6MulticastInterfaceResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                              BaseNetworkSocketSetIpv6MulticastInterfaceResponse `fidl_ordinal:"1"`
	Err                                                   fuchsiaposix.Errno                                 `fidl_ordinal:"2"`
}

func (_m *BaseNetworkSocketSetIpv6MulticastInterfaceResult) reset() {
	switch _m.I_baseNetworkSocketSetIpv6MulticastInterfaceResultTag {
	case 1:
		var _zeroed BaseNetworkSocketSetIpv6MulticastInterfaceResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseNetworkSocketSetIpv6MulticastInterfaceResult) Which() I_baseNetworkSocketSetIpv6MulticastInterfaceResultTag {
	return _m.I_baseNetworkSocketSetIpv6MulticastInterfaceResultTag
}

func (_m *BaseNetworkSocketSetIpv6MulticastInterfaceResult) Ordinal() uint64 {
	return uint64(_m.I_baseNetworkSocketSetIpv6MulticastInterfaceResultTag)
}

func (_m *BaseNetworkSocketSetIpv6MulticastInterfaceResult) SetResponse(response BaseNetworkSocketSetIpv6MulticastInterfaceResponse) {
	_m.reset()
	_m.I_baseNetworkSocketSetIpv6MulticastInterfaceResultTag = BaseNetworkSocketSetIpv6MulticastInterfaceResultResponse
	_m.Response = response
}

func BaseNetworkSocketSetIpv6MulticastInterfaceResultWithResponse(response BaseNetworkSocketSetIpv6MulticastInterfaceResponse) BaseNetworkSocketSetIpv6MulticastInterfaceResult {
	var _u BaseNetworkSocketSetIpv6MulticastInterfaceResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseNetworkSocketSetIpv6MulticastInterfaceResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseNetworkSocketSetIpv6MulticastInterfaceResultTag = BaseNetworkSocketSetIpv6MulticastInterfaceResultErr
	_m.Err = err
}

func BaseNetworkSocketSetIpv6MulticastInterfaceResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketSetIpv6MulticastInterfaceResult {
	var _u BaseNetworkSocketSetIpv6MulticastInterfaceResult
	_u.SetErr(err)
	return _u
}

type I_baseNetworkSocketGetIpv6MulticastInterfaceResultTag uint64

const (
	BaseNetworkSocketGetIpv6MulticastInterfaceResultResponse = 1 // 0x00000001
	BaseNetworkSocketGetIpv6MulticastInterfaceResultErr      = 2 // 0x00000002
)

type BaseNetworkSocketGetIpv6MulticastInterfaceResult struct {
	I_baseNetworkSocketGetIpv6MulticastInterfaceResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                              BaseNetworkSocketGetIpv6MulticastInterfaceResponse `fidl_ordinal:"1"`
	Err                                                   fuchsiaposix.Errno                                 `fidl_ordinal:"2"`
}

func (_m *BaseNetworkSocketGetIpv6MulticastInterfaceResult) reset() {
	switch _m.I_baseNetworkSocketGetIpv6MulticastInterfaceResultTag {
	case 1:
		var _zeroed BaseNetworkSocketGetIpv6MulticastInterfaceResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseNetworkSocketGetIpv6MulticastInterfaceResult) Which() I_baseNetworkSocketGetIpv6MulticastInterfaceResultTag {
	return _m.I_baseNetworkSocketGetIpv6MulticastInterfaceResultTag
}

func (_m *BaseNetworkSocketGetIpv6MulticastInterfaceResult) Ordinal() uint64 {
	return uint64(_m.I_baseNetworkSocketGetIpv6MulticastInterfaceResultTag)
}

func (_m *BaseNetworkSocketGetIpv6MulticastInterfaceResult) SetResponse(response BaseNetworkSocketGetIpv6MulticastInterfaceResponse) {
	_m.reset()
	_m.I_baseNetworkSocketGetIpv6MulticastInterfaceResultTag = BaseNetworkSocketGetIpv6MulticastInterfaceResultResponse
	_m.Response = response
}

func BaseNetworkSocketGetIpv6MulticastInterfaceResultWithResponse(response BaseNetworkSocketGetIpv6MulticastInterfaceResponse) BaseNetworkSocketGetIpv6MulticastInterfaceResult {
	var _u BaseNetworkSocketGetIpv6MulticastInterfaceResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseNetworkSocketGetIpv6MulticastInterfaceResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseNetworkSocketGetIpv6MulticastInterfaceResultTag = BaseNetworkSocketGetIpv6MulticastInterfaceResultErr
	_m.Err = err
}

func BaseNetworkSocketGetIpv6MulticastInterfaceResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketGetIpv6MulticastInterfaceResult {
	var _u BaseNetworkSocketGetIpv6MulticastInterfaceResult
	_u.SetErr(err)
	return _u
}

type I_baseNetworkSocketSetIpv6MulticastHopsResultTag uint64

const (
	BaseNetworkSocketSetIpv6MulticastHopsResultResponse = 1 // 0x00000001
	BaseNetworkSocketSetIpv6MulticastHopsResultErr      = 2 // 0x00000002
)

type BaseNetworkSocketSetIpv6MulticastHopsResult struct {
	I_baseNetworkSocketSetIpv6MulticastHopsResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                         BaseNetworkSocketSetIpv6MulticastHopsResponse `fidl_ordinal:"1"`
	Err                                              fuchsiaposix.Errno                            `fidl_ordinal:"2"`
}

func (_m *BaseNetworkSocketSetIpv6MulticastHopsResult) reset() {
	switch _m.I_baseNetworkSocketSetIpv6MulticastHopsResultTag {
	case 1:
		var _zeroed BaseNetworkSocketSetIpv6MulticastHopsResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseNetworkSocketSetIpv6MulticastHopsResult) Which() I_baseNetworkSocketSetIpv6MulticastHopsResultTag {
	return _m.I_baseNetworkSocketSetIpv6MulticastHopsResultTag
}

func (_m *BaseNetworkSocketSetIpv6MulticastHopsResult) Ordinal() uint64 {
	return uint64(_m.I_baseNetworkSocketSetIpv6MulticastHopsResultTag)
}

func (_m *BaseNetworkSocketSetIpv6MulticastHopsResult) SetResponse(response BaseNetworkSocketSetIpv6MulticastHopsResponse) {
	_m.reset()
	_m.I_baseNetworkSocketSetIpv6MulticastHopsResultTag = BaseNetworkSocketSetIpv6MulticastHopsResultResponse
	_m.Response = response
}

func BaseNetworkSocketSetIpv6MulticastHopsResultWithResponse(response BaseNetworkSocketSetIpv6MulticastHopsResponse) BaseNetworkSocketSetIpv6MulticastHopsResult {
	var _u BaseNetworkSocketSetIpv6MulticastHopsResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseNetworkSocketSetIpv6MulticastHopsResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseNetworkSocketSetIpv6MulticastHopsResultTag = BaseNetworkSocketSetIpv6MulticastHopsResultErr
	_m.Err = err
}

func BaseNetworkSocketSetIpv6MulticastHopsResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketSetIpv6MulticastHopsResult {
	var _u BaseNetworkSocketSetIpv6MulticastHopsResult
	_u.SetErr(err)
	return _u
}

type I_baseNetworkSocketGetIpv6MulticastHopsResultTag uint64

const (
	BaseNetworkSocketGetIpv6MulticastHopsResultResponse = 1 // 0x00000001
	BaseNetworkSocketGetIpv6MulticastHopsResultErr      = 2 // 0x00000002
)

type BaseNetworkSocketGetIpv6MulticastHopsResult struct {
	I_baseNetworkSocketGetIpv6MulticastHopsResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                         BaseNetworkSocketGetIpv6MulticastHopsResponse `fidl_ordinal:"1"`
	Err                                              fuchsiaposix.Errno                            `fidl_ordinal:"2"`
}

func (_m *BaseNetworkSocketGetIpv6MulticastHopsResult) reset() {
	switch _m.I_baseNetworkSocketGetIpv6MulticastHopsResultTag {
	case 1:
		var _zeroed BaseNetworkSocketGetIpv6MulticastHopsResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseNetworkSocketGetIpv6MulticastHopsResult) Which() I_baseNetworkSocketGetIpv6MulticastHopsResultTag {
	return _m.I_baseNetworkSocketGetIpv6MulticastHopsResultTag
}

func (_m *BaseNetworkSocketGetIpv6MulticastHopsResult) Ordinal() uint64 {
	return uint64(_m.I_baseNetworkSocketGetIpv6MulticastHopsResultTag)
}

func (_m *BaseNetworkSocketGetIpv6MulticastHopsResult) SetResponse(response BaseNetworkSocketGetIpv6MulticastHopsResponse) {
	_m.reset()
	_m.I_baseNetworkSocketGetIpv6MulticastHopsResultTag = BaseNetworkSocketGetIpv6MulticastHopsResultResponse
	_m.Response = response
}

func BaseNetworkSocketGetIpv6MulticastHopsResultWithResponse(response BaseNetworkSocketGetIpv6MulticastHopsResponse) BaseNetworkSocketGetIpv6MulticastHopsResult {
	var _u BaseNetworkSocketGetIpv6MulticastHopsResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseNetworkSocketGetIpv6MulticastHopsResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseNetworkSocketGetIpv6MulticastHopsResultTag = BaseNetworkSocketGetIpv6MulticastHopsResultErr
	_m.Err = err
}

func BaseNetworkSocketGetIpv6MulticastHopsResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketGetIpv6MulticastHopsResult {
	var _u BaseNetworkSocketGetIpv6MulticastHopsResult
	_u.SetErr(err)
	return _u
}

type I_baseNetworkSocketSetIpv6MulticastLoopbackResultTag uint64

const (
	BaseNetworkSocketSetIpv6MulticastLoopbackResultResponse = 1 // 0x00000001
	BaseNetworkSocketSetIpv6MulticastLoopbackResultErr      = 2 // 0x00000002
)

type BaseNetworkSocketSetIpv6MulticastLoopbackResult struct {
	I_baseNetworkSocketSetIpv6MulticastLoopbackResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                             BaseNetworkSocketSetIpv6MulticastLoopbackResponse `fidl_ordinal:"1"`
	Err                                                  fuchsiaposix.Errno                                `fidl_ordinal:"2"`
}

func (_m *BaseNetworkSocketSetIpv6MulticastLoopbackResult) reset() {
	switch _m.I_baseNetworkSocketSetIpv6MulticastLoopbackResultTag {
	case 1:
		var _zeroed BaseNetworkSocketSetIpv6MulticastLoopbackResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseNetworkSocketSetIpv6MulticastLoopbackResult) Which() I_baseNetworkSocketSetIpv6MulticastLoopbackResultTag {
	return _m.I_baseNetworkSocketSetIpv6MulticastLoopbackResultTag
}

func (_m *BaseNetworkSocketSetIpv6MulticastLoopbackResult) Ordinal() uint64 {
	return uint64(_m.I_baseNetworkSocketSetIpv6MulticastLoopbackResultTag)
}

func (_m *BaseNetworkSocketSetIpv6MulticastLoopbackResult) SetResponse(response BaseNetworkSocketSetIpv6MulticastLoopbackResponse) {
	_m.reset()
	_m.I_baseNetworkSocketSetIpv6MulticastLoopbackResultTag = BaseNetworkSocketSetIpv6MulticastLoopbackResultResponse
	_m.Response = response
}

func BaseNetworkSocketSetIpv6MulticastLoopbackResultWithResponse(response BaseNetworkSocketSetIpv6MulticastLoopbackResponse) BaseNetworkSocketSetIpv6MulticastLoopbackResult {
	var _u BaseNetworkSocketSetIpv6MulticastLoopbackResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseNetworkSocketSetIpv6MulticastLoopbackResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseNetworkSocketSetIpv6MulticastLoopbackResultTag = BaseNetworkSocketSetIpv6MulticastLoopbackResultErr
	_m.Err = err
}

func BaseNetworkSocketSetIpv6MulticastLoopbackResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketSetIpv6MulticastLoopbackResult {
	var _u BaseNetworkSocketSetIpv6MulticastLoopbackResult
	_u.SetErr(err)
	return _u
}

type I_baseNetworkSocketGetIpv6MulticastLoopbackResultTag uint64

const (
	BaseNetworkSocketGetIpv6MulticastLoopbackResultResponse = 1 // 0x00000001
	BaseNetworkSocketGetIpv6MulticastLoopbackResultErr      = 2 // 0x00000002
)

type BaseNetworkSocketGetIpv6MulticastLoopbackResult struct {
	I_baseNetworkSocketGetIpv6MulticastLoopbackResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                             BaseNetworkSocketGetIpv6MulticastLoopbackResponse `fidl_ordinal:"1"`
	Err                                                  fuchsiaposix.Errno                                `fidl_ordinal:"2"`
}

func (_m *BaseNetworkSocketGetIpv6MulticastLoopbackResult) reset() {
	switch _m.I_baseNetworkSocketGetIpv6MulticastLoopbackResultTag {
	case 1:
		var _zeroed BaseNetworkSocketGetIpv6MulticastLoopbackResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseNetworkSocketGetIpv6MulticastLoopbackResult) Which() I_baseNetworkSocketGetIpv6MulticastLoopbackResultTag {
	return _m.I_baseNetworkSocketGetIpv6MulticastLoopbackResultTag
}

func (_m *BaseNetworkSocketGetIpv6MulticastLoopbackResult) Ordinal() uint64 {
	return uint64(_m.I_baseNetworkSocketGetIpv6MulticastLoopbackResultTag)
}

func (_m *BaseNetworkSocketGetIpv6MulticastLoopbackResult) SetResponse(response BaseNetworkSocketGetIpv6MulticastLoopbackResponse) {
	_m.reset()
	_m.I_baseNetworkSocketGetIpv6MulticastLoopbackResultTag = BaseNetworkSocketGetIpv6MulticastLoopbackResultResponse
	_m.Response = response
}

func BaseNetworkSocketGetIpv6MulticastLoopbackResultWithResponse(response BaseNetworkSocketGetIpv6MulticastLoopbackResponse) BaseNetworkSocketGetIpv6MulticastLoopbackResult {
	var _u BaseNetworkSocketGetIpv6MulticastLoopbackResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseNetworkSocketGetIpv6MulticastLoopbackResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseNetworkSocketGetIpv6MulticastLoopbackResultTag = BaseNetworkSocketGetIpv6MulticastLoopbackResultErr
	_m.Err = err
}

func BaseNetworkSocketGetIpv6MulticastLoopbackResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketGetIpv6MulticastLoopbackResult {
	var _u BaseNetworkSocketGetIpv6MulticastLoopbackResult
	_u.SetErr(err)
	return _u
}

type I_baseNetworkSocketSetIpv6OnlyResultTag uint64

const (
	BaseNetworkSocketSetIpv6OnlyResultResponse = 1 // 0x00000001
	BaseNetworkSocketSetIpv6OnlyResultErr      = 2 // 0x00000002
)

type BaseNetworkSocketSetIpv6OnlyResult struct {
	I_baseNetworkSocketSetIpv6OnlyResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                BaseNetworkSocketSetIpv6OnlyResponse `fidl_ordinal:"1"`
	Err                                     fuchsiaposix.Errno                   `fidl_ordinal:"2"`
}

func (_m *BaseNetworkSocketSetIpv6OnlyResult) reset() {
	switch _m.I_baseNetworkSocketSetIpv6OnlyResultTag {
	case 1:
		var _zeroed BaseNetworkSocketSetIpv6OnlyResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseNetworkSocketSetIpv6OnlyResult) Which() I_baseNetworkSocketSetIpv6OnlyResultTag {
	return _m.I_baseNetworkSocketSetIpv6OnlyResultTag
}

func (_m *BaseNetworkSocketSetIpv6OnlyResult) Ordinal() uint64 {
	return uint64(_m.I_baseNetworkSocketSetIpv6OnlyResultTag)
}

func (_m *BaseNetworkSocketSetIpv6OnlyResult) SetResponse(response BaseNetworkSocketSetIpv6OnlyResponse) {
	_m.reset()
	_m.I_baseNetworkSocketSetIpv6OnlyResultTag = BaseNetworkSocketSetIpv6OnlyResultResponse
	_m.Response = response
}

func BaseNetworkSocketSetIpv6OnlyResultWithResponse(response BaseNetworkSocketSetIpv6OnlyResponse) BaseNetworkSocketSetIpv6OnlyResult {
	var _u BaseNetworkSocketSetIpv6OnlyResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseNetworkSocketSetIpv6OnlyResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseNetworkSocketSetIpv6OnlyResultTag = BaseNetworkSocketSetIpv6OnlyResultErr
	_m.Err = err
}

func BaseNetworkSocketSetIpv6OnlyResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketSetIpv6OnlyResult {
	var _u BaseNetworkSocketSetIpv6OnlyResult
	_u.SetErr(err)
	return _u
}

type I_baseNetworkSocketGetIpv6OnlyResultTag uint64

const (
	BaseNetworkSocketGetIpv6OnlyResultResponse = 1 // 0x00000001
	BaseNetworkSocketGetIpv6OnlyResultErr      = 2 // 0x00000002
)

type BaseNetworkSocketGetIpv6OnlyResult struct {
	I_baseNetworkSocketGetIpv6OnlyResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                BaseNetworkSocketGetIpv6OnlyResponse `fidl_ordinal:"1"`
	Err                                     fuchsiaposix.Errno                   `fidl_ordinal:"2"`
}

func (_m *BaseNetworkSocketGetIpv6OnlyResult) reset() {
	switch _m.I_baseNetworkSocketGetIpv6OnlyResultTag {
	case 1:
		var _zeroed BaseNetworkSocketGetIpv6OnlyResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseNetworkSocketGetIpv6OnlyResult) Which() I_baseNetworkSocketGetIpv6OnlyResultTag {
	return _m.I_baseNetworkSocketGetIpv6OnlyResultTag
}

func (_m *BaseNetworkSocketGetIpv6OnlyResult) Ordinal() uint64 {
	return uint64(_m.I_baseNetworkSocketGetIpv6OnlyResultTag)
}

func (_m *BaseNetworkSocketGetIpv6OnlyResult) SetResponse(response BaseNetworkSocketGetIpv6OnlyResponse) {
	_m.reset()
	_m.I_baseNetworkSocketGetIpv6OnlyResultTag = BaseNetworkSocketGetIpv6OnlyResultResponse
	_m.Response = response
}

func BaseNetworkSocketGetIpv6OnlyResultWithResponse(response BaseNetworkSocketGetIpv6OnlyResponse) BaseNetworkSocketGetIpv6OnlyResult {
	var _u BaseNetworkSocketGetIpv6OnlyResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseNetworkSocketGetIpv6OnlyResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseNetworkSocketGetIpv6OnlyResultTag = BaseNetworkSocketGetIpv6OnlyResultErr
	_m.Err = err
}

func BaseNetworkSocketGetIpv6OnlyResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketGetIpv6OnlyResult {
	var _u BaseNetworkSocketGetIpv6OnlyResult
	_u.SetErr(err)
	return _u
}

type I_baseNetworkSocketSetIpv6ReceiveTrafficClassResultTag uint64

const (
	BaseNetworkSocketSetIpv6ReceiveTrafficClassResultResponse = 1 // 0x00000001
	BaseNetworkSocketSetIpv6ReceiveTrafficClassResultErr      = 2 // 0x00000002
)

type BaseNetworkSocketSetIpv6ReceiveTrafficClassResult struct {
	I_baseNetworkSocketSetIpv6ReceiveTrafficClassResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                               BaseNetworkSocketSetIpv6ReceiveTrafficClassResponse `fidl_ordinal:"1"`
	Err                                                    fuchsiaposix.Errno                                  `fidl_ordinal:"2"`
}

func (_m *BaseNetworkSocketSetIpv6ReceiveTrafficClassResult) reset() {
	switch _m.I_baseNetworkSocketSetIpv6ReceiveTrafficClassResultTag {
	case 1:
		var _zeroed BaseNetworkSocketSetIpv6ReceiveTrafficClassResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseNetworkSocketSetIpv6ReceiveTrafficClassResult) Which() I_baseNetworkSocketSetIpv6ReceiveTrafficClassResultTag {
	return _m.I_baseNetworkSocketSetIpv6ReceiveTrafficClassResultTag
}

func (_m *BaseNetworkSocketSetIpv6ReceiveTrafficClassResult) Ordinal() uint64 {
	return uint64(_m.I_baseNetworkSocketSetIpv6ReceiveTrafficClassResultTag)
}

func (_m *BaseNetworkSocketSetIpv6ReceiveTrafficClassResult) SetResponse(response BaseNetworkSocketSetIpv6ReceiveTrafficClassResponse) {
	_m.reset()
	_m.I_baseNetworkSocketSetIpv6ReceiveTrafficClassResultTag = BaseNetworkSocketSetIpv6ReceiveTrafficClassResultResponse
	_m.Response = response
}

func BaseNetworkSocketSetIpv6ReceiveTrafficClassResultWithResponse(response BaseNetworkSocketSetIpv6ReceiveTrafficClassResponse) BaseNetworkSocketSetIpv6ReceiveTrafficClassResult {
	var _u BaseNetworkSocketSetIpv6ReceiveTrafficClassResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseNetworkSocketSetIpv6ReceiveTrafficClassResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseNetworkSocketSetIpv6ReceiveTrafficClassResultTag = BaseNetworkSocketSetIpv6ReceiveTrafficClassResultErr
	_m.Err = err
}

func BaseNetworkSocketSetIpv6ReceiveTrafficClassResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketSetIpv6ReceiveTrafficClassResult {
	var _u BaseNetworkSocketSetIpv6ReceiveTrafficClassResult
	_u.SetErr(err)
	return _u
}

type I_baseNetworkSocketGetIpv6ReceiveTrafficClassResultTag uint64

const (
	BaseNetworkSocketGetIpv6ReceiveTrafficClassResultResponse = 1 // 0x00000001
	BaseNetworkSocketGetIpv6ReceiveTrafficClassResultErr      = 2 // 0x00000002
)

type BaseNetworkSocketGetIpv6ReceiveTrafficClassResult struct {
	I_baseNetworkSocketGetIpv6ReceiveTrafficClassResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                               BaseNetworkSocketGetIpv6ReceiveTrafficClassResponse `fidl_ordinal:"1"`
	Err                                                    fuchsiaposix.Errno                                  `fidl_ordinal:"2"`
}

func (_m *BaseNetworkSocketGetIpv6ReceiveTrafficClassResult) reset() {
	switch _m.I_baseNetworkSocketGetIpv6ReceiveTrafficClassResultTag {
	case 1:
		var _zeroed BaseNetworkSocketGetIpv6ReceiveTrafficClassResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseNetworkSocketGetIpv6ReceiveTrafficClassResult) Which() I_baseNetworkSocketGetIpv6ReceiveTrafficClassResultTag {
	return _m.I_baseNetworkSocketGetIpv6ReceiveTrafficClassResultTag
}

func (_m *BaseNetworkSocketGetIpv6ReceiveTrafficClassResult) Ordinal() uint64 {
	return uint64(_m.I_baseNetworkSocketGetIpv6ReceiveTrafficClassResultTag)
}

func (_m *BaseNetworkSocketGetIpv6ReceiveTrafficClassResult) SetResponse(response BaseNetworkSocketGetIpv6ReceiveTrafficClassResponse) {
	_m.reset()
	_m.I_baseNetworkSocketGetIpv6ReceiveTrafficClassResultTag = BaseNetworkSocketGetIpv6ReceiveTrafficClassResultResponse
	_m.Response = response
}

func BaseNetworkSocketGetIpv6ReceiveTrafficClassResultWithResponse(response BaseNetworkSocketGetIpv6ReceiveTrafficClassResponse) BaseNetworkSocketGetIpv6ReceiveTrafficClassResult {
	var _u BaseNetworkSocketGetIpv6ReceiveTrafficClassResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseNetworkSocketGetIpv6ReceiveTrafficClassResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseNetworkSocketGetIpv6ReceiveTrafficClassResultTag = BaseNetworkSocketGetIpv6ReceiveTrafficClassResultErr
	_m.Err = err
}

func BaseNetworkSocketGetIpv6ReceiveTrafficClassResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketGetIpv6ReceiveTrafficClassResult {
	var _u BaseNetworkSocketGetIpv6ReceiveTrafficClassResult
	_u.SetErr(err)
	return _u
}

type I_baseNetworkSocketSetIpv6TrafficClassResultTag uint64

const (
	BaseNetworkSocketSetIpv6TrafficClassResultResponse = 1 // 0x00000001
	BaseNetworkSocketSetIpv6TrafficClassResultErr      = 2 // 0x00000002
)

type BaseNetworkSocketSetIpv6TrafficClassResult struct {
	I_baseNetworkSocketSetIpv6TrafficClassResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                        BaseNetworkSocketSetIpv6TrafficClassResponse `fidl_ordinal:"1"`
	Err                                             fuchsiaposix.Errno                           `fidl_ordinal:"2"`
}

func (_m *BaseNetworkSocketSetIpv6TrafficClassResult) reset() {
	switch _m.I_baseNetworkSocketSetIpv6TrafficClassResultTag {
	case 1:
		var _zeroed BaseNetworkSocketSetIpv6TrafficClassResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseNetworkSocketSetIpv6TrafficClassResult) Which() I_baseNetworkSocketSetIpv6TrafficClassResultTag {
	return _m.I_baseNetworkSocketSetIpv6TrafficClassResultTag
}

func (_m *BaseNetworkSocketSetIpv6TrafficClassResult) Ordinal() uint64 {
	return uint64(_m.I_baseNetworkSocketSetIpv6TrafficClassResultTag)
}

func (_m *BaseNetworkSocketSetIpv6TrafficClassResult) SetResponse(response BaseNetworkSocketSetIpv6TrafficClassResponse) {
	_m.reset()
	_m.I_baseNetworkSocketSetIpv6TrafficClassResultTag = BaseNetworkSocketSetIpv6TrafficClassResultResponse
	_m.Response = response
}

func BaseNetworkSocketSetIpv6TrafficClassResultWithResponse(response BaseNetworkSocketSetIpv6TrafficClassResponse) BaseNetworkSocketSetIpv6TrafficClassResult {
	var _u BaseNetworkSocketSetIpv6TrafficClassResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseNetworkSocketSetIpv6TrafficClassResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseNetworkSocketSetIpv6TrafficClassResultTag = BaseNetworkSocketSetIpv6TrafficClassResultErr
	_m.Err = err
}

func BaseNetworkSocketSetIpv6TrafficClassResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketSetIpv6TrafficClassResult {
	var _u BaseNetworkSocketSetIpv6TrafficClassResult
	_u.SetErr(err)
	return _u
}

type I_baseNetworkSocketGetIpv6TrafficClassResultTag uint64

const (
	BaseNetworkSocketGetIpv6TrafficClassResultResponse = 1 // 0x00000001
	BaseNetworkSocketGetIpv6TrafficClassResultErr      = 2 // 0x00000002
)

type BaseNetworkSocketGetIpv6TrafficClassResult struct {
	I_baseNetworkSocketGetIpv6TrafficClassResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                        BaseNetworkSocketGetIpv6TrafficClassResponse `fidl_ordinal:"1"`
	Err                                             fuchsiaposix.Errno                           `fidl_ordinal:"2"`
}

func (_m *BaseNetworkSocketGetIpv6TrafficClassResult) reset() {
	switch _m.I_baseNetworkSocketGetIpv6TrafficClassResultTag {
	case 1:
		var _zeroed BaseNetworkSocketGetIpv6TrafficClassResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseNetworkSocketGetIpv6TrafficClassResult) Which() I_baseNetworkSocketGetIpv6TrafficClassResultTag {
	return _m.I_baseNetworkSocketGetIpv6TrafficClassResultTag
}

func (_m *BaseNetworkSocketGetIpv6TrafficClassResult) Ordinal() uint64 {
	return uint64(_m.I_baseNetworkSocketGetIpv6TrafficClassResultTag)
}

func (_m *BaseNetworkSocketGetIpv6TrafficClassResult) SetResponse(response BaseNetworkSocketGetIpv6TrafficClassResponse) {
	_m.reset()
	_m.I_baseNetworkSocketGetIpv6TrafficClassResultTag = BaseNetworkSocketGetIpv6TrafficClassResultResponse
	_m.Response = response
}

func BaseNetworkSocketGetIpv6TrafficClassResultWithResponse(response BaseNetworkSocketGetIpv6TrafficClassResponse) BaseNetworkSocketGetIpv6TrafficClassResult {
	var _u BaseNetworkSocketGetIpv6TrafficClassResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseNetworkSocketGetIpv6TrafficClassResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseNetworkSocketGetIpv6TrafficClassResultTag = BaseNetworkSocketGetIpv6TrafficClassResultErr
	_m.Err = err
}

func BaseNetworkSocketGetIpv6TrafficClassResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketGetIpv6TrafficClassResult {
	var _u BaseNetworkSocketGetIpv6TrafficClassResult
	_u.SetErr(err)
	return _u
}

type I_baseNetworkSocketBaseSocketBindResultTag uint64

const (
	BaseNetworkSocketBaseSocketBindResultResponse = 1 // 0x00000001
	BaseNetworkSocketBaseSocketBindResultErr      = 2 // 0x00000002
)

type BaseNetworkSocketBaseSocketBindResult struct {
	I_baseNetworkSocketBaseSocketBindResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                   BaseNetworkSocketBaseSocketBindResponse `fidl_ordinal:"1"`
	Err                                        fuchsiaposix.Errno                      `fidl_ordinal:"2"`
}

func (_m *BaseNetworkSocketBaseSocketBindResult) reset() {
	switch _m.I_baseNetworkSocketBaseSocketBindResultTag {
	case 1:
		var _zeroed BaseNetworkSocketBaseSocketBindResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseNetworkSocketBaseSocketBindResult) Which() I_baseNetworkSocketBaseSocketBindResultTag {
	return _m.I_baseNetworkSocketBaseSocketBindResultTag
}

func (_m *BaseNetworkSocketBaseSocketBindResult) Ordinal() uint64 {
	return uint64(_m.I_baseNetworkSocketBaseSocketBindResultTag)
}

func (_m *BaseNetworkSocketBaseSocketBindResult) SetResponse(response BaseNetworkSocketBaseSocketBindResponse) {
	_m.reset()
	_m.I_baseNetworkSocketBaseSocketBindResultTag = BaseNetworkSocketBaseSocketBindResultResponse
	_m.Response = response
}

func BaseNetworkSocketBaseSocketBindResultWithResponse(response BaseNetworkSocketBaseSocketBindResponse) BaseNetworkSocketBaseSocketBindResult {
	var _u BaseNetworkSocketBaseSocketBindResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseNetworkSocketBaseSocketBindResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseNetworkSocketBaseSocketBindResultTag = BaseNetworkSocketBaseSocketBindResultErr
	_m.Err = err
}

func BaseNetworkSocketBaseSocketBindResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketBaseSocketBindResult {
	var _u BaseNetworkSocketBaseSocketBindResult
	_u.SetErr(err)
	return _u
}

type I_baseNetworkSocketBaseSocketConnectResultTag uint64

const (
	BaseNetworkSocketBaseSocketConnectResultResponse = 1 // 0x00000001
	BaseNetworkSocketBaseSocketConnectResultErr      = 2 // 0x00000002
)

type BaseNetworkSocketBaseSocketConnectResult struct {
	I_baseNetworkSocketBaseSocketConnectResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                      BaseNetworkSocketBaseSocketConnectResponse `fidl_ordinal:"1"`
	Err                                           fuchsiaposix.Errno                         `fidl_ordinal:"2"`
}

func (_m *BaseNetworkSocketBaseSocketConnectResult) reset() {
	switch _m.I_baseNetworkSocketBaseSocketConnectResultTag {
	case 1:
		var _zeroed BaseNetworkSocketBaseSocketConnectResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseNetworkSocketBaseSocketConnectResult) Which() I_baseNetworkSocketBaseSocketConnectResultTag {
	return _m.I_baseNetworkSocketBaseSocketConnectResultTag
}

func (_m *BaseNetworkSocketBaseSocketConnectResult) Ordinal() uint64 {
	return uint64(_m.I_baseNetworkSocketBaseSocketConnectResultTag)
}

func (_m *BaseNetworkSocketBaseSocketConnectResult) SetResponse(response BaseNetworkSocketBaseSocketConnectResponse) {
	_m.reset()
	_m.I_baseNetworkSocketBaseSocketConnectResultTag = BaseNetworkSocketBaseSocketConnectResultResponse
	_m.Response = response
}

func BaseNetworkSocketBaseSocketConnectResultWithResponse(response BaseNetworkSocketBaseSocketConnectResponse) BaseNetworkSocketBaseSocketConnectResult {
	var _u BaseNetworkSocketBaseSocketConnectResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseNetworkSocketBaseSocketConnectResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseNetworkSocketBaseSocketConnectResultTag = BaseNetworkSocketBaseSocketConnectResultErr
	_m.Err = err
}

func BaseNetworkSocketBaseSocketConnectResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketBaseSocketConnectResult {
	var _u BaseNetworkSocketBaseSocketConnectResult
	_u.SetErr(err)
	return _u
}

type I_baseNetworkSocketBaseSocketDisconnectResultTag uint64

const (
	BaseNetworkSocketBaseSocketDisconnectResultResponse = 1 // 0x00000001
	BaseNetworkSocketBaseSocketDisconnectResultErr      = 2 // 0x00000002
)

type BaseNetworkSocketBaseSocketDisconnectResult struct {
	I_baseNetworkSocketBaseSocketDisconnectResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                         BaseNetworkSocketBaseSocketDisconnectResponse `fidl_ordinal:"1"`
	Err                                              fuchsiaposix.Errno                            `fidl_ordinal:"2"`
}

func (_m *BaseNetworkSocketBaseSocketDisconnectResult) reset() {
	switch _m.I_baseNetworkSocketBaseSocketDisconnectResultTag {
	case 1:
		var _zeroed BaseNetworkSocketBaseSocketDisconnectResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseNetworkSocketBaseSocketDisconnectResult) Which() I_baseNetworkSocketBaseSocketDisconnectResultTag {
	return _m.I_baseNetworkSocketBaseSocketDisconnectResultTag
}

func (_m *BaseNetworkSocketBaseSocketDisconnectResult) Ordinal() uint64 {
	return uint64(_m.I_baseNetworkSocketBaseSocketDisconnectResultTag)
}

func (_m *BaseNetworkSocketBaseSocketDisconnectResult) SetResponse(response BaseNetworkSocketBaseSocketDisconnectResponse) {
	_m.reset()
	_m.I_baseNetworkSocketBaseSocketDisconnectResultTag = BaseNetworkSocketBaseSocketDisconnectResultResponse
	_m.Response = response
}

func BaseNetworkSocketBaseSocketDisconnectResultWithResponse(response BaseNetworkSocketBaseSocketDisconnectResponse) BaseNetworkSocketBaseSocketDisconnectResult {
	var _u BaseNetworkSocketBaseSocketDisconnectResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseNetworkSocketBaseSocketDisconnectResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseNetworkSocketBaseSocketDisconnectResultTag = BaseNetworkSocketBaseSocketDisconnectResultErr
	_m.Err = err
}

func BaseNetworkSocketBaseSocketDisconnectResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketBaseSocketDisconnectResult {
	var _u BaseNetworkSocketBaseSocketDisconnectResult
	_u.SetErr(err)
	return _u
}

type I_baseNetworkSocketBaseSocketGetSockNameResultTag uint64

const (
	BaseNetworkSocketBaseSocketGetSockNameResultResponse = 1 // 0x00000001
	BaseNetworkSocketBaseSocketGetSockNameResultErr      = 2 // 0x00000002
)

type BaseNetworkSocketBaseSocketGetSockNameResult struct {
	I_baseNetworkSocketBaseSocketGetSockNameResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                          BaseNetworkSocketBaseSocketGetSockNameResponse `fidl_ordinal:"1"`
	Err                                               fuchsiaposix.Errno                             `fidl_ordinal:"2"`
}

func (_m *BaseNetworkSocketBaseSocketGetSockNameResult) reset() {
	switch _m.I_baseNetworkSocketBaseSocketGetSockNameResultTag {
	case 1:
		var _zeroed BaseNetworkSocketBaseSocketGetSockNameResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseNetworkSocketBaseSocketGetSockNameResult) Which() I_baseNetworkSocketBaseSocketGetSockNameResultTag {
	return _m.I_baseNetworkSocketBaseSocketGetSockNameResultTag
}

func (_m *BaseNetworkSocketBaseSocketGetSockNameResult) Ordinal() uint64 {
	return uint64(_m.I_baseNetworkSocketBaseSocketGetSockNameResultTag)
}

func (_m *BaseNetworkSocketBaseSocketGetSockNameResult) SetResponse(response BaseNetworkSocketBaseSocketGetSockNameResponse) {
	_m.reset()
	_m.I_baseNetworkSocketBaseSocketGetSockNameResultTag = BaseNetworkSocketBaseSocketGetSockNameResultResponse
	_m.Response = response
}

func BaseNetworkSocketBaseSocketGetSockNameResultWithResponse(response BaseNetworkSocketBaseSocketGetSockNameResponse) BaseNetworkSocketBaseSocketGetSockNameResult {
	var _u BaseNetworkSocketBaseSocketGetSockNameResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseNetworkSocketBaseSocketGetSockNameResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseNetworkSocketBaseSocketGetSockNameResultTag = BaseNetworkSocketBaseSocketGetSockNameResultErr
	_m.Err = err
}

func BaseNetworkSocketBaseSocketGetSockNameResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketBaseSocketGetSockNameResult {
	var _u BaseNetworkSocketBaseSocketGetSockNameResult
	_u.SetErr(err)
	return _u
}

type I_baseNetworkSocketBaseSocketGetPeerNameResultTag uint64

const (
	BaseNetworkSocketBaseSocketGetPeerNameResultResponse = 1 // 0x00000001
	BaseNetworkSocketBaseSocketGetPeerNameResultErr      = 2 // 0x00000002
)

type BaseNetworkSocketBaseSocketGetPeerNameResult struct {
	I_baseNetworkSocketBaseSocketGetPeerNameResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                          BaseNetworkSocketBaseSocketGetPeerNameResponse `fidl_ordinal:"1"`
	Err                                               fuchsiaposix.Errno                             `fidl_ordinal:"2"`
}

func (_m *BaseNetworkSocketBaseSocketGetPeerNameResult) reset() {
	switch _m.I_baseNetworkSocketBaseSocketGetPeerNameResultTag {
	case 1:
		var _zeroed BaseNetworkSocketBaseSocketGetPeerNameResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseNetworkSocketBaseSocketGetPeerNameResult) Which() I_baseNetworkSocketBaseSocketGetPeerNameResultTag {
	return _m.I_baseNetworkSocketBaseSocketGetPeerNameResultTag
}

func (_m *BaseNetworkSocketBaseSocketGetPeerNameResult) Ordinal() uint64 {
	return uint64(_m.I_baseNetworkSocketBaseSocketGetPeerNameResultTag)
}

func (_m *BaseNetworkSocketBaseSocketGetPeerNameResult) SetResponse(response BaseNetworkSocketBaseSocketGetPeerNameResponse) {
	_m.reset()
	_m.I_baseNetworkSocketBaseSocketGetPeerNameResultTag = BaseNetworkSocketBaseSocketGetPeerNameResultResponse
	_m.Response = response
}

func BaseNetworkSocketBaseSocketGetPeerNameResultWithResponse(response BaseNetworkSocketBaseSocketGetPeerNameResponse) BaseNetworkSocketBaseSocketGetPeerNameResult {
	var _u BaseNetworkSocketBaseSocketGetPeerNameResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseNetworkSocketBaseSocketGetPeerNameResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseNetworkSocketBaseSocketGetPeerNameResultTag = BaseNetworkSocketBaseSocketGetPeerNameResultErr
	_m.Err = err
}

func BaseNetworkSocketBaseSocketGetPeerNameResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketBaseSocketGetPeerNameResult {
	var _u BaseNetworkSocketBaseSocketGetPeerNameResult
	_u.SetErr(err)
	return _u
}

type I_baseNetworkSocketBaseSocketShutdownResultTag uint64

const (
	BaseNetworkSocketBaseSocketShutdownResultResponse = 1 // 0x00000001
	BaseNetworkSocketBaseSocketShutdownResultErr      = 2 // 0x00000002
)

type BaseNetworkSocketBaseSocketShutdownResult struct {
	I_baseNetworkSocketBaseSocketShutdownResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                       BaseNetworkSocketBaseSocketShutdownResponse `fidl_ordinal:"1"`
	Err                                            fuchsiaposix.Errno                          `fidl_ordinal:"2"`
}

func (_m *BaseNetworkSocketBaseSocketShutdownResult) reset() {
	switch _m.I_baseNetworkSocketBaseSocketShutdownResultTag {
	case 1:
		var _zeroed BaseNetworkSocketBaseSocketShutdownResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseNetworkSocketBaseSocketShutdownResult) Which() I_baseNetworkSocketBaseSocketShutdownResultTag {
	return _m.I_baseNetworkSocketBaseSocketShutdownResultTag
}

func (_m *BaseNetworkSocketBaseSocketShutdownResult) Ordinal() uint64 {
	return uint64(_m.I_baseNetworkSocketBaseSocketShutdownResultTag)
}

func (_m *BaseNetworkSocketBaseSocketShutdownResult) SetResponse(response BaseNetworkSocketBaseSocketShutdownResponse) {
	_m.reset()
	_m.I_baseNetworkSocketBaseSocketShutdownResultTag = BaseNetworkSocketBaseSocketShutdownResultResponse
	_m.Response = response
}

func BaseNetworkSocketBaseSocketShutdownResultWithResponse(response BaseNetworkSocketBaseSocketShutdownResponse) BaseNetworkSocketBaseSocketShutdownResult {
	var _u BaseNetworkSocketBaseSocketShutdownResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseNetworkSocketBaseSocketShutdownResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseNetworkSocketBaseSocketShutdownResultTag = BaseNetworkSocketBaseSocketShutdownResultErr
	_m.Err = err
}

func BaseNetworkSocketBaseSocketShutdownResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketBaseSocketShutdownResult {
	var _u BaseNetworkSocketBaseSocketShutdownResult
	_u.SetErr(err)
	return _u
}

type I_baseNetworkSocketBaseSocketShutdown2ResultTag uint64

const (
	BaseNetworkSocketBaseSocketShutdown2ResultResponse = 1 // 0x00000001
	BaseNetworkSocketBaseSocketShutdown2ResultErr      = 2 // 0x00000002
)

type BaseNetworkSocketBaseSocketShutdown2Result struct {
	I_baseNetworkSocketBaseSocketShutdown2ResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                        BaseNetworkSocketBaseSocketShutdown2Response `fidl_ordinal:"1"`
	Err                                             fuchsiaposix.Errno                           `fidl_ordinal:"2"`
}

func (_m *BaseNetworkSocketBaseSocketShutdown2Result) reset() {
	switch _m.I_baseNetworkSocketBaseSocketShutdown2ResultTag {
	case 1:
		var _zeroed BaseNetworkSocketBaseSocketShutdown2Response
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseNetworkSocketBaseSocketShutdown2Result) Which() I_baseNetworkSocketBaseSocketShutdown2ResultTag {
	return _m.I_baseNetworkSocketBaseSocketShutdown2ResultTag
}

func (_m *BaseNetworkSocketBaseSocketShutdown2Result) Ordinal() uint64 {
	return uint64(_m.I_baseNetworkSocketBaseSocketShutdown2ResultTag)
}

func (_m *BaseNetworkSocketBaseSocketShutdown2Result) SetResponse(response BaseNetworkSocketBaseSocketShutdown2Response) {
	_m.reset()
	_m.I_baseNetworkSocketBaseSocketShutdown2ResultTag = BaseNetworkSocketBaseSocketShutdown2ResultResponse
	_m.Response = response
}

func BaseNetworkSocketBaseSocketShutdown2ResultWithResponse(response BaseNetworkSocketBaseSocketShutdown2Response) BaseNetworkSocketBaseSocketShutdown2Result {
	var _u BaseNetworkSocketBaseSocketShutdown2Result
	_u.SetResponse(response)
	return _u
}

func (_m *BaseNetworkSocketBaseSocketShutdown2Result) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseNetworkSocketBaseSocketShutdown2ResultTag = BaseNetworkSocketBaseSocketShutdown2ResultErr
	_m.Err = err
}

func BaseNetworkSocketBaseSocketShutdown2ResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketBaseSocketShutdown2Result {
	var _u BaseNetworkSocketBaseSocketShutdown2Result
	_u.SetErr(err)
	return _u
}

type I_baseNetworkSocketBaseSocketSetIpTypeOfServiceResultTag uint64

const (
	BaseNetworkSocketBaseSocketSetIpTypeOfServiceResultResponse = 1 // 0x00000001
	BaseNetworkSocketBaseSocketSetIpTypeOfServiceResultErr      = 2 // 0x00000002
)

type BaseNetworkSocketBaseSocketSetIpTypeOfServiceResult struct {
	I_baseNetworkSocketBaseSocketSetIpTypeOfServiceResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                                 BaseNetworkSocketBaseSocketSetIpTypeOfServiceResponse `fidl_ordinal:"1"`
	Err                                                      fuchsiaposix.Errno                                    `fidl_ordinal:"2"`
}

func (_m *BaseNetworkSocketBaseSocketSetIpTypeOfServiceResult) reset() {
	switch _m.I_baseNetworkSocketBaseSocketSetIpTypeOfServiceResultTag {
	case 1:
		var _zeroed BaseNetworkSocketBaseSocketSetIpTypeOfServiceResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseNetworkSocketBaseSocketSetIpTypeOfServiceResult) Which() I_baseNetworkSocketBaseSocketSetIpTypeOfServiceResultTag {
	return _m.I_baseNetworkSocketBaseSocketSetIpTypeOfServiceResultTag
}

func (_m *BaseNetworkSocketBaseSocketSetIpTypeOfServiceResult) Ordinal() uint64 {
	return uint64(_m.I_baseNetworkSocketBaseSocketSetIpTypeOfServiceResultTag)
}

func (_m *BaseNetworkSocketBaseSocketSetIpTypeOfServiceResult) SetResponse(response BaseNetworkSocketBaseSocketSetIpTypeOfServiceResponse) {
	_m.reset()
	_m.I_baseNetworkSocketBaseSocketSetIpTypeOfServiceResultTag = BaseNetworkSocketBaseSocketSetIpTypeOfServiceResultResponse
	_m.Response = response
}

func BaseNetworkSocketBaseSocketSetIpTypeOfServiceResultWithResponse(response BaseNetworkSocketBaseSocketSetIpTypeOfServiceResponse) BaseNetworkSocketBaseSocketSetIpTypeOfServiceResult {
	var _u BaseNetworkSocketBaseSocketSetIpTypeOfServiceResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseNetworkSocketBaseSocketSetIpTypeOfServiceResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseNetworkSocketBaseSocketSetIpTypeOfServiceResultTag = BaseNetworkSocketBaseSocketSetIpTypeOfServiceResultErr
	_m.Err = err
}

func BaseNetworkSocketBaseSocketSetIpTypeOfServiceResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketBaseSocketSetIpTypeOfServiceResult {
	var _u BaseNetworkSocketBaseSocketSetIpTypeOfServiceResult
	_u.SetErr(err)
	return _u
}

type I_baseNetworkSocketBaseSocketGetIpTypeOfServiceResultTag uint64

const (
	BaseNetworkSocketBaseSocketGetIpTypeOfServiceResultResponse = 1 // 0x00000001
	BaseNetworkSocketBaseSocketGetIpTypeOfServiceResultErr      = 2 // 0x00000002
)

type BaseNetworkSocketBaseSocketGetIpTypeOfServiceResult struct {
	I_baseNetworkSocketBaseSocketGetIpTypeOfServiceResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                                 BaseNetworkSocketBaseSocketGetIpTypeOfServiceResponse `fidl_ordinal:"1"`
	Err                                                      fuchsiaposix.Errno                                    `fidl_ordinal:"2"`
}

func (_m *BaseNetworkSocketBaseSocketGetIpTypeOfServiceResult) reset() {
	switch _m.I_baseNetworkSocketBaseSocketGetIpTypeOfServiceResultTag {
	case 1:
		var _zeroed BaseNetworkSocketBaseSocketGetIpTypeOfServiceResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseNetworkSocketBaseSocketGetIpTypeOfServiceResult) Which() I_baseNetworkSocketBaseSocketGetIpTypeOfServiceResultTag {
	return _m.I_baseNetworkSocketBaseSocketGetIpTypeOfServiceResultTag
}

func (_m *BaseNetworkSocketBaseSocketGetIpTypeOfServiceResult) Ordinal() uint64 {
	return uint64(_m.I_baseNetworkSocketBaseSocketGetIpTypeOfServiceResultTag)
}

func (_m *BaseNetworkSocketBaseSocketGetIpTypeOfServiceResult) SetResponse(response BaseNetworkSocketBaseSocketGetIpTypeOfServiceResponse) {
	_m.reset()
	_m.I_baseNetworkSocketBaseSocketGetIpTypeOfServiceResultTag = BaseNetworkSocketBaseSocketGetIpTypeOfServiceResultResponse
	_m.Response = response
}

func BaseNetworkSocketBaseSocketGetIpTypeOfServiceResultWithResponse(response BaseNetworkSocketBaseSocketGetIpTypeOfServiceResponse) BaseNetworkSocketBaseSocketGetIpTypeOfServiceResult {
	var _u BaseNetworkSocketBaseSocketGetIpTypeOfServiceResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseNetworkSocketBaseSocketGetIpTypeOfServiceResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseNetworkSocketBaseSocketGetIpTypeOfServiceResultTag = BaseNetworkSocketBaseSocketGetIpTypeOfServiceResultErr
	_m.Err = err
}

func BaseNetworkSocketBaseSocketGetIpTypeOfServiceResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketBaseSocketGetIpTypeOfServiceResult {
	var _u BaseNetworkSocketBaseSocketGetIpTypeOfServiceResult
	_u.SetErr(err)
	return _u
}

type I_baseNetworkSocketBaseSocketSetIpTtlResultTag uint64

const (
	BaseNetworkSocketBaseSocketSetIpTtlResultResponse = 1 // 0x00000001
	BaseNetworkSocketBaseSocketSetIpTtlResultErr      = 2 // 0x00000002
)

type BaseNetworkSocketBaseSocketSetIpTtlResult struct {
	I_baseNetworkSocketBaseSocketSetIpTtlResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                       BaseNetworkSocketBaseSocketSetIpTtlResponse `fidl_ordinal:"1"`
	Err                                            fuchsiaposix.Errno                          `fidl_ordinal:"2"`
}

func (_m *BaseNetworkSocketBaseSocketSetIpTtlResult) reset() {
	switch _m.I_baseNetworkSocketBaseSocketSetIpTtlResultTag {
	case 1:
		var _zeroed BaseNetworkSocketBaseSocketSetIpTtlResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseNetworkSocketBaseSocketSetIpTtlResult) Which() I_baseNetworkSocketBaseSocketSetIpTtlResultTag {
	return _m.I_baseNetworkSocketBaseSocketSetIpTtlResultTag
}

func (_m *BaseNetworkSocketBaseSocketSetIpTtlResult) Ordinal() uint64 {
	return uint64(_m.I_baseNetworkSocketBaseSocketSetIpTtlResultTag)
}

func (_m *BaseNetworkSocketBaseSocketSetIpTtlResult) SetResponse(response BaseNetworkSocketBaseSocketSetIpTtlResponse) {
	_m.reset()
	_m.I_baseNetworkSocketBaseSocketSetIpTtlResultTag = BaseNetworkSocketBaseSocketSetIpTtlResultResponse
	_m.Response = response
}

func BaseNetworkSocketBaseSocketSetIpTtlResultWithResponse(response BaseNetworkSocketBaseSocketSetIpTtlResponse) BaseNetworkSocketBaseSocketSetIpTtlResult {
	var _u BaseNetworkSocketBaseSocketSetIpTtlResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseNetworkSocketBaseSocketSetIpTtlResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseNetworkSocketBaseSocketSetIpTtlResultTag = BaseNetworkSocketBaseSocketSetIpTtlResultErr
	_m.Err = err
}

func BaseNetworkSocketBaseSocketSetIpTtlResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketBaseSocketSetIpTtlResult {
	var _u BaseNetworkSocketBaseSocketSetIpTtlResult
	_u.SetErr(err)
	return _u
}

type I_baseNetworkSocketBaseSocketGetIpTtlResultTag uint64

const (
	BaseNetworkSocketBaseSocketGetIpTtlResultResponse = 1 // 0x00000001
	BaseNetworkSocketBaseSocketGetIpTtlResultErr      = 2 // 0x00000002
)

type BaseNetworkSocketBaseSocketGetIpTtlResult struct {
	I_baseNetworkSocketBaseSocketGetIpTtlResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                       BaseNetworkSocketBaseSocketGetIpTtlResponse `fidl_ordinal:"1"`
	Err                                            fuchsiaposix.Errno                          `fidl_ordinal:"2"`
}

func (_m *BaseNetworkSocketBaseSocketGetIpTtlResult) reset() {
	switch _m.I_baseNetworkSocketBaseSocketGetIpTtlResultTag {
	case 1:
		var _zeroed BaseNetworkSocketBaseSocketGetIpTtlResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseNetworkSocketBaseSocketGetIpTtlResult) Which() I_baseNetworkSocketBaseSocketGetIpTtlResultTag {
	return _m.I_baseNetworkSocketBaseSocketGetIpTtlResultTag
}

func (_m *BaseNetworkSocketBaseSocketGetIpTtlResult) Ordinal() uint64 {
	return uint64(_m.I_baseNetworkSocketBaseSocketGetIpTtlResultTag)
}

func (_m *BaseNetworkSocketBaseSocketGetIpTtlResult) SetResponse(response BaseNetworkSocketBaseSocketGetIpTtlResponse) {
	_m.reset()
	_m.I_baseNetworkSocketBaseSocketGetIpTtlResultTag = BaseNetworkSocketBaseSocketGetIpTtlResultResponse
	_m.Response = response
}

func BaseNetworkSocketBaseSocketGetIpTtlResultWithResponse(response BaseNetworkSocketBaseSocketGetIpTtlResponse) BaseNetworkSocketBaseSocketGetIpTtlResult {
	var _u BaseNetworkSocketBaseSocketGetIpTtlResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseNetworkSocketBaseSocketGetIpTtlResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseNetworkSocketBaseSocketGetIpTtlResultTag = BaseNetworkSocketBaseSocketGetIpTtlResultErr
	_m.Err = err
}

func BaseNetworkSocketBaseSocketGetIpTtlResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketBaseSocketGetIpTtlResult {
	var _u BaseNetworkSocketBaseSocketGetIpTtlResult
	_u.SetErr(err)
	return _u
}

type I_baseNetworkSocketBaseSocketSetIpPacketInfoResultTag uint64

const (
	BaseNetworkSocketBaseSocketSetIpPacketInfoResultResponse = 1 // 0x00000001
	BaseNetworkSocketBaseSocketSetIpPacketInfoResultErr      = 2 // 0x00000002
)

type BaseNetworkSocketBaseSocketSetIpPacketInfoResult struct {
	I_baseNetworkSocketBaseSocketSetIpPacketInfoResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                              BaseNetworkSocketBaseSocketSetIpPacketInfoResponse `fidl_ordinal:"1"`
	Err                                                   fuchsiaposix.Errno                                 `fidl_ordinal:"2"`
}

func (_m *BaseNetworkSocketBaseSocketSetIpPacketInfoResult) reset() {
	switch _m.I_baseNetworkSocketBaseSocketSetIpPacketInfoResultTag {
	case 1:
		var _zeroed BaseNetworkSocketBaseSocketSetIpPacketInfoResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseNetworkSocketBaseSocketSetIpPacketInfoResult) Which() I_baseNetworkSocketBaseSocketSetIpPacketInfoResultTag {
	return _m.I_baseNetworkSocketBaseSocketSetIpPacketInfoResultTag
}

func (_m *BaseNetworkSocketBaseSocketSetIpPacketInfoResult) Ordinal() uint64 {
	return uint64(_m.I_baseNetworkSocketBaseSocketSetIpPacketInfoResultTag)
}

func (_m *BaseNetworkSocketBaseSocketSetIpPacketInfoResult) SetResponse(response BaseNetworkSocketBaseSocketSetIpPacketInfoResponse) {
	_m.reset()
	_m.I_baseNetworkSocketBaseSocketSetIpPacketInfoResultTag = BaseNetworkSocketBaseSocketSetIpPacketInfoResultResponse
	_m.Response = response
}

func BaseNetworkSocketBaseSocketSetIpPacketInfoResultWithResponse(response BaseNetworkSocketBaseSocketSetIpPacketInfoResponse) BaseNetworkSocketBaseSocketSetIpPacketInfoResult {
	var _u BaseNetworkSocketBaseSocketSetIpPacketInfoResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseNetworkSocketBaseSocketSetIpPacketInfoResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseNetworkSocketBaseSocketSetIpPacketInfoResultTag = BaseNetworkSocketBaseSocketSetIpPacketInfoResultErr
	_m.Err = err
}

func BaseNetworkSocketBaseSocketSetIpPacketInfoResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketBaseSocketSetIpPacketInfoResult {
	var _u BaseNetworkSocketBaseSocketSetIpPacketInfoResult
	_u.SetErr(err)
	return _u
}

type I_baseNetworkSocketBaseSocketGetIpPacketInfoResultTag uint64

const (
	BaseNetworkSocketBaseSocketGetIpPacketInfoResultResponse = 1 // 0x00000001
	BaseNetworkSocketBaseSocketGetIpPacketInfoResultErr      = 2 // 0x00000002
)

type BaseNetworkSocketBaseSocketGetIpPacketInfoResult struct {
	I_baseNetworkSocketBaseSocketGetIpPacketInfoResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                              BaseNetworkSocketBaseSocketGetIpPacketInfoResponse `fidl_ordinal:"1"`
	Err                                                   fuchsiaposix.Errno                                 `fidl_ordinal:"2"`
}

func (_m *BaseNetworkSocketBaseSocketGetIpPacketInfoResult) reset() {
	switch _m.I_baseNetworkSocketBaseSocketGetIpPacketInfoResultTag {
	case 1:
		var _zeroed BaseNetworkSocketBaseSocketGetIpPacketInfoResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseNetworkSocketBaseSocketGetIpPacketInfoResult) Which() I_baseNetworkSocketBaseSocketGetIpPacketInfoResultTag {
	return _m.I_baseNetworkSocketBaseSocketGetIpPacketInfoResultTag
}

func (_m *BaseNetworkSocketBaseSocketGetIpPacketInfoResult) Ordinal() uint64 {
	return uint64(_m.I_baseNetworkSocketBaseSocketGetIpPacketInfoResultTag)
}

func (_m *BaseNetworkSocketBaseSocketGetIpPacketInfoResult) SetResponse(response BaseNetworkSocketBaseSocketGetIpPacketInfoResponse) {
	_m.reset()
	_m.I_baseNetworkSocketBaseSocketGetIpPacketInfoResultTag = BaseNetworkSocketBaseSocketGetIpPacketInfoResultResponse
	_m.Response = response
}

func BaseNetworkSocketBaseSocketGetIpPacketInfoResultWithResponse(response BaseNetworkSocketBaseSocketGetIpPacketInfoResponse) BaseNetworkSocketBaseSocketGetIpPacketInfoResult {
	var _u BaseNetworkSocketBaseSocketGetIpPacketInfoResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseNetworkSocketBaseSocketGetIpPacketInfoResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseNetworkSocketBaseSocketGetIpPacketInfoResultTag = BaseNetworkSocketBaseSocketGetIpPacketInfoResultErr
	_m.Err = err
}

func BaseNetworkSocketBaseSocketGetIpPacketInfoResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketBaseSocketGetIpPacketInfoResult {
	var _u BaseNetworkSocketBaseSocketGetIpPacketInfoResult
	_u.SetErr(err)
	return _u
}

type I_baseNetworkSocketBaseSocketSetIpReceiveTypeOfServiceResultTag uint64

const (
	BaseNetworkSocketBaseSocketSetIpReceiveTypeOfServiceResultResponse = 1 // 0x00000001
	BaseNetworkSocketBaseSocketSetIpReceiveTypeOfServiceResultErr      = 2 // 0x00000002
)

type BaseNetworkSocketBaseSocketSetIpReceiveTypeOfServiceResult struct {
	I_baseNetworkSocketBaseSocketSetIpReceiveTypeOfServiceResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                                        BaseNetworkSocketBaseSocketSetIpReceiveTypeOfServiceResponse `fidl_ordinal:"1"`
	Err                                                             fuchsiaposix.Errno                                           `fidl_ordinal:"2"`
}

func (_m *BaseNetworkSocketBaseSocketSetIpReceiveTypeOfServiceResult) reset() {
	switch _m.I_baseNetworkSocketBaseSocketSetIpReceiveTypeOfServiceResultTag {
	case 1:
		var _zeroed BaseNetworkSocketBaseSocketSetIpReceiveTypeOfServiceResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseNetworkSocketBaseSocketSetIpReceiveTypeOfServiceResult) Which() I_baseNetworkSocketBaseSocketSetIpReceiveTypeOfServiceResultTag {
	return _m.I_baseNetworkSocketBaseSocketSetIpReceiveTypeOfServiceResultTag
}

func (_m *BaseNetworkSocketBaseSocketSetIpReceiveTypeOfServiceResult) Ordinal() uint64 {
	return uint64(_m.I_baseNetworkSocketBaseSocketSetIpReceiveTypeOfServiceResultTag)
}

func (_m *BaseNetworkSocketBaseSocketSetIpReceiveTypeOfServiceResult) SetResponse(response BaseNetworkSocketBaseSocketSetIpReceiveTypeOfServiceResponse) {
	_m.reset()
	_m.I_baseNetworkSocketBaseSocketSetIpReceiveTypeOfServiceResultTag = BaseNetworkSocketBaseSocketSetIpReceiveTypeOfServiceResultResponse
	_m.Response = response
}

func BaseNetworkSocketBaseSocketSetIpReceiveTypeOfServiceResultWithResponse(response BaseNetworkSocketBaseSocketSetIpReceiveTypeOfServiceResponse) BaseNetworkSocketBaseSocketSetIpReceiveTypeOfServiceResult {
	var _u BaseNetworkSocketBaseSocketSetIpReceiveTypeOfServiceResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseNetworkSocketBaseSocketSetIpReceiveTypeOfServiceResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseNetworkSocketBaseSocketSetIpReceiveTypeOfServiceResultTag = BaseNetworkSocketBaseSocketSetIpReceiveTypeOfServiceResultErr
	_m.Err = err
}

func BaseNetworkSocketBaseSocketSetIpReceiveTypeOfServiceResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketBaseSocketSetIpReceiveTypeOfServiceResult {
	var _u BaseNetworkSocketBaseSocketSetIpReceiveTypeOfServiceResult
	_u.SetErr(err)
	return _u
}

type I_baseNetworkSocketBaseSocketGetIpReceiveTypeOfServiceResultTag uint64

const (
	BaseNetworkSocketBaseSocketGetIpReceiveTypeOfServiceResultResponse = 1 // 0x00000001
	BaseNetworkSocketBaseSocketGetIpReceiveTypeOfServiceResultErr      = 2 // 0x00000002
)

type BaseNetworkSocketBaseSocketGetIpReceiveTypeOfServiceResult struct {
	I_baseNetworkSocketBaseSocketGetIpReceiveTypeOfServiceResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                                        BaseNetworkSocketBaseSocketGetIpReceiveTypeOfServiceResponse `fidl_ordinal:"1"`
	Err                                                             fuchsiaposix.Errno                                           `fidl_ordinal:"2"`
}

func (_m *BaseNetworkSocketBaseSocketGetIpReceiveTypeOfServiceResult) reset() {
	switch _m.I_baseNetworkSocketBaseSocketGetIpReceiveTypeOfServiceResultTag {
	case 1:
		var _zeroed BaseNetworkSocketBaseSocketGetIpReceiveTypeOfServiceResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseNetworkSocketBaseSocketGetIpReceiveTypeOfServiceResult) Which() I_baseNetworkSocketBaseSocketGetIpReceiveTypeOfServiceResultTag {
	return _m.I_baseNetworkSocketBaseSocketGetIpReceiveTypeOfServiceResultTag
}

func (_m *BaseNetworkSocketBaseSocketGetIpReceiveTypeOfServiceResult) Ordinal() uint64 {
	return uint64(_m.I_baseNetworkSocketBaseSocketGetIpReceiveTypeOfServiceResultTag)
}

func (_m *BaseNetworkSocketBaseSocketGetIpReceiveTypeOfServiceResult) SetResponse(response BaseNetworkSocketBaseSocketGetIpReceiveTypeOfServiceResponse) {
	_m.reset()
	_m.I_baseNetworkSocketBaseSocketGetIpReceiveTypeOfServiceResultTag = BaseNetworkSocketBaseSocketGetIpReceiveTypeOfServiceResultResponse
	_m.Response = response
}

func BaseNetworkSocketBaseSocketGetIpReceiveTypeOfServiceResultWithResponse(response BaseNetworkSocketBaseSocketGetIpReceiveTypeOfServiceResponse) BaseNetworkSocketBaseSocketGetIpReceiveTypeOfServiceResult {
	var _u BaseNetworkSocketBaseSocketGetIpReceiveTypeOfServiceResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseNetworkSocketBaseSocketGetIpReceiveTypeOfServiceResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseNetworkSocketBaseSocketGetIpReceiveTypeOfServiceResultTag = BaseNetworkSocketBaseSocketGetIpReceiveTypeOfServiceResultErr
	_m.Err = err
}

func BaseNetworkSocketBaseSocketGetIpReceiveTypeOfServiceResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketBaseSocketGetIpReceiveTypeOfServiceResult {
	var _u BaseNetworkSocketBaseSocketGetIpReceiveTypeOfServiceResult
	_u.SetErr(err)
	return _u
}

type I_baseNetworkSocketBaseSocketSetIpMulticastInterfaceResultTag uint64

const (
	BaseNetworkSocketBaseSocketSetIpMulticastInterfaceResultResponse = 1 // 0x00000001
	BaseNetworkSocketBaseSocketSetIpMulticastInterfaceResultErr      = 2 // 0x00000002
)

type BaseNetworkSocketBaseSocketSetIpMulticastInterfaceResult struct {
	I_baseNetworkSocketBaseSocketSetIpMulticastInterfaceResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                                      BaseNetworkSocketBaseSocketSetIpMulticastInterfaceResponse `fidl_ordinal:"1"`
	Err                                                           fuchsiaposix.Errno                                         `fidl_ordinal:"2"`
}

func (_m *BaseNetworkSocketBaseSocketSetIpMulticastInterfaceResult) reset() {
	switch _m.I_baseNetworkSocketBaseSocketSetIpMulticastInterfaceResultTag {
	case 1:
		var _zeroed BaseNetworkSocketBaseSocketSetIpMulticastInterfaceResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseNetworkSocketBaseSocketSetIpMulticastInterfaceResult) Which() I_baseNetworkSocketBaseSocketSetIpMulticastInterfaceResultTag {
	return _m.I_baseNetworkSocketBaseSocketSetIpMulticastInterfaceResultTag
}

func (_m *BaseNetworkSocketBaseSocketSetIpMulticastInterfaceResult) Ordinal() uint64 {
	return uint64(_m.I_baseNetworkSocketBaseSocketSetIpMulticastInterfaceResultTag)
}

func (_m *BaseNetworkSocketBaseSocketSetIpMulticastInterfaceResult) SetResponse(response BaseNetworkSocketBaseSocketSetIpMulticastInterfaceResponse) {
	_m.reset()
	_m.I_baseNetworkSocketBaseSocketSetIpMulticastInterfaceResultTag = BaseNetworkSocketBaseSocketSetIpMulticastInterfaceResultResponse
	_m.Response = response
}

func BaseNetworkSocketBaseSocketSetIpMulticastInterfaceResultWithResponse(response BaseNetworkSocketBaseSocketSetIpMulticastInterfaceResponse) BaseNetworkSocketBaseSocketSetIpMulticastInterfaceResult {
	var _u BaseNetworkSocketBaseSocketSetIpMulticastInterfaceResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseNetworkSocketBaseSocketSetIpMulticastInterfaceResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseNetworkSocketBaseSocketSetIpMulticastInterfaceResultTag = BaseNetworkSocketBaseSocketSetIpMulticastInterfaceResultErr
	_m.Err = err
}

func BaseNetworkSocketBaseSocketSetIpMulticastInterfaceResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketBaseSocketSetIpMulticastInterfaceResult {
	var _u BaseNetworkSocketBaseSocketSetIpMulticastInterfaceResult
	_u.SetErr(err)
	return _u
}

type I_baseNetworkSocketBaseSocketGetIpMulticastInterfaceResultTag uint64

const (
	BaseNetworkSocketBaseSocketGetIpMulticastInterfaceResultResponse = 1 // 0x00000001
	BaseNetworkSocketBaseSocketGetIpMulticastInterfaceResultErr      = 2 // 0x00000002
)

type BaseNetworkSocketBaseSocketGetIpMulticastInterfaceResult struct {
	I_baseNetworkSocketBaseSocketGetIpMulticastInterfaceResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                                      BaseNetworkSocketBaseSocketGetIpMulticastInterfaceResponse `fidl_ordinal:"1"`
	Err                                                           fuchsiaposix.Errno                                         `fidl_ordinal:"2"`
}

func (_m *BaseNetworkSocketBaseSocketGetIpMulticastInterfaceResult) reset() {
	switch _m.I_baseNetworkSocketBaseSocketGetIpMulticastInterfaceResultTag {
	case 1:
		var _zeroed BaseNetworkSocketBaseSocketGetIpMulticastInterfaceResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseNetworkSocketBaseSocketGetIpMulticastInterfaceResult) Which() I_baseNetworkSocketBaseSocketGetIpMulticastInterfaceResultTag {
	return _m.I_baseNetworkSocketBaseSocketGetIpMulticastInterfaceResultTag
}

func (_m *BaseNetworkSocketBaseSocketGetIpMulticastInterfaceResult) Ordinal() uint64 {
	return uint64(_m.I_baseNetworkSocketBaseSocketGetIpMulticastInterfaceResultTag)
}

func (_m *BaseNetworkSocketBaseSocketGetIpMulticastInterfaceResult) SetResponse(response BaseNetworkSocketBaseSocketGetIpMulticastInterfaceResponse) {
	_m.reset()
	_m.I_baseNetworkSocketBaseSocketGetIpMulticastInterfaceResultTag = BaseNetworkSocketBaseSocketGetIpMulticastInterfaceResultResponse
	_m.Response = response
}

func BaseNetworkSocketBaseSocketGetIpMulticastInterfaceResultWithResponse(response BaseNetworkSocketBaseSocketGetIpMulticastInterfaceResponse) BaseNetworkSocketBaseSocketGetIpMulticastInterfaceResult {
	var _u BaseNetworkSocketBaseSocketGetIpMulticastInterfaceResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseNetworkSocketBaseSocketGetIpMulticastInterfaceResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseNetworkSocketBaseSocketGetIpMulticastInterfaceResultTag = BaseNetworkSocketBaseSocketGetIpMulticastInterfaceResultErr
	_m.Err = err
}

func BaseNetworkSocketBaseSocketGetIpMulticastInterfaceResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketBaseSocketGetIpMulticastInterfaceResult {
	var _u BaseNetworkSocketBaseSocketGetIpMulticastInterfaceResult
	_u.SetErr(err)
	return _u
}

type I_baseNetworkSocketBaseSocketSetIpMulticastTtlResultTag uint64

const (
	BaseNetworkSocketBaseSocketSetIpMulticastTtlResultResponse = 1 // 0x00000001
	BaseNetworkSocketBaseSocketSetIpMulticastTtlResultErr      = 2 // 0x00000002
)

type BaseNetworkSocketBaseSocketSetIpMulticastTtlResult struct {
	I_baseNetworkSocketBaseSocketSetIpMulticastTtlResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                                BaseNetworkSocketBaseSocketSetIpMulticastTtlResponse `fidl_ordinal:"1"`
	Err                                                     fuchsiaposix.Errno                                   `fidl_ordinal:"2"`
}

func (_m *BaseNetworkSocketBaseSocketSetIpMulticastTtlResult) reset() {
	switch _m.I_baseNetworkSocketBaseSocketSetIpMulticastTtlResultTag {
	case 1:
		var _zeroed BaseNetworkSocketBaseSocketSetIpMulticastTtlResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseNetworkSocketBaseSocketSetIpMulticastTtlResult) Which() I_baseNetworkSocketBaseSocketSetIpMulticastTtlResultTag {
	return _m.I_baseNetworkSocketBaseSocketSetIpMulticastTtlResultTag
}

func (_m *BaseNetworkSocketBaseSocketSetIpMulticastTtlResult) Ordinal() uint64 {
	return uint64(_m.I_baseNetworkSocketBaseSocketSetIpMulticastTtlResultTag)
}

func (_m *BaseNetworkSocketBaseSocketSetIpMulticastTtlResult) SetResponse(response BaseNetworkSocketBaseSocketSetIpMulticastTtlResponse) {
	_m.reset()
	_m.I_baseNetworkSocketBaseSocketSetIpMulticastTtlResultTag = BaseNetworkSocketBaseSocketSetIpMulticastTtlResultResponse
	_m.Response = response
}

func BaseNetworkSocketBaseSocketSetIpMulticastTtlResultWithResponse(response BaseNetworkSocketBaseSocketSetIpMulticastTtlResponse) BaseNetworkSocketBaseSocketSetIpMulticastTtlResult {
	var _u BaseNetworkSocketBaseSocketSetIpMulticastTtlResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseNetworkSocketBaseSocketSetIpMulticastTtlResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseNetworkSocketBaseSocketSetIpMulticastTtlResultTag = BaseNetworkSocketBaseSocketSetIpMulticastTtlResultErr
	_m.Err = err
}

func BaseNetworkSocketBaseSocketSetIpMulticastTtlResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketBaseSocketSetIpMulticastTtlResult {
	var _u BaseNetworkSocketBaseSocketSetIpMulticastTtlResult
	_u.SetErr(err)
	return _u
}

type I_baseNetworkSocketBaseSocketGetIpMulticastTtlResultTag uint64

const (
	BaseNetworkSocketBaseSocketGetIpMulticastTtlResultResponse = 1 // 0x00000001
	BaseNetworkSocketBaseSocketGetIpMulticastTtlResultErr      = 2 // 0x00000002
)

type BaseNetworkSocketBaseSocketGetIpMulticastTtlResult struct {
	I_baseNetworkSocketBaseSocketGetIpMulticastTtlResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                                BaseNetworkSocketBaseSocketGetIpMulticastTtlResponse `fidl_ordinal:"1"`
	Err                                                     fuchsiaposix.Errno                                   `fidl_ordinal:"2"`
}

func (_m *BaseNetworkSocketBaseSocketGetIpMulticastTtlResult) reset() {
	switch _m.I_baseNetworkSocketBaseSocketGetIpMulticastTtlResultTag {
	case 1:
		var _zeroed BaseNetworkSocketBaseSocketGetIpMulticastTtlResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseNetworkSocketBaseSocketGetIpMulticastTtlResult) Which() I_baseNetworkSocketBaseSocketGetIpMulticastTtlResultTag {
	return _m.I_baseNetworkSocketBaseSocketGetIpMulticastTtlResultTag
}

func (_m *BaseNetworkSocketBaseSocketGetIpMulticastTtlResult) Ordinal() uint64 {
	return uint64(_m.I_baseNetworkSocketBaseSocketGetIpMulticastTtlResultTag)
}

func (_m *BaseNetworkSocketBaseSocketGetIpMulticastTtlResult) SetResponse(response BaseNetworkSocketBaseSocketGetIpMulticastTtlResponse) {
	_m.reset()
	_m.I_baseNetworkSocketBaseSocketGetIpMulticastTtlResultTag = BaseNetworkSocketBaseSocketGetIpMulticastTtlResultResponse
	_m.Response = response
}

func BaseNetworkSocketBaseSocketGetIpMulticastTtlResultWithResponse(response BaseNetworkSocketBaseSocketGetIpMulticastTtlResponse) BaseNetworkSocketBaseSocketGetIpMulticastTtlResult {
	var _u BaseNetworkSocketBaseSocketGetIpMulticastTtlResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseNetworkSocketBaseSocketGetIpMulticastTtlResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseNetworkSocketBaseSocketGetIpMulticastTtlResultTag = BaseNetworkSocketBaseSocketGetIpMulticastTtlResultErr
	_m.Err = err
}

func BaseNetworkSocketBaseSocketGetIpMulticastTtlResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketBaseSocketGetIpMulticastTtlResult {
	var _u BaseNetworkSocketBaseSocketGetIpMulticastTtlResult
	_u.SetErr(err)
	return _u
}

type I_baseNetworkSocketBaseSocketSetIpMulticastLoopbackResultTag uint64

const (
	BaseNetworkSocketBaseSocketSetIpMulticastLoopbackResultResponse = 1 // 0x00000001
	BaseNetworkSocketBaseSocketSetIpMulticastLoopbackResultErr      = 2 // 0x00000002
)

type BaseNetworkSocketBaseSocketSetIpMulticastLoopbackResult struct {
	I_baseNetworkSocketBaseSocketSetIpMulticastLoopbackResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                                     BaseNetworkSocketBaseSocketSetIpMulticastLoopbackResponse `fidl_ordinal:"1"`
	Err                                                          fuchsiaposix.Errno                                        `fidl_ordinal:"2"`
}

func (_m *BaseNetworkSocketBaseSocketSetIpMulticastLoopbackResult) reset() {
	switch _m.I_baseNetworkSocketBaseSocketSetIpMulticastLoopbackResultTag {
	case 1:
		var _zeroed BaseNetworkSocketBaseSocketSetIpMulticastLoopbackResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseNetworkSocketBaseSocketSetIpMulticastLoopbackResult) Which() I_baseNetworkSocketBaseSocketSetIpMulticastLoopbackResultTag {
	return _m.I_baseNetworkSocketBaseSocketSetIpMulticastLoopbackResultTag
}

func (_m *BaseNetworkSocketBaseSocketSetIpMulticastLoopbackResult) Ordinal() uint64 {
	return uint64(_m.I_baseNetworkSocketBaseSocketSetIpMulticastLoopbackResultTag)
}

func (_m *BaseNetworkSocketBaseSocketSetIpMulticastLoopbackResult) SetResponse(response BaseNetworkSocketBaseSocketSetIpMulticastLoopbackResponse) {
	_m.reset()
	_m.I_baseNetworkSocketBaseSocketSetIpMulticastLoopbackResultTag = BaseNetworkSocketBaseSocketSetIpMulticastLoopbackResultResponse
	_m.Response = response
}

func BaseNetworkSocketBaseSocketSetIpMulticastLoopbackResultWithResponse(response BaseNetworkSocketBaseSocketSetIpMulticastLoopbackResponse) BaseNetworkSocketBaseSocketSetIpMulticastLoopbackResult {
	var _u BaseNetworkSocketBaseSocketSetIpMulticastLoopbackResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseNetworkSocketBaseSocketSetIpMulticastLoopbackResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseNetworkSocketBaseSocketSetIpMulticastLoopbackResultTag = BaseNetworkSocketBaseSocketSetIpMulticastLoopbackResultErr
	_m.Err = err
}

func BaseNetworkSocketBaseSocketSetIpMulticastLoopbackResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketBaseSocketSetIpMulticastLoopbackResult {
	var _u BaseNetworkSocketBaseSocketSetIpMulticastLoopbackResult
	_u.SetErr(err)
	return _u
}

type I_baseNetworkSocketBaseSocketGetIpMulticastLoopbackResultTag uint64

const (
	BaseNetworkSocketBaseSocketGetIpMulticastLoopbackResultResponse = 1 // 0x00000001
	BaseNetworkSocketBaseSocketGetIpMulticastLoopbackResultErr      = 2 // 0x00000002
)

type BaseNetworkSocketBaseSocketGetIpMulticastLoopbackResult struct {
	I_baseNetworkSocketBaseSocketGetIpMulticastLoopbackResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                                     BaseNetworkSocketBaseSocketGetIpMulticastLoopbackResponse `fidl_ordinal:"1"`
	Err                                                          fuchsiaposix.Errno                                        `fidl_ordinal:"2"`
}

func (_m *BaseNetworkSocketBaseSocketGetIpMulticastLoopbackResult) reset() {
	switch _m.I_baseNetworkSocketBaseSocketGetIpMulticastLoopbackResultTag {
	case 1:
		var _zeroed BaseNetworkSocketBaseSocketGetIpMulticastLoopbackResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseNetworkSocketBaseSocketGetIpMulticastLoopbackResult) Which() I_baseNetworkSocketBaseSocketGetIpMulticastLoopbackResultTag {
	return _m.I_baseNetworkSocketBaseSocketGetIpMulticastLoopbackResultTag
}

func (_m *BaseNetworkSocketBaseSocketGetIpMulticastLoopbackResult) Ordinal() uint64 {
	return uint64(_m.I_baseNetworkSocketBaseSocketGetIpMulticastLoopbackResultTag)
}

func (_m *BaseNetworkSocketBaseSocketGetIpMulticastLoopbackResult) SetResponse(response BaseNetworkSocketBaseSocketGetIpMulticastLoopbackResponse) {
	_m.reset()
	_m.I_baseNetworkSocketBaseSocketGetIpMulticastLoopbackResultTag = BaseNetworkSocketBaseSocketGetIpMulticastLoopbackResultResponse
	_m.Response = response
}

func BaseNetworkSocketBaseSocketGetIpMulticastLoopbackResultWithResponse(response BaseNetworkSocketBaseSocketGetIpMulticastLoopbackResponse) BaseNetworkSocketBaseSocketGetIpMulticastLoopbackResult {
	var _u BaseNetworkSocketBaseSocketGetIpMulticastLoopbackResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseNetworkSocketBaseSocketGetIpMulticastLoopbackResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseNetworkSocketBaseSocketGetIpMulticastLoopbackResultTag = BaseNetworkSocketBaseSocketGetIpMulticastLoopbackResultErr
	_m.Err = err
}

func BaseNetworkSocketBaseSocketGetIpMulticastLoopbackResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketBaseSocketGetIpMulticastLoopbackResult {
	var _u BaseNetworkSocketBaseSocketGetIpMulticastLoopbackResult
	_u.SetErr(err)
	return _u
}

type I_baseNetworkSocketBaseSocketAddIpMembershipResultTag uint64

const (
	BaseNetworkSocketBaseSocketAddIpMembershipResultResponse = 1 // 0x00000001
	BaseNetworkSocketBaseSocketAddIpMembershipResultErr      = 2 // 0x00000002
)

type BaseNetworkSocketBaseSocketAddIpMembershipResult struct {
	I_baseNetworkSocketBaseSocketAddIpMembershipResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                              BaseNetworkSocketBaseSocketAddIpMembershipResponse `fidl_ordinal:"1"`
	Err                                                   fuchsiaposix.Errno                                 `fidl_ordinal:"2"`
}

func (_m *BaseNetworkSocketBaseSocketAddIpMembershipResult) reset() {
	switch _m.I_baseNetworkSocketBaseSocketAddIpMembershipResultTag {
	case 1:
		var _zeroed BaseNetworkSocketBaseSocketAddIpMembershipResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseNetworkSocketBaseSocketAddIpMembershipResult) Which() I_baseNetworkSocketBaseSocketAddIpMembershipResultTag {
	return _m.I_baseNetworkSocketBaseSocketAddIpMembershipResultTag
}

func (_m *BaseNetworkSocketBaseSocketAddIpMembershipResult) Ordinal() uint64 {
	return uint64(_m.I_baseNetworkSocketBaseSocketAddIpMembershipResultTag)
}

func (_m *BaseNetworkSocketBaseSocketAddIpMembershipResult) SetResponse(response BaseNetworkSocketBaseSocketAddIpMembershipResponse) {
	_m.reset()
	_m.I_baseNetworkSocketBaseSocketAddIpMembershipResultTag = BaseNetworkSocketBaseSocketAddIpMembershipResultResponse
	_m.Response = response
}

func BaseNetworkSocketBaseSocketAddIpMembershipResultWithResponse(response BaseNetworkSocketBaseSocketAddIpMembershipResponse) BaseNetworkSocketBaseSocketAddIpMembershipResult {
	var _u BaseNetworkSocketBaseSocketAddIpMembershipResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseNetworkSocketBaseSocketAddIpMembershipResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseNetworkSocketBaseSocketAddIpMembershipResultTag = BaseNetworkSocketBaseSocketAddIpMembershipResultErr
	_m.Err = err
}

func BaseNetworkSocketBaseSocketAddIpMembershipResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketBaseSocketAddIpMembershipResult {
	var _u BaseNetworkSocketBaseSocketAddIpMembershipResult
	_u.SetErr(err)
	return _u
}

type I_baseNetworkSocketBaseSocketDropIpMembershipResultTag uint64

const (
	BaseNetworkSocketBaseSocketDropIpMembershipResultResponse = 1 // 0x00000001
	BaseNetworkSocketBaseSocketDropIpMembershipResultErr      = 2 // 0x00000002
)

type BaseNetworkSocketBaseSocketDropIpMembershipResult struct {
	I_baseNetworkSocketBaseSocketDropIpMembershipResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                               BaseNetworkSocketBaseSocketDropIpMembershipResponse `fidl_ordinal:"1"`
	Err                                                    fuchsiaposix.Errno                                  `fidl_ordinal:"2"`
}

func (_m *BaseNetworkSocketBaseSocketDropIpMembershipResult) reset() {
	switch _m.I_baseNetworkSocketBaseSocketDropIpMembershipResultTag {
	case 1:
		var _zeroed BaseNetworkSocketBaseSocketDropIpMembershipResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseNetworkSocketBaseSocketDropIpMembershipResult) Which() I_baseNetworkSocketBaseSocketDropIpMembershipResultTag {
	return _m.I_baseNetworkSocketBaseSocketDropIpMembershipResultTag
}

func (_m *BaseNetworkSocketBaseSocketDropIpMembershipResult) Ordinal() uint64 {
	return uint64(_m.I_baseNetworkSocketBaseSocketDropIpMembershipResultTag)
}

func (_m *BaseNetworkSocketBaseSocketDropIpMembershipResult) SetResponse(response BaseNetworkSocketBaseSocketDropIpMembershipResponse) {
	_m.reset()
	_m.I_baseNetworkSocketBaseSocketDropIpMembershipResultTag = BaseNetworkSocketBaseSocketDropIpMembershipResultResponse
	_m.Response = response
}

func BaseNetworkSocketBaseSocketDropIpMembershipResultWithResponse(response BaseNetworkSocketBaseSocketDropIpMembershipResponse) BaseNetworkSocketBaseSocketDropIpMembershipResult {
	var _u BaseNetworkSocketBaseSocketDropIpMembershipResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseNetworkSocketBaseSocketDropIpMembershipResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseNetworkSocketBaseSocketDropIpMembershipResultTag = BaseNetworkSocketBaseSocketDropIpMembershipResultErr
	_m.Err = err
}

func BaseNetworkSocketBaseSocketDropIpMembershipResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketBaseSocketDropIpMembershipResult {
	var _u BaseNetworkSocketBaseSocketDropIpMembershipResult
	_u.SetErr(err)
	return _u
}

type I_baseNetworkSocketBaseSocketAddIpv6MembershipResultTag uint64

const (
	BaseNetworkSocketBaseSocketAddIpv6MembershipResultResponse = 1 // 0x00000001
	BaseNetworkSocketBaseSocketAddIpv6MembershipResultErr      = 2 // 0x00000002
)

type BaseNetworkSocketBaseSocketAddIpv6MembershipResult struct {
	I_baseNetworkSocketBaseSocketAddIpv6MembershipResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                                BaseNetworkSocketBaseSocketAddIpv6MembershipResponse `fidl_ordinal:"1"`
	Err                                                     fuchsiaposix.Errno                                   `fidl_ordinal:"2"`
}

func (_m *BaseNetworkSocketBaseSocketAddIpv6MembershipResult) reset() {
	switch _m.I_baseNetworkSocketBaseSocketAddIpv6MembershipResultTag {
	case 1:
		var _zeroed BaseNetworkSocketBaseSocketAddIpv6MembershipResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseNetworkSocketBaseSocketAddIpv6MembershipResult) Which() I_baseNetworkSocketBaseSocketAddIpv6MembershipResultTag {
	return _m.I_baseNetworkSocketBaseSocketAddIpv6MembershipResultTag
}

func (_m *BaseNetworkSocketBaseSocketAddIpv6MembershipResult) Ordinal() uint64 {
	return uint64(_m.I_baseNetworkSocketBaseSocketAddIpv6MembershipResultTag)
}

func (_m *BaseNetworkSocketBaseSocketAddIpv6MembershipResult) SetResponse(response BaseNetworkSocketBaseSocketAddIpv6MembershipResponse) {
	_m.reset()
	_m.I_baseNetworkSocketBaseSocketAddIpv6MembershipResultTag = BaseNetworkSocketBaseSocketAddIpv6MembershipResultResponse
	_m.Response = response
}

func BaseNetworkSocketBaseSocketAddIpv6MembershipResultWithResponse(response BaseNetworkSocketBaseSocketAddIpv6MembershipResponse) BaseNetworkSocketBaseSocketAddIpv6MembershipResult {
	var _u BaseNetworkSocketBaseSocketAddIpv6MembershipResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseNetworkSocketBaseSocketAddIpv6MembershipResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseNetworkSocketBaseSocketAddIpv6MembershipResultTag = BaseNetworkSocketBaseSocketAddIpv6MembershipResultErr
	_m.Err = err
}

func BaseNetworkSocketBaseSocketAddIpv6MembershipResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketBaseSocketAddIpv6MembershipResult {
	var _u BaseNetworkSocketBaseSocketAddIpv6MembershipResult
	_u.SetErr(err)
	return _u
}

type I_baseNetworkSocketBaseSocketDropIpv6MembershipResultTag uint64

const (
	BaseNetworkSocketBaseSocketDropIpv6MembershipResultResponse = 1 // 0x00000001
	BaseNetworkSocketBaseSocketDropIpv6MembershipResultErr      = 2 // 0x00000002
)

type BaseNetworkSocketBaseSocketDropIpv6MembershipResult struct {
	I_baseNetworkSocketBaseSocketDropIpv6MembershipResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                                 BaseNetworkSocketBaseSocketDropIpv6MembershipResponse `fidl_ordinal:"1"`
	Err                                                      fuchsiaposix.Errno                                    `fidl_ordinal:"2"`
}

func (_m *BaseNetworkSocketBaseSocketDropIpv6MembershipResult) reset() {
	switch _m.I_baseNetworkSocketBaseSocketDropIpv6MembershipResultTag {
	case 1:
		var _zeroed BaseNetworkSocketBaseSocketDropIpv6MembershipResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseNetworkSocketBaseSocketDropIpv6MembershipResult) Which() I_baseNetworkSocketBaseSocketDropIpv6MembershipResultTag {
	return _m.I_baseNetworkSocketBaseSocketDropIpv6MembershipResultTag
}

func (_m *BaseNetworkSocketBaseSocketDropIpv6MembershipResult) Ordinal() uint64 {
	return uint64(_m.I_baseNetworkSocketBaseSocketDropIpv6MembershipResultTag)
}

func (_m *BaseNetworkSocketBaseSocketDropIpv6MembershipResult) SetResponse(response BaseNetworkSocketBaseSocketDropIpv6MembershipResponse) {
	_m.reset()
	_m.I_baseNetworkSocketBaseSocketDropIpv6MembershipResultTag = BaseNetworkSocketBaseSocketDropIpv6MembershipResultResponse
	_m.Response = response
}

func BaseNetworkSocketBaseSocketDropIpv6MembershipResultWithResponse(response BaseNetworkSocketBaseSocketDropIpv6MembershipResponse) BaseNetworkSocketBaseSocketDropIpv6MembershipResult {
	var _u BaseNetworkSocketBaseSocketDropIpv6MembershipResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseNetworkSocketBaseSocketDropIpv6MembershipResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseNetworkSocketBaseSocketDropIpv6MembershipResultTag = BaseNetworkSocketBaseSocketDropIpv6MembershipResultErr
	_m.Err = err
}

func BaseNetworkSocketBaseSocketDropIpv6MembershipResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketBaseSocketDropIpv6MembershipResult {
	var _u BaseNetworkSocketBaseSocketDropIpv6MembershipResult
	_u.SetErr(err)
	return _u
}

type I_baseNetworkSocketBaseSocketSetIpv6MulticastInterfaceResultTag uint64

const (
	BaseNetworkSocketBaseSocketSetIpv6MulticastInterfaceResultResponse = 1 // 0x00000001
	BaseNetworkSocketBaseSocketSetIpv6MulticastInterfaceResultErr      = 2 // 0x00000002
)

type BaseNetworkSocketBaseSocketSetIpv6MulticastInterfaceResult struct {
	I_baseNetworkSocketBaseSocketSetIpv6MulticastInterfaceResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                                        BaseNetworkSocketBaseSocketSetIpv6MulticastInterfaceResponse `fidl_ordinal:"1"`
	Err                                                             fuchsiaposix.Errno                                           `fidl_ordinal:"2"`
}

func (_m *BaseNetworkSocketBaseSocketSetIpv6MulticastInterfaceResult) reset() {
	switch _m.I_baseNetworkSocketBaseSocketSetIpv6MulticastInterfaceResultTag {
	case 1:
		var _zeroed BaseNetworkSocketBaseSocketSetIpv6MulticastInterfaceResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseNetworkSocketBaseSocketSetIpv6MulticastInterfaceResult) Which() I_baseNetworkSocketBaseSocketSetIpv6MulticastInterfaceResultTag {
	return _m.I_baseNetworkSocketBaseSocketSetIpv6MulticastInterfaceResultTag
}

func (_m *BaseNetworkSocketBaseSocketSetIpv6MulticastInterfaceResult) Ordinal() uint64 {
	return uint64(_m.I_baseNetworkSocketBaseSocketSetIpv6MulticastInterfaceResultTag)
}

func (_m *BaseNetworkSocketBaseSocketSetIpv6MulticastInterfaceResult) SetResponse(response BaseNetworkSocketBaseSocketSetIpv6MulticastInterfaceResponse) {
	_m.reset()
	_m.I_baseNetworkSocketBaseSocketSetIpv6MulticastInterfaceResultTag = BaseNetworkSocketBaseSocketSetIpv6MulticastInterfaceResultResponse
	_m.Response = response
}

func BaseNetworkSocketBaseSocketSetIpv6MulticastInterfaceResultWithResponse(response BaseNetworkSocketBaseSocketSetIpv6MulticastInterfaceResponse) BaseNetworkSocketBaseSocketSetIpv6MulticastInterfaceResult {
	var _u BaseNetworkSocketBaseSocketSetIpv6MulticastInterfaceResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseNetworkSocketBaseSocketSetIpv6MulticastInterfaceResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseNetworkSocketBaseSocketSetIpv6MulticastInterfaceResultTag = BaseNetworkSocketBaseSocketSetIpv6MulticastInterfaceResultErr
	_m.Err = err
}

func BaseNetworkSocketBaseSocketSetIpv6MulticastInterfaceResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketBaseSocketSetIpv6MulticastInterfaceResult {
	var _u BaseNetworkSocketBaseSocketSetIpv6MulticastInterfaceResult
	_u.SetErr(err)
	return _u
}

type I_baseNetworkSocketBaseSocketGetIpv6MulticastInterfaceResultTag uint64

const (
	BaseNetworkSocketBaseSocketGetIpv6MulticastInterfaceResultResponse = 1 // 0x00000001
	BaseNetworkSocketBaseSocketGetIpv6MulticastInterfaceResultErr      = 2 // 0x00000002
)

type BaseNetworkSocketBaseSocketGetIpv6MulticastInterfaceResult struct {
	I_baseNetworkSocketBaseSocketGetIpv6MulticastInterfaceResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                                        BaseNetworkSocketBaseSocketGetIpv6MulticastInterfaceResponse `fidl_ordinal:"1"`
	Err                                                             fuchsiaposix.Errno                                           `fidl_ordinal:"2"`
}

func (_m *BaseNetworkSocketBaseSocketGetIpv6MulticastInterfaceResult) reset() {
	switch _m.I_baseNetworkSocketBaseSocketGetIpv6MulticastInterfaceResultTag {
	case 1:
		var _zeroed BaseNetworkSocketBaseSocketGetIpv6MulticastInterfaceResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseNetworkSocketBaseSocketGetIpv6MulticastInterfaceResult) Which() I_baseNetworkSocketBaseSocketGetIpv6MulticastInterfaceResultTag {
	return _m.I_baseNetworkSocketBaseSocketGetIpv6MulticastInterfaceResultTag
}

func (_m *BaseNetworkSocketBaseSocketGetIpv6MulticastInterfaceResult) Ordinal() uint64 {
	return uint64(_m.I_baseNetworkSocketBaseSocketGetIpv6MulticastInterfaceResultTag)
}

func (_m *BaseNetworkSocketBaseSocketGetIpv6MulticastInterfaceResult) SetResponse(response BaseNetworkSocketBaseSocketGetIpv6MulticastInterfaceResponse) {
	_m.reset()
	_m.I_baseNetworkSocketBaseSocketGetIpv6MulticastInterfaceResultTag = BaseNetworkSocketBaseSocketGetIpv6MulticastInterfaceResultResponse
	_m.Response = response
}

func BaseNetworkSocketBaseSocketGetIpv6MulticastInterfaceResultWithResponse(response BaseNetworkSocketBaseSocketGetIpv6MulticastInterfaceResponse) BaseNetworkSocketBaseSocketGetIpv6MulticastInterfaceResult {
	var _u BaseNetworkSocketBaseSocketGetIpv6MulticastInterfaceResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseNetworkSocketBaseSocketGetIpv6MulticastInterfaceResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseNetworkSocketBaseSocketGetIpv6MulticastInterfaceResultTag = BaseNetworkSocketBaseSocketGetIpv6MulticastInterfaceResultErr
	_m.Err = err
}

func BaseNetworkSocketBaseSocketGetIpv6MulticastInterfaceResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketBaseSocketGetIpv6MulticastInterfaceResult {
	var _u BaseNetworkSocketBaseSocketGetIpv6MulticastInterfaceResult
	_u.SetErr(err)
	return _u
}

type I_baseNetworkSocketBaseSocketSetIpv6MulticastHopsResultTag uint64

const (
	BaseNetworkSocketBaseSocketSetIpv6MulticastHopsResultResponse = 1 // 0x00000001
	BaseNetworkSocketBaseSocketSetIpv6MulticastHopsResultErr      = 2 // 0x00000002
)

type BaseNetworkSocketBaseSocketSetIpv6MulticastHopsResult struct {
	I_baseNetworkSocketBaseSocketSetIpv6MulticastHopsResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                                   BaseNetworkSocketBaseSocketSetIpv6MulticastHopsResponse `fidl_ordinal:"1"`
	Err                                                        fuchsiaposix.Errno                                      `fidl_ordinal:"2"`
}

func (_m *BaseNetworkSocketBaseSocketSetIpv6MulticastHopsResult) reset() {
	switch _m.I_baseNetworkSocketBaseSocketSetIpv6MulticastHopsResultTag {
	case 1:
		var _zeroed BaseNetworkSocketBaseSocketSetIpv6MulticastHopsResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseNetworkSocketBaseSocketSetIpv6MulticastHopsResult) Which() I_baseNetworkSocketBaseSocketSetIpv6MulticastHopsResultTag {
	return _m.I_baseNetworkSocketBaseSocketSetIpv6MulticastHopsResultTag
}

func (_m *BaseNetworkSocketBaseSocketSetIpv6MulticastHopsResult) Ordinal() uint64 {
	return uint64(_m.I_baseNetworkSocketBaseSocketSetIpv6MulticastHopsResultTag)
}

func (_m *BaseNetworkSocketBaseSocketSetIpv6MulticastHopsResult) SetResponse(response BaseNetworkSocketBaseSocketSetIpv6MulticastHopsResponse) {
	_m.reset()
	_m.I_baseNetworkSocketBaseSocketSetIpv6MulticastHopsResultTag = BaseNetworkSocketBaseSocketSetIpv6MulticastHopsResultResponse
	_m.Response = response
}

func BaseNetworkSocketBaseSocketSetIpv6MulticastHopsResultWithResponse(response BaseNetworkSocketBaseSocketSetIpv6MulticastHopsResponse) BaseNetworkSocketBaseSocketSetIpv6MulticastHopsResult {
	var _u BaseNetworkSocketBaseSocketSetIpv6MulticastHopsResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseNetworkSocketBaseSocketSetIpv6MulticastHopsResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseNetworkSocketBaseSocketSetIpv6MulticastHopsResultTag = BaseNetworkSocketBaseSocketSetIpv6MulticastHopsResultErr
	_m.Err = err
}

func BaseNetworkSocketBaseSocketSetIpv6MulticastHopsResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketBaseSocketSetIpv6MulticastHopsResult {
	var _u BaseNetworkSocketBaseSocketSetIpv6MulticastHopsResult
	_u.SetErr(err)
	return _u
}

type I_baseNetworkSocketBaseSocketGetIpv6MulticastHopsResultTag uint64

const (
	BaseNetworkSocketBaseSocketGetIpv6MulticastHopsResultResponse = 1 // 0x00000001
	BaseNetworkSocketBaseSocketGetIpv6MulticastHopsResultErr      = 2 // 0x00000002
)

type BaseNetworkSocketBaseSocketGetIpv6MulticastHopsResult struct {
	I_baseNetworkSocketBaseSocketGetIpv6MulticastHopsResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                                   BaseNetworkSocketBaseSocketGetIpv6MulticastHopsResponse `fidl_ordinal:"1"`
	Err                                                        fuchsiaposix.Errno                                      `fidl_ordinal:"2"`
}

func (_m *BaseNetworkSocketBaseSocketGetIpv6MulticastHopsResult) reset() {
	switch _m.I_baseNetworkSocketBaseSocketGetIpv6MulticastHopsResultTag {
	case 1:
		var _zeroed BaseNetworkSocketBaseSocketGetIpv6MulticastHopsResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseNetworkSocketBaseSocketGetIpv6MulticastHopsResult) Which() I_baseNetworkSocketBaseSocketGetIpv6MulticastHopsResultTag {
	return _m.I_baseNetworkSocketBaseSocketGetIpv6MulticastHopsResultTag
}

func (_m *BaseNetworkSocketBaseSocketGetIpv6MulticastHopsResult) Ordinal() uint64 {
	return uint64(_m.I_baseNetworkSocketBaseSocketGetIpv6MulticastHopsResultTag)
}

func (_m *BaseNetworkSocketBaseSocketGetIpv6MulticastHopsResult) SetResponse(response BaseNetworkSocketBaseSocketGetIpv6MulticastHopsResponse) {
	_m.reset()
	_m.I_baseNetworkSocketBaseSocketGetIpv6MulticastHopsResultTag = BaseNetworkSocketBaseSocketGetIpv6MulticastHopsResultResponse
	_m.Response = response
}

func BaseNetworkSocketBaseSocketGetIpv6MulticastHopsResultWithResponse(response BaseNetworkSocketBaseSocketGetIpv6MulticastHopsResponse) BaseNetworkSocketBaseSocketGetIpv6MulticastHopsResult {
	var _u BaseNetworkSocketBaseSocketGetIpv6MulticastHopsResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseNetworkSocketBaseSocketGetIpv6MulticastHopsResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseNetworkSocketBaseSocketGetIpv6MulticastHopsResultTag = BaseNetworkSocketBaseSocketGetIpv6MulticastHopsResultErr
	_m.Err = err
}

func BaseNetworkSocketBaseSocketGetIpv6MulticastHopsResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketBaseSocketGetIpv6MulticastHopsResult {
	var _u BaseNetworkSocketBaseSocketGetIpv6MulticastHopsResult
	_u.SetErr(err)
	return _u
}

type I_baseNetworkSocketBaseSocketSetIpv6MulticastLoopbackResultTag uint64

const (
	BaseNetworkSocketBaseSocketSetIpv6MulticastLoopbackResultResponse = 1 // 0x00000001
	BaseNetworkSocketBaseSocketSetIpv6MulticastLoopbackResultErr      = 2 // 0x00000002
)

type BaseNetworkSocketBaseSocketSetIpv6MulticastLoopbackResult struct {
	I_baseNetworkSocketBaseSocketSetIpv6MulticastLoopbackResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                                       BaseNetworkSocketBaseSocketSetIpv6MulticastLoopbackResponse `fidl_ordinal:"1"`
	Err                                                            fuchsiaposix.Errno                                          `fidl_ordinal:"2"`
}

func (_m *BaseNetworkSocketBaseSocketSetIpv6MulticastLoopbackResult) reset() {
	switch _m.I_baseNetworkSocketBaseSocketSetIpv6MulticastLoopbackResultTag {
	case 1:
		var _zeroed BaseNetworkSocketBaseSocketSetIpv6MulticastLoopbackResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseNetworkSocketBaseSocketSetIpv6MulticastLoopbackResult) Which() I_baseNetworkSocketBaseSocketSetIpv6MulticastLoopbackResultTag {
	return _m.I_baseNetworkSocketBaseSocketSetIpv6MulticastLoopbackResultTag
}

func (_m *BaseNetworkSocketBaseSocketSetIpv6MulticastLoopbackResult) Ordinal() uint64 {
	return uint64(_m.I_baseNetworkSocketBaseSocketSetIpv6MulticastLoopbackResultTag)
}

func (_m *BaseNetworkSocketBaseSocketSetIpv6MulticastLoopbackResult) SetResponse(response BaseNetworkSocketBaseSocketSetIpv6MulticastLoopbackResponse) {
	_m.reset()
	_m.I_baseNetworkSocketBaseSocketSetIpv6MulticastLoopbackResultTag = BaseNetworkSocketBaseSocketSetIpv6MulticastLoopbackResultResponse
	_m.Response = response
}

func BaseNetworkSocketBaseSocketSetIpv6MulticastLoopbackResultWithResponse(response BaseNetworkSocketBaseSocketSetIpv6MulticastLoopbackResponse) BaseNetworkSocketBaseSocketSetIpv6MulticastLoopbackResult {
	var _u BaseNetworkSocketBaseSocketSetIpv6MulticastLoopbackResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseNetworkSocketBaseSocketSetIpv6MulticastLoopbackResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseNetworkSocketBaseSocketSetIpv6MulticastLoopbackResultTag = BaseNetworkSocketBaseSocketSetIpv6MulticastLoopbackResultErr
	_m.Err = err
}

func BaseNetworkSocketBaseSocketSetIpv6MulticastLoopbackResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketBaseSocketSetIpv6MulticastLoopbackResult {
	var _u BaseNetworkSocketBaseSocketSetIpv6MulticastLoopbackResult
	_u.SetErr(err)
	return _u
}

type I_baseNetworkSocketBaseSocketGetIpv6MulticastLoopbackResultTag uint64

const (
	BaseNetworkSocketBaseSocketGetIpv6MulticastLoopbackResultResponse = 1 // 0x00000001
	BaseNetworkSocketBaseSocketGetIpv6MulticastLoopbackResultErr      = 2 // 0x00000002
)

type BaseNetworkSocketBaseSocketGetIpv6MulticastLoopbackResult struct {
	I_baseNetworkSocketBaseSocketGetIpv6MulticastLoopbackResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                                       BaseNetworkSocketBaseSocketGetIpv6MulticastLoopbackResponse `fidl_ordinal:"1"`
	Err                                                            fuchsiaposix.Errno                                          `fidl_ordinal:"2"`
}

func (_m *BaseNetworkSocketBaseSocketGetIpv6MulticastLoopbackResult) reset() {
	switch _m.I_baseNetworkSocketBaseSocketGetIpv6MulticastLoopbackResultTag {
	case 1:
		var _zeroed BaseNetworkSocketBaseSocketGetIpv6MulticastLoopbackResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseNetworkSocketBaseSocketGetIpv6MulticastLoopbackResult) Which() I_baseNetworkSocketBaseSocketGetIpv6MulticastLoopbackResultTag {
	return _m.I_baseNetworkSocketBaseSocketGetIpv6MulticastLoopbackResultTag
}

func (_m *BaseNetworkSocketBaseSocketGetIpv6MulticastLoopbackResult) Ordinal() uint64 {
	return uint64(_m.I_baseNetworkSocketBaseSocketGetIpv6MulticastLoopbackResultTag)
}

func (_m *BaseNetworkSocketBaseSocketGetIpv6MulticastLoopbackResult) SetResponse(response BaseNetworkSocketBaseSocketGetIpv6MulticastLoopbackResponse) {
	_m.reset()
	_m.I_baseNetworkSocketBaseSocketGetIpv6MulticastLoopbackResultTag = BaseNetworkSocketBaseSocketGetIpv6MulticastLoopbackResultResponse
	_m.Response = response
}

func BaseNetworkSocketBaseSocketGetIpv6MulticastLoopbackResultWithResponse(response BaseNetworkSocketBaseSocketGetIpv6MulticastLoopbackResponse) BaseNetworkSocketBaseSocketGetIpv6MulticastLoopbackResult {
	var _u BaseNetworkSocketBaseSocketGetIpv6MulticastLoopbackResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseNetworkSocketBaseSocketGetIpv6MulticastLoopbackResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseNetworkSocketBaseSocketGetIpv6MulticastLoopbackResultTag = BaseNetworkSocketBaseSocketGetIpv6MulticastLoopbackResultErr
	_m.Err = err
}

func BaseNetworkSocketBaseSocketGetIpv6MulticastLoopbackResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketBaseSocketGetIpv6MulticastLoopbackResult {
	var _u BaseNetworkSocketBaseSocketGetIpv6MulticastLoopbackResult
	_u.SetErr(err)
	return _u
}

type I_baseNetworkSocketBaseSocketSetIpv6OnlyResultTag uint64

const (
	BaseNetworkSocketBaseSocketSetIpv6OnlyResultResponse = 1 // 0x00000001
	BaseNetworkSocketBaseSocketSetIpv6OnlyResultErr      = 2 // 0x00000002
)

type BaseNetworkSocketBaseSocketSetIpv6OnlyResult struct {
	I_baseNetworkSocketBaseSocketSetIpv6OnlyResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                          BaseNetworkSocketBaseSocketSetIpv6OnlyResponse `fidl_ordinal:"1"`
	Err                                               fuchsiaposix.Errno                             `fidl_ordinal:"2"`
}

func (_m *BaseNetworkSocketBaseSocketSetIpv6OnlyResult) reset() {
	switch _m.I_baseNetworkSocketBaseSocketSetIpv6OnlyResultTag {
	case 1:
		var _zeroed BaseNetworkSocketBaseSocketSetIpv6OnlyResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseNetworkSocketBaseSocketSetIpv6OnlyResult) Which() I_baseNetworkSocketBaseSocketSetIpv6OnlyResultTag {
	return _m.I_baseNetworkSocketBaseSocketSetIpv6OnlyResultTag
}

func (_m *BaseNetworkSocketBaseSocketSetIpv6OnlyResult) Ordinal() uint64 {
	return uint64(_m.I_baseNetworkSocketBaseSocketSetIpv6OnlyResultTag)
}

func (_m *BaseNetworkSocketBaseSocketSetIpv6OnlyResult) SetResponse(response BaseNetworkSocketBaseSocketSetIpv6OnlyResponse) {
	_m.reset()
	_m.I_baseNetworkSocketBaseSocketSetIpv6OnlyResultTag = BaseNetworkSocketBaseSocketSetIpv6OnlyResultResponse
	_m.Response = response
}

func BaseNetworkSocketBaseSocketSetIpv6OnlyResultWithResponse(response BaseNetworkSocketBaseSocketSetIpv6OnlyResponse) BaseNetworkSocketBaseSocketSetIpv6OnlyResult {
	var _u BaseNetworkSocketBaseSocketSetIpv6OnlyResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseNetworkSocketBaseSocketSetIpv6OnlyResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseNetworkSocketBaseSocketSetIpv6OnlyResultTag = BaseNetworkSocketBaseSocketSetIpv6OnlyResultErr
	_m.Err = err
}

func BaseNetworkSocketBaseSocketSetIpv6OnlyResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketBaseSocketSetIpv6OnlyResult {
	var _u BaseNetworkSocketBaseSocketSetIpv6OnlyResult
	_u.SetErr(err)
	return _u
}

type I_baseNetworkSocketBaseSocketGetIpv6OnlyResultTag uint64

const (
	BaseNetworkSocketBaseSocketGetIpv6OnlyResultResponse = 1 // 0x00000001
	BaseNetworkSocketBaseSocketGetIpv6OnlyResultErr      = 2 // 0x00000002
)

type BaseNetworkSocketBaseSocketGetIpv6OnlyResult struct {
	I_baseNetworkSocketBaseSocketGetIpv6OnlyResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                          BaseNetworkSocketBaseSocketGetIpv6OnlyResponse `fidl_ordinal:"1"`
	Err                                               fuchsiaposix.Errno                             `fidl_ordinal:"2"`
}

func (_m *BaseNetworkSocketBaseSocketGetIpv6OnlyResult) reset() {
	switch _m.I_baseNetworkSocketBaseSocketGetIpv6OnlyResultTag {
	case 1:
		var _zeroed BaseNetworkSocketBaseSocketGetIpv6OnlyResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseNetworkSocketBaseSocketGetIpv6OnlyResult) Which() I_baseNetworkSocketBaseSocketGetIpv6OnlyResultTag {
	return _m.I_baseNetworkSocketBaseSocketGetIpv6OnlyResultTag
}

func (_m *BaseNetworkSocketBaseSocketGetIpv6OnlyResult) Ordinal() uint64 {
	return uint64(_m.I_baseNetworkSocketBaseSocketGetIpv6OnlyResultTag)
}

func (_m *BaseNetworkSocketBaseSocketGetIpv6OnlyResult) SetResponse(response BaseNetworkSocketBaseSocketGetIpv6OnlyResponse) {
	_m.reset()
	_m.I_baseNetworkSocketBaseSocketGetIpv6OnlyResultTag = BaseNetworkSocketBaseSocketGetIpv6OnlyResultResponse
	_m.Response = response
}

func BaseNetworkSocketBaseSocketGetIpv6OnlyResultWithResponse(response BaseNetworkSocketBaseSocketGetIpv6OnlyResponse) BaseNetworkSocketBaseSocketGetIpv6OnlyResult {
	var _u BaseNetworkSocketBaseSocketGetIpv6OnlyResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseNetworkSocketBaseSocketGetIpv6OnlyResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseNetworkSocketBaseSocketGetIpv6OnlyResultTag = BaseNetworkSocketBaseSocketGetIpv6OnlyResultErr
	_m.Err = err
}

func BaseNetworkSocketBaseSocketGetIpv6OnlyResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketBaseSocketGetIpv6OnlyResult {
	var _u BaseNetworkSocketBaseSocketGetIpv6OnlyResult
	_u.SetErr(err)
	return _u
}

type I_baseNetworkSocketBaseSocketSetIpv6ReceiveTrafficClassResultTag uint64

const (
	BaseNetworkSocketBaseSocketSetIpv6ReceiveTrafficClassResultResponse = 1 // 0x00000001
	BaseNetworkSocketBaseSocketSetIpv6ReceiveTrafficClassResultErr      = 2 // 0x00000002
)

type BaseNetworkSocketBaseSocketSetIpv6ReceiveTrafficClassResult struct {
	I_baseNetworkSocketBaseSocketSetIpv6ReceiveTrafficClassResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                                         BaseNetworkSocketBaseSocketSetIpv6ReceiveTrafficClassResponse `fidl_ordinal:"1"`
	Err                                                              fuchsiaposix.Errno                                            `fidl_ordinal:"2"`
}

func (_m *BaseNetworkSocketBaseSocketSetIpv6ReceiveTrafficClassResult) reset() {
	switch _m.I_baseNetworkSocketBaseSocketSetIpv6ReceiveTrafficClassResultTag {
	case 1:
		var _zeroed BaseNetworkSocketBaseSocketSetIpv6ReceiveTrafficClassResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseNetworkSocketBaseSocketSetIpv6ReceiveTrafficClassResult) Which() I_baseNetworkSocketBaseSocketSetIpv6ReceiveTrafficClassResultTag {
	return _m.I_baseNetworkSocketBaseSocketSetIpv6ReceiveTrafficClassResultTag
}

func (_m *BaseNetworkSocketBaseSocketSetIpv6ReceiveTrafficClassResult) Ordinal() uint64 {
	return uint64(_m.I_baseNetworkSocketBaseSocketSetIpv6ReceiveTrafficClassResultTag)
}

func (_m *BaseNetworkSocketBaseSocketSetIpv6ReceiveTrafficClassResult) SetResponse(response BaseNetworkSocketBaseSocketSetIpv6ReceiveTrafficClassResponse) {
	_m.reset()
	_m.I_baseNetworkSocketBaseSocketSetIpv6ReceiveTrafficClassResultTag = BaseNetworkSocketBaseSocketSetIpv6ReceiveTrafficClassResultResponse
	_m.Response = response
}

func BaseNetworkSocketBaseSocketSetIpv6ReceiveTrafficClassResultWithResponse(response BaseNetworkSocketBaseSocketSetIpv6ReceiveTrafficClassResponse) BaseNetworkSocketBaseSocketSetIpv6ReceiveTrafficClassResult {
	var _u BaseNetworkSocketBaseSocketSetIpv6ReceiveTrafficClassResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseNetworkSocketBaseSocketSetIpv6ReceiveTrafficClassResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseNetworkSocketBaseSocketSetIpv6ReceiveTrafficClassResultTag = BaseNetworkSocketBaseSocketSetIpv6ReceiveTrafficClassResultErr
	_m.Err = err
}

func BaseNetworkSocketBaseSocketSetIpv6ReceiveTrafficClassResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketBaseSocketSetIpv6ReceiveTrafficClassResult {
	var _u BaseNetworkSocketBaseSocketSetIpv6ReceiveTrafficClassResult
	_u.SetErr(err)
	return _u
}

type I_baseNetworkSocketBaseSocketGetIpv6ReceiveTrafficClassResultTag uint64

const (
	BaseNetworkSocketBaseSocketGetIpv6ReceiveTrafficClassResultResponse = 1 // 0x00000001
	BaseNetworkSocketBaseSocketGetIpv6ReceiveTrafficClassResultErr      = 2 // 0x00000002
)

type BaseNetworkSocketBaseSocketGetIpv6ReceiveTrafficClassResult struct {
	I_baseNetworkSocketBaseSocketGetIpv6ReceiveTrafficClassResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                                         BaseNetworkSocketBaseSocketGetIpv6ReceiveTrafficClassResponse `fidl_ordinal:"1"`
	Err                                                              fuchsiaposix.Errno                                            `fidl_ordinal:"2"`
}

func (_m *BaseNetworkSocketBaseSocketGetIpv6ReceiveTrafficClassResult) reset() {
	switch _m.I_baseNetworkSocketBaseSocketGetIpv6ReceiveTrafficClassResultTag {
	case 1:
		var _zeroed BaseNetworkSocketBaseSocketGetIpv6ReceiveTrafficClassResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseNetworkSocketBaseSocketGetIpv6ReceiveTrafficClassResult) Which() I_baseNetworkSocketBaseSocketGetIpv6ReceiveTrafficClassResultTag {
	return _m.I_baseNetworkSocketBaseSocketGetIpv6ReceiveTrafficClassResultTag
}

func (_m *BaseNetworkSocketBaseSocketGetIpv6ReceiveTrafficClassResult) Ordinal() uint64 {
	return uint64(_m.I_baseNetworkSocketBaseSocketGetIpv6ReceiveTrafficClassResultTag)
}

func (_m *BaseNetworkSocketBaseSocketGetIpv6ReceiveTrafficClassResult) SetResponse(response BaseNetworkSocketBaseSocketGetIpv6ReceiveTrafficClassResponse) {
	_m.reset()
	_m.I_baseNetworkSocketBaseSocketGetIpv6ReceiveTrafficClassResultTag = BaseNetworkSocketBaseSocketGetIpv6ReceiveTrafficClassResultResponse
	_m.Response = response
}

func BaseNetworkSocketBaseSocketGetIpv6ReceiveTrafficClassResultWithResponse(response BaseNetworkSocketBaseSocketGetIpv6ReceiveTrafficClassResponse) BaseNetworkSocketBaseSocketGetIpv6ReceiveTrafficClassResult {
	var _u BaseNetworkSocketBaseSocketGetIpv6ReceiveTrafficClassResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseNetworkSocketBaseSocketGetIpv6ReceiveTrafficClassResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseNetworkSocketBaseSocketGetIpv6ReceiveTrafficClassResultTag = BaseNetworkSocketBaseSocketGetIpv6ReceiveTrafficClassResultErr
	_m.Err = err
}

func BaseNetworkSocketBaseSocketGetIpv6ReceiveTrafficClassResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketBaseSocketGetIpv6ReceiveTrafficClassResult {
	var _u BaseNetworkSocketBaseSocketGetIpv6ReceiveTrafficClassResult
	_u.SetErr(err)
	return _u
}

type I_baseNetworkSocketBaseSocketSetIpv6TrafficClassResultTag uint64

const (
	BaseNetworkSocketBaseSocketSetIpv6TrafficClassResultResponse = 1 // 0x00000001
	BaseNetworkSocketBaseSocketSetIpv6TrafficClassResultErr      = 2 // 0x00000002
)

type BaseNetworkSocketBaseSocketSetIpv6TrafficClassResult struct {
	I_baseNetworkSocketBaseSocketSetIpv6TrafficClassResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                                  BaseNetworkSocketBaseSocketSetIpv6TrafficClassResponse `fidl_ordinal:"1"`
	Err                                                       fuchsiaposix.Errno                                     `fidl_ordinal:"2"`
}

func (_m *BaseNetworkSocketBaseSocketSetIpv6TrafficClassResult) reset() {
	switch _m.I_baseNetworkSocketBaseSocketSetIpv6TrafficClassResultTag {
	case 1:
		var _zeroed BaseNetworkSocketBaseSocketSetIpv6TrafficClassResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseNetworkSocketBaseSocketSetIpv6TrafficClassResult) Which() I_baseNetworkSocketBaseSocketSetIpv6TrafficClassResultTag {
	return _m.I_baseNetworkSocketBaseSocketSetIpv6TrafficClassResultTag
}

func (_m *BaseNetworkSocketBaseSocketSetIpv6TrafficClassResult) Ordinal() uint64 {
	return uint64(_m.I_baseNetworkSocketBaseSocketSetIpv6TrafficClassResultTag)
}

func (_m *BaseNetworkSocketBaseSocketSetIpv6TrafficClassResult) SetResponse(response BaseNetworkSocketBaseSocketSetIpv6TrafficClassResponse) {
	_m.reset()
	_m.I_baseNetworkSocketBaseSocketSetIpv6TrafficClassResultTag = BaseNetworkSocketBaseSocketSetIpv6TrafficClassResultResponse
	_m.Response = response
}

func BaseNetworkSocketBaseSocketSetIpv6TrafficClassResultWithResponse(response BaseNetworkSocketBaseSocketSetIpv6TrafficClassResponse) BaseNetworkSocketBaseSocketSetIpv6TrafficClassResult {
	var _u BaseNetworkSocketBaseSocketSetIpv6TrafficClassResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseNetworkSocketBaseSocketSetIpv6TrafficClassResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseNetworkSocketBaseSocketSetIpv6TrafficClassResultTag = BaseNetworkSocketBaseSocketSetIpv6TrafficClassResultErr
	_m.Err = err
}

func BaseNetworkSocketBaseSocketSetIpv6TrafficClassResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketBaseSocketSetIpv6TrafficClassResult {
	var _u BaseNetworkSocketBaseSocketSetIpv6TrafficClassResult
	_u.SetErr(err)
	return _u
}

type I_baseNetworkSocketBaseSocketGetIpv6TrafficClassResultTag uint64

const (
	BaseNetworkSocketBaseSocketGetIpv6TrafficClassResultResponse = 1 // 0x00000001
	BaseNetworkSocketBaseSocketGetIpv6TrafficClassResultErr      = 2 // 0x00000002
)

type BaseNetworkSocketBaseSocketGetIpv6TrafficClassResult struct {
	I_baseNetworkSocketBaseSocketGetIpv6TrafficClassResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                                  BaseNetworkSocketBaseSocketGetIpv6TrafficClassResponse `fidl_ordinal:"1"`
	Err                                                       fuchsiaposix.Errno                                     `fidl_ordinal:"2"`
}

func (_m *BaseNetworkSocketBaseSocketGetIpv6TrafficClassResult) reset() {
	switch _m.I_baseNetworkSocketBaseSocketGetIpv6TrafficClassResultTag {
	case 1:
		var _zeroed BaseNetworkSocketBaseSocketGetIpv6TrafficClassResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed fuchsiaposix.Errno
		_m.Err = _zeroed
	}
}

func (_m *BaseNetworkSocketBaseSocketGetIpv6TrafficClassResult) Which() I_baseNetworkSocketBaseSocketGetIpv6TrafficClassResultTag {
	return _m.I_baseNetworkSocketBaseSocketGetIpv6TrafficClassResultTag
}

func (_m *BaseNetworkSocketBaseSocketGetIpv6TrafficClassResult) Ordinal() uint64 {
	return uint64(_m.I_baseNetworkSocketBaseSocketGetIpv6TrafficClassResultTag)
}

func (_m *BaseNetworkSocketBaseSocketGetIpv6TrafficClassResult) SetResponse(response BaseNetworkSocketBaseSocketGetIpv6TrafficClassResponse) {
	_m.reset()
	_m.I_baseNetworkSocketBaseSocketGetIpv6TrafficClassResultTag = BaseNetworkSocketBaseSocketGetIpv6TrafficClassResultResponse
	_m.Response = response
}

func BaseNetworkSocketBaseSocketGetIpv6TrafficClassResultWithResponse(response BaseNetworkSocketBaseSocketGetIpv6TrafficClassResponse) BaseNetworkSocketBaseSocketGetIpv6TrafficClassResult {
	var _u BaseNetworkSocketBaseSocketGetIpv6TrafficClassResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseNetworkSocketBaseSocketGetIpv6TrafficClassResult) SetErr(err fuchsiaposix.Errno) {
	_m.reset()
	_m.I_baseNetworkSocketBaseSocketGetIpv6TrafficClassResultTag = BaseNetworkSocketBaseSocketGetIpv6TrafficClassResultErr
	_m.Err = err
}

func BaseNetworkSocketBaseSocketGetIpv6TrafficClassResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketBaseSocketGetIpv6TrafficClassResult {
	var _u BaseNetworkSocketBaseSocketGetIpv6TrafficClassResult
	_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
	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
)

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_
}

// 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_
}

// A socket.
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)
	// 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)
}

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 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_
	}
	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 (
	BaseNetworkSocketCloneOrdinal                                uint64 = 0x5a61678f293ce16f
	BaseNetworkSocketCloseOrdinal                                uint64 = 0x5309c5bd1c33dc44
	BaseNetworkSocketDescribeOrdinal                             uint64 = 0xffcec215078dea0
	BaseNetworkSocketOnOpenOrdinal                               uint64 = 0x7fc7bbb1dbfd1972
	BaseNetworkSocketSyncOrdinal                                 uint64 = 0x189d88326c18b519
	BaseNetworkSocketGetAttrOrdinal                              uint64 = 0x78985e216314dafd
	BaseNetworkSocketSetAttrOrdinal                              uint64 = 0x4186c0f40d938f46
	BaseNetworkSocketNodeGetFlagsOrdinal                         uint64 = 0x5b88fffb8eda3aa1
	BaseNetworkSocketNodeSetFlagsOrdinal                         uint64 = 0x5295b76c71fde733
	BaseNetworkSocketSetReuseAddressOrdinal                      uint64 = 0x1fd74ee8b9a4a876
	BaseNetworkSocketGetReuseAddressOrdinal                      uint64 = 0x67b7206b8d1bc0a5
	BaseNetworkSocketGetErrorOrdinal                             uint64 = 0x5aad39b33e5f6ebb
	BaseNetworkSocketSetBroadcastOrdinal                         uint64 = 0x6023e081ce3cd947
	BaseNetworkSocketGetBroadcastOrdinal                         uint64 = 0x68796fc556f9780d
	BaseNetworkSocketSetSendBufferOrdinal                        uint64 = 0x756eac32d73a7a70
	BaseNetworkSocketGetSendBufferOrdinal                        uint64 = 0x78a52fd9c7b2410b
	BaseNetworkSocketSetReceiveBufferOrdinal                     uint64 = 0x6b0cf2f1919c7001
	BaseNetworkSocketGetReceiveBufferOrdinal                     uint64 = 0x14c1a4b64f709e5c
	BaseNetworkSocketSetKeepAliveOrdinal                         uint64 = 0x572df8f0b920d2c7
	BaseNetworkSocketGetKeepAliveOrdinal                         uint64 = 0x2dd29d3215f2c9d2
	BaseNetworkSocketSetOutOfBandInlineOrdinal                   uint64 = 0x3ecb49968bee439
	BaseNetworkSocketGetOutOfBandInlineOrdinal                   uint64 = 0x348c1ab3aeca1745
	BaseNetworkSocketSetNoCheckOrdinal                           uint64 = 0x6bbf00c53a4c78c2
	BaseNetworkSocketGetNoCheckOrdinal                           uint64 = 0x2cd4249286417694
	BaseNetworkSocketSetLingerOrdinal                            uint64 = 0x45386351246e998e
	BaseNetworkSocketGetLingerOrdinal                            uint64 = 0x48eb20fc5ccb0e45
	BaseNetworkSocketSetReusePortOrdinal                         uint64 = 0x24dd3e5cb36d9ccb
	BaseNetworkSocketGetReusePortOrdinal                         uint64 = 0x7a112c1ab54ff828
	BaseNetworkSocketGetAcceptConnOrdinal                        uint64 = 0x67ce6db6c2ec8966
	BaseNetworkSocketSetBindToDeviceOrdinal                      uint64 = 0x2118b483f28aafc4
	BaseNetworkSocketGetBindToDeviceOrdinal                      uint64 = 0x1ab1fbf0ef7906c8
	BaseNetworkSocketSetTimestampOrdinal                         uint64 = 0x285d6516c263d839
	BaseNetworkSocketGetTimestampOrdinal                         uint64 = 0x49f2fffbbcc2bd27
	BaseNetworkSocketBindOrdinal                                 uint64 = 0x4bc6400ae92125d
	BaseNetworkSocketConnectOrdinal                              uint64 = 0x5f05f19bfdd38871
	BaseNetworkSocketDisconnectOrdinal                           uint64 = 0x74e63b91f7b29b2
	BaseNetworkSocketGetSockNameOrdinal                          uint64 = 0x475f23f84a1a4f85
	BaseNetworkSocketGetPeerNameOrdinal                          uint64 = 0x1ffecf4bd5b6432e
	BaseNetworkSocketShutdownOrdinal                             uint64 = 0x247f38b6db68c336
	BaseNetworkSocketShutdown2Ordinal                            uint64 = 0x421055d9d50e4f48
	BaseNetworkSocketSetIpTypeOfServiceOrdinal                   uint64 = 0x995c600475b6d46
	BaseNetworkSocketGetIpTypeOfServiceOrdinal                   uint64 = 0x3814a04259f75fcb
	BaseNetworkSocketSetIpTtlOrdinal                             uint64 = 0x29e2424b433ae1ef
	BaseNetworkSocketGetIpTtlOrdinal                             uint64 = 0x47e47fa1f24da471
	BaseNetworkSocketSetIpPacketInfoOrdinal                      uint64 = 0x392d16bee20c0e16
	BaseNetworkSocketGetIpPacketInfoOrdinal                      uint64 = 0x54b505f242280740
	BaseNetworkSocketSetIpReceiveTypeOfServiceOrdinal            uint64 = 0x6c4f6714995f84ef
	BaseNetworkSocketGetIpReceiveTypeOfServiceOrdinal            uint64 = 0x4158ba7dc2795960
	BaseNetworkSocketSetIpMulticastInterfaceOrdinal              uint64 = 0x752fbfa9b12befe
	BaseNetworkSocketGetIpMulticastInterfaceOrdinal              uint64 = 0x320bd14c4df046c4
	BaseNetworkSocketSetIpMulticastTtlOrdinal                    uint64 = 0x63134d53772916a1
	BaseNetworkSocketGetIpMulticastTtlOrdinal                    uint64 = 0x4665cd378f39e1a
	BaseNetworkSocketSetIpMulticastLoopbackOrdinal               uint64 = 0x20c55c11f00943ea
	BaseNetworkSocketGetIpMulticastLoopbackOrdinal               uint64 = 0x3b6b26ff558298f2
	BaseNetworkSocketAddIpMembershipOrdinal                      uint64 = 0x76bc7df115a3b4d0
	BaseNetworkSocketDropIpMembershipOrdinal                     uint64 = 0x2888f3099188d03
	BaseNetworkSocketAddIpv6MembershipOrdinal                    uint64 = 0x7c94727acb4ea4b3
	BaseNetworkSocketDropIpv6MembershipOrdinal                   uint64 = 0x42104c70ccaba304
	BaseNetworkSocketSetIpv6MulticastInterfaceOrdinal            uint64 = 0x135f76db3774ab3b
	BaseNetworkSocketGetIpv6MulticastInterfaceOrdinal            uint64 = 0x1f26fcdd348f1882
	BaseNetworkSocketSetIpv6MulticastHopsOrdinal                 uint64 = 0x25b9cd4d181f82c1
	BaseNetworkSocketGetIpv6MulticastHopsOrdinal                 uint64 = 0x52916948a365012a
	BaseNetworkSocketSetIpv6MulticastLoopbackOrdinal             uint64 = 0x55701c409ff41b40
	BaseNetworkSocketGetIpv6MulticastLoopbackOrdinal             uint64 = 0x4415b701fde319c3
	BaseNetworkSocketSetIpv6OnlyOrdinal                          uint64 = 0x4873f1364758cbba
	BaseNetworkSocketGetIpv6OnlyOrdinal                          uint64 = 0x4aa3340a1a26b89c
	BaseNetworkSocketSetIpv6ReceiveTrafficClassOrdinal           uint64 = 0x58f07c8788d099a0
	BaseNetworkSocketGetIpv6ReceiveTrafficClassOrdinal           uint64 = 0x2e334df1da553ffa
	BaseNetworkSocketSetIpv6TrafficClassOrdinal                  uint64 = 0x6af077800c5a0b4f
	BaseNetworkSocketGetIpv6TrafficClassOrdinal                  uint64 = 0x6baf6eed8fc2f04
	BaseNetworkSocketBaseSocketBindOrdinal                       uint64 = 0xf8457e6b05e15bc
	BaseNetworkSocketBaseSocketConnectOrdinal                    uint64 = 0x17abeee0b9843bb1
	BaseNetworkSocketBaseSocketDisconnectOrdinal                 uint64 = 0x20eaedba2e0f70a4
	BaseNetworkSocketBaseSocketGetSockNameOrdinal                uint64 = 0x41a618ef19a91f9d
	BaseNetworkSocketBaseSocketGetPeerNameOrdinal                uint64 = 0x4009d08a4beb5e95
	BaseNetworkSocketBaseSocketShutdownOrdinal                   uint64 = 0x382080a1d15b2111
	BaseNetworkSocketBaseSocketShutdown2Ordinal                  uint64 = 0x57d3458f9754763b
	BaseNetworkSocketBaseSocketSetIpTypeOfServiceOrdinal         uint64 = 0x559849ba9574834a
	BaseNetworkSocketBaseSocketGetIpTypeOfServiceOrdinal         uint64 = 0x2740d6bfa379deb1
	BaseNetworkSocketBaseSocketSetIpTtlOrdinal                   uint64 = 0x67395f7176d7918e
	BaseNetworkSocketBaseSocketGetIpTtlOrdinal                   uint64 = 0x789d5ddfe26b97ac
	BaseNetworkSocketBaseSocketSetIpPacketInfoOrdinal            uint64 = 0x3e02030a2fd13c03
	BaseNetworkSocketBaseSocketGetIpPacketInfoOrdinal            uint64 = 0x176f008d5a0dab15
	BaseNetworkSocketBaseSocketSetIpReceiveTypeOfServiceOrdinal  uint64 = 0x17148064e563dde5
	BaseNetworkSocketBaseSocketGetIpReceiveTypeOfServiceOrdinal  uint64 = 0x26cc26653b0fa460
	BaseNetworkSocketBaseSocketSetIpMulticastInterfaceOrdinal    uint64 = 0x6566fdb7061bbcf8
	BaseNetworkSocketBaseSocketGetIpMulticastInterfaceOrdinal    uint64 = 0x44415752b16ff024
	BaseNetworkSocketBaseSocketSetIpMulticastTtlOrdinal          uint64 = 0x7d1a477776ba00d3
	BaseNetworkSocketBaseSocketGetIpMulticastTtlOrdinal          uint64 = 0x17cbd4bd9246fc40
	BaseNetworkSocketBaseSocketSetIpMulticastLoopbackOrdinal     uint64 = 0x2a56b32f8f02369
	BaseNetworkSocketBaseSocketGetIpMulticastLoopbackOrdinal     uint64 = 0x27b16d7883c08ca8
	BaseNetworkSocketBaseSocketAddIpMembershipOrdinal            uint64 = 0x39a4eda6580147a0
	BaseNetworkSocketBaseSocketDropIpMembershipOrdinal           uint64 = 0x6d16e8fbaf496254
	BaseNetworkSocketBaseSocketAddIpv6MembershipOrdinal          uint64 = 0x231556bfce3194c1
	BaseNetworkSocketBaseSocketDropIpv6MembershipOrdinal         uint64 = 0x629c12db293444c0
	BaseNetworkSocketBaseSocketSetIpv6MulticastInterfaceOrdinal  uint64 = 0x5d2a568e67b54234
	BaseNetworkSocketBaseSocketGetIpv6MulticastInterfaceOrdinal  uint64 = 0x7b8f38fe354f32bc
	BaseNetworkSocketBaseSocketSetIpv6MulticastHopsOrdinal       uint64 = 0x2b2167d12c8a495d
	BaseNetworkSocketBaseSocketGetIpv6MulticastHopsOrdinal       uint64 = 0x51a3c8257b1a2745
	BaseNetworkSocketBaseSocketSetIpv6MulticastLoopbackOrdinal   uint64 = 0x97706949c4163b7
	BaseNetworkSocketBaseSocketGetIpv6MulticastLoopbackOrdinal   uint64 = 0x78d6544e48794935
	BaseNetworkSocketBaseSocketSetIpv6OnlyOrdinal                uint64 = 0x1d87ce5c02d8bcb2
	BaseNetworkSocketBaseSocketGetIpv6OnlyOrdinal                uint64 = 0x25d6755dbe2e9c7e
	BaseNetworkSocketBaseSocketSetIpv6ReceiveTrafficClassOrdinal uint64 = 0x53b93b71c9431fe4
	BaseNetworkSocketBaseSocketGetIpv6ReceiveTrafficClassOrdinal uint64 = 0x1c8433af11cd4596
	BaseNetworkSocketBaseSocketSetIpv6TrafficClassOrdinal        uint64 = 0x32da0ca485fad782
	BaseNetworkSocketBaseSocketGetIpv6TrafficClassOrdinal        uint64 = 0x6ca5b9166c8d3cba
)

type BaseNetworkSocketWithCtxInterface _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 *BaseNetworkSocketWithCtxInterface) Clone(ctx_ _bindings.Context, flags uint32, object fuchsiaio.NodeWithCtxInterfaceRequest) error {
	req_ := &baseNetworkSocketWithCtxCloneRequest{
		Flags:  flags,
		Object: object,
	}
	err_ := ((*_bindings.ChannelProxy)(p)).Send(BaseNetworkSocketCloneOrdinal, req_)
	return err_
}

// Terminates connection with object.
//
// This method does not require any rights.
func (p *BaseNetworkSocketWithCtxInterface) Close(ctx_ _bindings.Context) (int32, error) {
	var req_ _bindings.Message
	resp_ := &baseNetworkSocketWithCtxCloseResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketCloseOrdinal, 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 *BaseNetworkSocketWithCtxInterface) Describe(ctx_ _bindings.Context) (fuchsiaio.NodeInfo, error) {
	var req_ _bindings.Message
	resp_ := &baseNetworkSocketWithCtxDescribeResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketDescribeOrdinal, 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 *BaseNetworkSocketWithCtxInterface) ExpectOnOpen(ctx_ _bindings.Context) (int32, *fuchsiaio.NodeInfo, error) {
	resp_ := &baseNetworkSocketWithCtxOnOpenResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Recv(BaseNetworkSocketOnOpenOrdinal, 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 *BaseNetworkSocketWithCtxInterface) Sync(ctx_ _bindings.Context) (int32, error) {
	var req_ _bindings.Message
	resp_ := &baseNetworkSocketWithCtxSyncResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketSyncOrdinal, req_, resp_)
	return resp_.S, err_
}

// Acquires information about the node.
//
// This method does not require any rights.
func (p *BaseNetworkSocketWithCtxInterface) GetAttr(ctx_ _bindings.Context) (int32, fuchsiaio.NodeAttributes, error) {
	var req_ _bindings.Message
	resp_ := &baseNetworkSocketWithCtxGetAttrResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketGetAttrOrdinal, 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 *BaseNetworkSocketWithCtxInterface) SetAttr(ctx_ _bindings.Context, flags uint32, attributes fuchsiaio.NodeAttributes) (int32, error) {
	req_ := &baseNetworkSocketWithCtxSetAttrRequest{
		Flags:      flags,
		Attributes: attributes,
	}
	resp_ := &baseNetworkSocketWithCtxSetAttrResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketSetAttrOrdinal, 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 *BaseNetworkSocketWithCtxInterface) NodeGetFlags(ctx_ _bindings.Context) (int32, uint32, error) {
	var req_ _bindings.Message
	resp_ := &baseNetworkSocketWithCtxNodeGetFlagsResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketNodeGetFlagsOrdinal, 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 *BaseNetworkSocketWithCtxInterface) NodeSetFlags(ctx_ _bindings.Context, flags uint32) (int32, error) {
	req_ := &baseNetworkSocketWithCtxNodeSetFlagsRequest{
		Flags: flags,
	}
	resp_ := &baseNetworkSocketWithCtxNodeSetFlagsResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketNodeSetFlagsOrdinal, req_, resp_)
	return resp_.S, err_
}

// Set `SOL_SOCKET` -> `SO_REUSEADDR`.
func (p *BaseNetworkSocketWithCtxInterface) SetReuseAddress(ctx_ _bindings.Context, value bool) (BaseSocketSetReuseAddressResult, error) {
	req_ := &baseNetworkSocketWithCtxSetReuseAddressRequest{
		Value: value,
	}
	resp_ := &baseNetworkSocketWithCtxSetReuseAddressResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketSetReuseAddressOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_SOCKET` -> `SO_REUSEADDR`.
func (p *BaseNetworkSocketWithCtxInterface) GetReuseAddress(ctx_ _bindings.Context) (BaseSocketGetReuseAddressResult, error) {
	var req_ _bindings.Message
	resp_ := &baseNetworkSocketWithCtxGetReuseAddressResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketGetReuseAddressOrdinal, 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 *BaseNetworkSocketWithCtxInterface) GetError(ctx_ _bindings.Context) (BaseSocketGetErrorResult, error) {
	var req_ _bindings.Message
	resp_ := &baseNetworkSocketWithCtxGetErrorResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketGetErrorOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_SOCKET` -> `SO_BROADCAST`.
func (p *BaseNetworkSocketWithCtxInterface) SetBroadcast(ctx_ _bindings.Context, value bool) (BaseSocketSetBroadcastResult, error) {
	req_ := &baseNetworkSocketWithCtxSetBroadcastRequest{
		Value: value,
	}
	resp_ := &baseNetworkSocketWithCtxSetBroadcastResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketSetBroadcastOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_SOCKET` -> `SO_BROADCAST`.
func (p *BaseNetworkSocketWithCtxInterface) GetBroadcast(ctx_ _bindings.Context) (BaseSocketGetBroadcastResult, error) {
	var req_ _bindings.Message
	resp_ := &baseNetworkSocketWithCtxGetBroadcastResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketGetBroadcastOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_SOCKET` -> `SO_SNDBUF`.
func (p *BaseNetworkSocketWithCtxInterface) SetSendBuffer(ctx_ _bindings.Context, valueBytes uint64) (BaseSocketSetSendBufferResult, error) {
	req_ := &baseNetworkSocketWithCtxSetSendBufferRequest{
		ValueBytes: valueBytes,
	}
	resp_ := &baseNetworkSocketWithCtxSetSendBufferResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketSetSendBufferOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_SOCKET` -> `SO_SNDBUF`.
func (p *BaseNetworkSocketWithCtxInterface) GetSendBuffer(ctx_ _bindings.Context) (BaseSocketGetSendBufferResult, error) {
	var req_ _bindings.Message
	resp_ := &baseNetworkSocketWithCtxGetSendBufferResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketGetSendBufferOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_SOCKET` -> `SO_RCVBUF`.
func (p *BaseNetworkSocketWithCtxInterface) SetReceiveBuffer(ctx_ _bindings.Context, valueBytes uint64) (BaseSocketSetReceiveBufferResult, error) {
	req_ := &baseNetworkSocketWithCtxSetReceiveBufferRequest{
		ValueBytes: valueBytes,
	}
	resp_ := &baseNetworkSocketWithCtxSetReceiveBufferResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketSetReceiveBufferOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_SOCKET` -> `SO_RCVBUF`.
func (p *BaseNetworkSocketWithCtxInterface) GetReceiveBuffer(ctx_ _bindings.Context) (BaseSocketGetReceiveBufferResult, error) {
	var req_ _bindings.Message
	resp_ := &baseNetworkSocketWithCtxGetReceiveBufferResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketGetReceiveBufferOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_SOCKET` -> `SO_KEEPALIVE`.
func (p *BaseNetworkSocketWithCtxInterface) SetKeepAlive(ctx_ _bindings.Context, value bool) (BaseSocketSetKeepAliveResult, error) {
	req_ := &baseNetworkSocketWithCtxSetKeepAliveRequest{
		Value: value,
	}
	resp_ := &baseNetworkSocketWithCtxSetKeepAliveResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketSetKeepAliveOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_SOCKET` -> `SO_KEEPALIVE`.
func (p *BaseNetworkSocketWithCtxInterface) GetKeepAlive(ctx_ _bindings.Context) (BaseSocketGetKeepAliveResult, error) {
	var req_ _bindings.Message
	resp_ := &baseNetworkSocketWithCtxGetKeepAliveResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketGetKeepAliveOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_SOCKET` -> `SO_OOBINLINE`.
func (p *BaseNetworkSocketWithCtxInterface) SetOutOfBandInline(ctx_ _bindings.Context, value bool) (BaseSocketSetOutOfBandInlineResult, error) {
	req_ := &baseNetworkSocketWithCtxSetOutOfBandInlineRequest{
		Value: value,
	}
	resp_ := &baseNetworkSocketWithCtxSetOutOfBandInlineResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketSetOutOfBandInlineOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_SOCKET` -> `SO_OOBINLINE`.
func (p *BaseNetworkSocketWithCtxInterface) GetOutOfBandInline(ctx_ _bindings.Context) (BaseSocketGetOutOfBandInlineResult, error) {
	var req_ _bindings.Message
	resp_ := &baseNetworkSocketWithCtxGetOutOfBandInlineResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketGetOutOfBandInlineOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_SOCKET` -> `SO_NO_CHECK`.
func (p *BaseNetworkSocketWithCtxInterface) SetNoCheck(ctx_ _bindings.Context, value bool) (BaseSocketSetNoCheckResult, error) {
	req_ := &baseNetworkSocketWithCtxSetNoCheckRequest{
		Value: value,
	}
	resp_ := &baseNetworkSocketWithCtxSetNoCheckResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketSetNoCheckOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_SOCKET` -> `SO_NO_CHECK`.
func (p *BaseNetworkSocketWithCtxInterface) GetNoCheck(ctx_ _bindings.Context) (BaseSocketGetNoCheckResult, error) {
	var req_ _bindings.Message
	resp_ := &baseNetworkSocketWithCtxGetNoCheckResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketGetNoCheckOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_SOCKET` -> `SO_LINGER`.
func (p *BaseNetworkSocketWithCtxInterface) SetLinger(ctx_ _bindings.Context, linger bool, lengthSecs uint32) (BaseSocketSetLingerResult, error) {
	req_ := &baseNetworkSocketWithCtxSetLingerRequest{
		Linger:     linger,
		LengthSecs: lengthSecs,
	}
	resp_ := &baseNetworkSocketWithCtxSetLingerResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketSetLingerOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_SOCKET` -> `SO_LINGER`.
func (p *BaseNetworkSocketWithCtxInterface) GetLinger(ctx_ _bindings.Context) (BaseSocketGetLingerResult, error) {
	var req_ _bindings.Message
	resp_ := &baseNetworkSocketWithCtxGetLingerResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketGetLingerOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_SOCKET` -> `SO_REUSEPORT`.
func (p *BaseNetworkSocketWithCtxInterface) SetReusePort(ctx_ _bindings.Context, value bool) (BaseSocketSetReusePortResult, error) {
	req_ := &baseNetworkSocketWithCtxSetReusePortRequest{
		Value: value,
	}
	resp_ := &baseNetworkSocketWithCtxSetReusePortResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketSetReusePortOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_SOCKET` -> `SO_REUSEPORT`.
func (p *BaseNetworkSocketWithCtxInterface) GetReusePort(ctx_ _bindings.Context) (BaseSocketGetReusePortResult, error) {
	var req_ _bindings.Message
	resp_ := &baseNetworkSocketWithCtxGetReusePortResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketGetReusePortOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_SOCKET` -> `SO_ACCEPTCONN`.
func (p *BaseNetworkSocketWithCtxInterface) GetAcceptConn(ctx_ _bindings.Context) (BaseSocketGetAcceptConnResult, error) {
	var req_ _bindings.Message
	resp_ := &baseNetworkSocketWithCtxGetAcceptConnResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketGetAcceptConnOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_SOCKET` -> `SO_BINDTODEVICE`.
func (p *BaseNetworkSocketWithCtxInterface) SetBindToDevice(ctx_ _bindings.Context, value string) (BaseSocketSetBindToDeviceResult, error) {
	req_ := &baseNetworkSocketWithCtxSetBindToDeviceRequest{
		Value: value,
	}
	resp_ := &baseNetworkSocketWithCtxSetBindToDeviceResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketSetBindToDeviceOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_SOCKET` -> `SO_BINDTODEVICE`.
func (p *BaseNetworkSocketWithCtxInterface) GetBindToDevice(ctx_ _bindings.Context) (BaseSocketGetBindToDeviceResult, error) {
	var req_ _bindings.Message
	resp_ := &baseNetworkSocketWithCtxGetBindToDeviceResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketGetBindToDeviceOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_SOCKET` -> `SO_TIMESTAMP`.
func (p *BaseNetworkSocketWithCtxInterface) SetTimestamp(ctx_ _bindings.Context, value bool) (BaseSocketSetTimestampResult, error) {
	req_ := &baseNetworkSocketWithCtxSetTimestampRequest{
		Value: value,
	}
	resp_ := &baseNetworkSocketWithCtxSetTimestampResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketSetTimestampOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_SOCKET` -> `SO_TIMESTAMP`.
func (p *BaseNetworkSocketWithCtxInterface) GetTimestamp(ctx_ _bindings.Context) (BaseSocketGetTimestampResult, error) {
	var req_ _bindings.Message
	resp_ := &baseNetworkSocketWithCtxGetTimestampResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketGetTimestampOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Sets the local address used for the socket.
func (p *BaseNetworkSocketWithCtxInterface) Bind(ctx_ _bindings.Context, addr fuchsianet.SocketAddress) (BaseNetworkSocketBindResult, error) {
	req_ := &baseNetworkSocketWithCtxBindRequest{
		Addr: addr,
	}
	resp_ := &baseNetworkSocketWithCtxBindResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketBindOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Initiates a connection to a remote address.
func (p *BaseNetworkSocketWithCtxInterface) Connect(ctx_ _bindings.Context, addr fuchsianet.SocketAddress) (BaseNetworkSocketConnectResult, error) {
	req_ := &baseNetworkSocketWithCtxConnectRequest{
		Addr: addr,
	}
	resp_ := &baseNetworkSocketWithCtxConnectResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketConnectOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Clears connection information from this socket.
func (p *BaseNetworkSocketWithCtxInterface) Disconnect(ctx_ _bindings.Context) (BaseNetworkSocketDisconnectResult, error) {
	var req_ _bindings.Message
	resp_ := &baseNetworkSocketWithCtxDisconnectResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketDisconnectOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Retrieves the local socket address.
func (p *BaseNetworkSocketWithCtxInterface) GetSockName(ctx_ _bindings.Context) (BaseNetworkSocketGetSockNameResult, error) {
	var req_ _bindings.Message
	resp_ := &baseNetworkSocketWithCtxGetSockNameResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketGetSockNameOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Retrieves the remote socket address.
func (p *BaseNetworkSocketWithCtxInterface) GetPeerName(ctx_ _bindings.Context) (BaseNetworkSocketGetPeerNameResult, error) {
	var req_ _bindings.Message
	resp_ := &baseNetworkSocketWithCtxGetPeerNameResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketGetPeerNameOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Shuts down part of the socket.
func (p *BaseNetworkSocketWithCtxInterface) Shutdown(ctx_ _bindings.Context, mode ShutdownMode) (BaseNetworkSocketShutdownResult, error) {
	req_ := &baseNetworkSocketWithCtxShutdownRequest{
		Mode: mode,
	}
	resp_ := &baseNetworkSocketWithCtxShutdownResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketShutdownOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *BaseNetworkSocketWithCtxInterface) Shutdown2(ctx_ _bindings.Context, mode ShutdownMode) (BaseNetworkSocketShutdown2Result, error) {
	req_ := &baseNetworkSocketWithCtxShutdown2Request{
		Mode: mode,
	}
	resp_ := &baseNetworkSocketWithCtxShutdown2Response{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketShutdown2Ordinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_IP` -> `IP_TOS`.
func (p *BaseNetworkSocketWithCtxInterface) SetIpTypeOfService(ctx_ _bindings.Context, value uint8) (BaseNetworkSocketSetIpTypeOfServiceResult, error) {
	req_ := &baseNetworkSocketWithCtxSetIpTypeOfServiceRequest{
		Value: value,
	}
	resp_ := &baseNetworkSocketWithCtxSetIpTypeOfServiceResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketSetIpTypeOfServiceOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_IP` -> `IP_TOS`.
func (p *BaseNetworkSocketWithCtxInterface) GetIpTypeOfService(ctx_ _bindings.Context) (BaseNetworkSocketGetIpTypeOfServiceResult, error) {
	var req_ _bindings.Message
	resp_ := &baseNetworkSocketWithCtxGetIpTypeOfServiceResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketGetIpTypeOfServiceOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_IP` -> `IP_TTL`.
func (p *BaseNetworkSocketWithCtxInterface) SetIpTtl(ctx_ _bindings.Context, value OptionalUint8) (BaseNetworkSocketSetIpTtlResult, error) {
	req_ := &baseNetworkSocketWithCtxSetIpTtlRequest{
		Value: value,
	}
	resp_ := &baseNetworkSocketWithCtxSetIpTtlResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketSetIpTtlOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_IP` -> `IP_TTL`.
func (p *BaseNetworkSocketWithCtxInterface) GetIpTtl(ctx_ _bindings.Context) (BaseNetworkSocketGetIpTtlResult, error) {
	var req_ _bindings.Message
	resp_ := &baseNetworkSocketWithCtxGetIpTtlResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketGetIpTtlOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_IP` -> `IP_PKTINFO`.
func (p *BaseNetworkSocketWithCtxInterface) SetIpPacketInfo(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpPacketInfoResult, error) {
	req_ := &baseNetworkSocketWithCtxSetIpPacketInfoRequest{
		Value: value,
	}
	resp_ := &baseNetworkSocketWithCtxSetIpPacketInfoResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketSetIpPacketInfoOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_IP` -> `IP_PKTINFO`.
func (p *BaseNetworkSocketWithCtxInterface) GetIpPacketInfo(ctx_ _bindings.Context) (BaseNetworkSocketGetIpPacketInfoResult, error) {
	var req_ _bindings.Message
	resp_ := &baseNetworkSocketWithCtxGetIpPacketInfoResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketGetIpPacketInfoOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_IP` -> `IP_RECVTOS`.
func (p *BaseNetworkSocketWithCtxInterface) SetIpReceiveTypeOfService(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpReceiveTypeOfServiceResult, error) {
	req_ := &baseNetworkSocketWithCtxSetIpReceiveTypeOfServiceRequest{
		Value: value,
	}
	resp_ := &baseNetworkSocketWithCtxSetIpReceiveTypeOfServiceResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketSetIpReceiveTypeOfServiceOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_IP` -> `IP_RECVTOS`.
func (p *BaseNetworkSocketWithCtxInterface) GetIpReceiveTypeOfService(ctx_ _bindings.Context) (BaseNetworkSocketGetIpReceiveTypeOfServiceResult, error) {
	var req_ _bindings.Message
	resp_ := &baseNetworkSocketWithCtxGetIpReceiveTypeOfServiceResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketGetIpReceiveTypeOfServiceOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_IP` -> `IP_MULTICAST_IF`.
func (p *BaseNetworkSocketWithCtxInterface) SetIpMulticastInterface(ctx_ _bindings.Context, iface uint64, address fuchsianet.Ipv4Address) (BaseNetworkSocketSetIpMulticastInterfaceResult, error) {
	req_ := &baseNetworkSocketWithCtxSetIpMulticastInterfaceRequest{
		Iface:   iface,
		Address: address,
	}
	resp_ := &baseNetworkSocketWithCtxSetIpMulticastInterfaceResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketSetIpMulticastInterfaceOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_IP` -> `IP_MULTICAST_IF`.
func (p *BaseNetworkSocketWithCtxInterface) GetIpMulticastInterface(ctx_ _bindings.Context) (BaseNetworkSocketGetIpMulticastInterfaceResult, error) {
	var req_ _bindings.Message
	resp_ := &baseNetworkSocketWithCtxGetIpMulticastInterfaceResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketGetIpMulticastInterfaceOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_IP` -> `IP_MULTICAST_TTL`.
func (p *BaseNetworkSocketWithCtxInterface) SetIpMulticastTtl(ctx_ _bindings.Context, value OptionalUint8) (BaseNetworkSocketSetIpMulticastTtlResult, error) {
	req_ := &baseNetworkSocketWithCtxSetIpMulticastTtlRequest{
		Value: value,
	}
	resp_ := &baseNetworkSocketWithCtxSetIpMulticastTtlResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketSetIpMulticastTtlOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_IP` -> `IP_MULTICAST_TTL`.
func (p *BaseNetworkSocketWithCtxInterface) GetIpMulticastTtl(ctx_ _bindings.Context) (BaseNetworkSocketGetIpMulticastTtlResult, error) {
	var req_ _bindings.Message
	resp_ := &baseNetworkSocketWithCtxGetIpMulticastTtlResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketGetIpMulticastTtlOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_IP` -> `IP_MULTICAST_LOOP`.
func (p *BaseNetworkSocketWithCtxInterface) SetIpMulticastLoopback(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpMulticastLoopbackResult, error) {
	req_ := &baseNetworkSocketWithCtxSetIpMulticastLoopbackRequest{
		Value: value,
	}
	resp_ := &baseNetworkSocketWithCtxSetIpMulticastLoopbackResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketSetIpMulticastLoopbackOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_IP` -> `IP_MULTICAST_LOOP`.
func (p *BaseNetworkSocketWithCtxInterface) GetIpMulticastLoopback(ctx_ _bindings.Context) (BaseNetworkSocketGetIpMulticastLoopbackResult, error) {
	var req_ _bindings.Message
	resp_ := &baseNetworkSocketWithCtxGetIpMulticastLoopbackResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketGetIpMulticastLoopbackOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_IP` -> `IP_ADD_MEMBERSHIP`
func (p *BaseNetworkSocketWithCtxInterface) AddIpMembership(ctx_ _bindings.Context, membership IpMulticastMembership) (BaseNetworkSocketAddIpMembershipResult, error) {
	req_ := &baseNetworkSocketWithCtxAddIpMembershipRequest{
		Membership: membership,
	}
	resp_ := &baseNetworkSocketWithCtxAddIpMembershipResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketAddIpMembershipOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_IP` -> `IP_DROP_MEMBERSHIP`
func (p *BaseNetworkSocketWithCtxInterface) DropIpMembership(ctx_ _bindings.Context, membership IpMulticastMembership) (BaseNetworkSocketDropIpMembershipResult, error) {
	req_ := &baseNetworkSocketWithCtxDropIpMembershipRequest{
		Membership: membership,
	}
	resp_ := &baseNetworkSocketWithCtxDropIpMembershipResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketDropIpMembershipOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_IPV6` -> `IPV6_ADD_MEMBERSHIP`.
func (p *BaseNetworkSocketWithCtxInterface) AddIpv6Membership(ctx_ _bindings.Context, membership Ipv6MulticastMembership) (BaseNetworkSocketAddIpv6MembershipResult, error) {
	req_ := &baseNetworkSocketWithCtxAddIpv6MembershipRequest{
		Membership: membership,
	}
	resp_ := &baseNetworkSocketWithCtxAddIpv6MembershipResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketAddIpv6MembershipOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_IPV6` -> `IPV6_DROP_MEMBERSHIP`.
func (p *BaseNetworkSocketWithCtxInterface) DropIpv6Membership(ctx_ _bindings.Context, membership Ipv6MulticastMembership) (BaseNetworkSocketDropIpv6MembershipResult, error) {
	req_ := &baseNetworkSocketWithCtxDropIpv6MembershipRequest{
		Membership: membership,
	}
	resp_ := &baseNetworkSocketWithCtxDropIpv6MembershipResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketDropIpv6MembershipOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_IPV6` -> `IPV6_MULTICAST_IF`.
func (p *BaseNetworkSocketWithCtxInterface) SetIpv6MulticastInterface(ctx_ _bindings.Context, value uint64) (BaseNetworkSocketSetIpv6MulticastInterfaceResult, error) {
	req_ := &baseNetworkSocketWithCtxSetIpv6MulticastInterfaceRequest{
		Value: value,
	}
	resp_ := &baseNetworkSocketWithCtxSetIpv6MulticastInterfaceResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketSetIpv6MulticastInterfaceOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_IPV6` -> `IPV6_MULTICAST_IF`.
func (p *BaseNetworkSocketWithCtxInterface) GetIpv6MulticastInterface(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6MulticastInterfaceResult, error) {
	var req_ _bindings.Message
	resp_ := &baseNetworkSocketWithCtxGetIpv6MulticastInterfaceResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketGetIpv6MulticastInterfaceOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`.
func (p *BaseNetworkSocketWithCtxInterface) SetIpv6MulticastHops(ctx_ _bindings.Context, value OptionalUint8) (BaseNetworkSocketSetIpv6MulticastHopsResult, error) {
	req_ := &baseNetworkSocketWithCtxSetIpv6MulticastHopsRequest{
		Value: value,
	}
	resp_ := &baseNetworkSocketWithCtxSetIpv6MulticastHopsResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketSetIpv6MulticastHopsOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`.
func (p *BaseNetworkSocketWithCtxInterface) GetIpv6MulticastHops(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6MulticastHopsResult, error) {
	var req_ _bindings.Message
	resp_ := &baseNetworkSocketWithCtxGetIpv6MulticastHopsResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketGetIpv6MulticastHopsOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`.
func (p *BaseNetworkSocketWithCtxInterface) SetIpv6MulticastLoopback(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpv6MulticastLoopbackResult, error) {
	req_ := &baseNetworkSocketWithCtxSetIpv6MulticastLoopbackRequest{
		Value: value,
	}
	resp_ := &baseNetworkSocketWithCtxSetIpv6MulticastLoopbackResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketSetIpv6MulticastLoopbackOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`.
func (p *BaseNetworkSocketWithCtxInterface) GetIpv6MulticastLoopback(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6MulticastLoopbackResult, error) {
	var req_ _bindings.Message
	resp_ := &baseNetworkSocketWithCtxGetIpv6MulticastLoopbackResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketGetIpv6MulticastLoopbackOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_IPV6` -> `IPV6_V6ONLY`.
func (p *BaseNetworkSocketWithCtxInterface) SetIpv6Only(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpv6OnlyResult, error) {
	req_ := &baseNetworkSocketWithCtxSetIpv6OnlyRequest{
		Value: value,
	}
	resp_ := &baseNetworkSocketWithCtxSetIpv6OnlyResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketSetIpv6OnlyOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_IPV6` -> `IPV6_V6ONLY`.
func (p *BaseNetworkSocketWithCtxInterface) GetIpv6Only(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6OnlyResult, error) {
	var req_ _bindings.Message
	resp_ := &baseNetworkSocketWithCtxGetIpv6OnlyResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketGetIpv6OnlyOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_IPV6` -> `IPV6_RECVTCLASS`.
func (p *BaseNetworkSocketWithCtxInterface) SetIpv6ReceiveTrafficClass(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpv6ReceiveTrafficClassResult, error) {
	req_ := &baseNetworkSocketWithCtxSetIpv6ReceiveTrafficClassRequest{
		Value: value,
	}
	resp_ := &baseNetworkSocketWithCtxSetIpv6ReceiveTrafficClassResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketSetIpv6ReceiveTrafficClassOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_IPV6` -> `IPV6_RECVTCLASS`.
func (p *BaseNetworkSocketWithCtxInterface) GetIpv6ReceiveTrafficClass(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6ReceiveTrafficClassResult, error) {
	var req_ _bindings.Message
	resp_ := &baseNetworkSocketWithCtxGetIpv6ReceiveTrafficClassResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketGetIpv6ReceiveTrafficClassOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_IPV6` -> `IPV6_TCLASS`
func (p *BaseNetworkSocketWithCtxInterface) SetIpv6TrafficClass(ctx_ _bindings.Context, value OptionalUint8) (BaseNetworkSocketSetIpv6TrafficClassResult, error) {
	req_ := &baseNetworkSocketWithCtxSetIpv6TrafficClassRequest{
		Value: value,
	}
	resp_ := &baseNetworkSocketWithCtxSetIpv6TrafficClassResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketSetIpv6TrafficClassOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get `SOL_IPV6` -> `IPV6_TCLASS`.
func (p *BaseNetworkSocketWithCtxInterface) GetIpv6TrafficClass(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6TrafficClassResult, error) {
	var req_ _bindings.Message
	resp_ := &baseNetworkSocketWithCtxGetIpv6TrafficClassResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketGetIpv6TrafficClassOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *BaseNetworkSocketWithCtxInterface) BaseSocketBind(ctx_ _bindings.Context, addr fuchsianet.SocketAddress) (BaseNetworkSocketBaseSocketBindResult, error) {
	req_ := &baseNetworkSocketWithCtxBaseSocketBindRequest{
		Addr: addr,
	}
	resp_ := &baseNetworkSocketWithCtxBaseSocketBindResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketBaseSocketBindOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *BaseNetworkSocketWithCtxInterface) BaseSocketConnect(ctx_ _bindings.Context, addr fuchsianet.SocketAddress) (BaseNetworkSocketBaseSocketConnectResult, error) {
	req_ := &baseNetworkSocketWithCtxBaseSocketConnectRequest{
		Addr: addr,
	}
	resp_ := &baseNetworkSocketWithCtxBaseSocketConnectResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketBaseSocketConnectOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *BaseNetworkSocketWithCtxInterface) BaseSocketDisconnect(ctx_ _bindings.Context) (BaseNetworkSocketBaseSocketDisconnectResult, error) {
	var req_ _bindings.Message
	resp_ := &baseNetworkSocketWithCtxBaseSocketDisconnectResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketBaseSocketDisconnectOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *BaseNetworkSocketWithCtxInterface) BaseSocketGetSockName(ctx_ _bindings.Context) (BaseNetworkSocketBaseSocketGetSockNameResult, error) {
	var req_ _bindings.Message
	resp_ := &baseNetworkSocketWithCtxBaseSocketGetSockNameResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketBaseSocketGetSockNameOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *BaseNetworkSocketWithCtxInterface) BaseSocketGetPeerName(ctx_ _bindings.Context) (BaseNetworkSocketBaseSocketGetPeerNameResult, error) {
	var req_ _bindings.Message
	resp_ := &baseNetworkSocketWithCtxBaseSocketGetPeerNameResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketBaseSocketGetPeerNameOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *BaseNetworkSocketWithCtxInterface) BaseSocketShutdown(ctx_ _bindings.Context, mode ShutdownMode) (BaseNetworkSocketBaseSocketShutdownResult, error) {
	req_ := &baseNetworkSocketWithCtxBaseSocketShutdownRequest{
		Mode: mode,
	}
	resp_ := &baseNetworkSocketWithCtxBaseSocketShutdownResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketBaseSocketShutdownOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *BaseNetworkSocketWithCtxInterface) BaseSocketShutdown2(ctx_ _bindings.Context, mode ShutdownMode) (BaseNetworkSocketBaseSocketShutdown2Result, error) {
	req_ := &baseNetworkSocketWithCtxBaseSocketShutdown2Request{
		Mode: mode,
	}
	resp_ := &baseNetworkSocketWithCtxBaseSocketShutdown2Response{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketBaseSocketShutdown2Ordinal, req_, resp_)
	return resp_.Result, err_
}

func (p *BaseNetworkSocketWithCtxInterface) BaseSocketSetIpTypeOfService(ctx_ _bindings.Context, value uint8) (BaseNetworkSocketBaseSocketSetIpTypeOfServiceResult, error) {
	req_ := &baseNetworkSocketWithCtxBaseSocketSetIpTypeOfServiceRequest{
		Value: value,
	}
	resp_ := &baseNetworkSocketWithCtxBaseSocketSetIpTypeOfServiceResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketBaseSocketSetIpTypeOfServiceOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *BaseNetworkSocketWithCtxInterface) BaseSocketGetIpTypeOfService(ctx_ _bindings.Context) (BaseNetworkSocketBaseSocketGetIpTypeOfServiceResult, error) {
	var req_ _bindings.Message
	resp_ := &baseNetworkSocketWithCtxBaseSocketGetIpTypeOfServiceResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketBaseSocketGetIpTypeOfServiceOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *BaseNetworkSocketWithCtxInterface) BaseSocketSetIpTtl(ctx_ _bindings.Context, value OptionalUint8) (BaseNetworkSocketBaseSocketSetIpTtlResult, error) {
	req_ := &baseNetworkSocketWithCtxBaseSocketSetIpTtlRequest{
		Value: value,
	}
	resp_ := &baseNetworkSocketWithCtxBaseSocketSetIpTtlResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketBaseSocketSetIpTtlOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *BaseNetworkSocketWithCtxInterface) BaseSocketGetIpTtl(ctx_ _bindings.Context) (BaseNetworkSocketBaseSocketGetIpTtlResult, error) {
	var req_ _bindings.Message
	resp_ := &baseNetworkSocketWithCtxBaseSocketGetIpTtlResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketBaseSocketGetIpTtlOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *BaseNetworkSocketWithCtxInterface) BaseSocketSetIpPacketInfo(ctx_ _bindings.Context, value bool) (BaseNetworkSocketBaseSocketSetIpPacketInfoResult, error) {
	req_ := &baseNetworkSocketWithCtxBaseSocketSetIpPacketInfoRequest{
		Value: value,
	}
	resp_ := &baseNetworkSocketWithCtxBaseSocketSetIpPacketInfoResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketBaseSocketSetIpPacketInfoOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *BaseNetworkSocketWithCtxInterface) BaseSocketGetIpPacketInfo(ctx_ _bindings.Context) (BaseNetworkSocketBaseSocketGetIpPacketInfoResult, error) {
	var req_ _bindings.Message
	resp_ := &baseNetworkSocketWithCtxBaseSocketGetIpPacketInfoResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketBaseSocketGetIpPacketInfoOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *BaseNetworkSocketWithCtxInterface) BaseSocketSetIpReceiveTypeOfService(ctx_ _bindings.Context, value bool) (BaseNetworkSocketBaseSocketSetIpReceiveTypeOfServiceResult, error) {
	req_ := &baseNetworkSocketWithCtxBaseSocketSetIpReceiveTypeOfServiceRequest{
		Value: value,
	}
	resp_ := &baseNetworkSocketWithCtxBaseSocketSetIpReceiveTypeOfServiceResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketBaseSocketSetIpReceiveTypeOfServiceOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *BaseNetworkSocketWithCtxInterface) BaseSocketGetIpReceiveTypeOfService(ctx_ _bindings.Context) (BaseNetworkSocketBaseSocketGetIpReceiveTypeOfServiceResult, error) {
	var req_ _bindings.Message
	resp_ := &baseNetworkSocketWithCtxBaseSocketGetIpReceiveTypeOfServiceResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketBaseSocketGetIpReceiveTypeOfServiceOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *BaseNetworkSocketWithCtxInterface) BaseSocketSetIpMulticastInterface(ctx_ _bindings.Context, iface uint64, address fuchsianet.Ipv4Address) (BaseNetworkSocketBaseSocketSetIpMulticastInterfaceResult, error) {
	req_ := &baseNetworkSocketWithCtxBaseSocketSetIpMulticastInterfaceRequest{
		Iface:   iface,
		Address: address,
	}
	resp_ := &baseNetworkSocketWithCtxBaseSocketSetIpMulticastInterfaceResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketBaseSocketSetIpMulticastInterfaceOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *BaseNetworkSocketWithCtxInterface) BaseSocketGetIpMulticastInterface(ctx_ _bindings.Context) (BaseNetworkSocketBaseSocketGetIpMulticastInterfaceResult, error) {
	var req_ _bindings.Message
	resp_ := &baseNetworkSocketWithCtxBaseSocketGetIpMulticastInterfaceResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketBaseSocketGetIpMulticastInterfaceOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *BaseNetworkSocketWithCtxInterface) BaseSocketSetIpMulticastTtl(ctx_ _bindings.Context, value OptionalUint8) (BaseNetworkSocketBaseSocketSetIpMulticastTtlResult, error) {
	req_ := &baseNetworkSocketWithCtxBaseSocketSetIpMulticastTtlRequest{
		Value: value,
	}
	resp_ := &baseNetworkSocketWithCtxBaseSocketSetIpMulticastTtlResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketBaseSocketSetIpMulticastTtlOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *BaseNetworkSocketWithCtxInterface) BaseSocketGetIpMulticastTtl(ctx_ _bindings.Context) (BaseNetworkSocketBaseSocketGetIpMulticastTtlResult, error) {
	var req_ _bindings.Message
	resp_ := &baseNetworkSocketWithCtxBaseSocketGetIpMulticastTtlResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketBaseSocketGetIpMulticastTtlOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *BaseNetworkSocketWithCtxInterface) BaseSocketSetIpMulticastLoopback(ctx_ _bindings.Context, value bool) (BaseNetworkSocketBaseSocketSetIpMulticastLoopbackResult, error) {
	req_ := &baseNetworkSocketWithCtxBaseSocketSetIpMulticastLoopbackRequest{
		Value: value,
	}
	resp_ := &baseNetworkSocketWithCtxBaseSocketSetIpMulticastLoopbackResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketBaseSocketSetIpMulticastLoopbackOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *BaseNetworkSocketWithCtxInterface) BaseSocketGetIpMulticastLoopback(ctx_ _bindings.Context) (BaseNetworkSocketBaseSocketGetIpMulticastLoopbackResult, error) {
	var req_ _bindings.Message
	resp_ := &baseNetworkSocketWithCtxBaseSocketGetIpMulticastLoopbackResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketBaseSocketGetIpMulticastLoopbackOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *BaseNetworkSocketWithCtxInterface) BaseSocketAddIpMembership(ctx_ _bindings.Context, membership IpMulticastMembership) (BaseNetworkSocketBaseSocketAddIpMembershipResult, error) {
	req_ := &baseNetworkSocketWithCtxBaseSocketAddIpMembershipRequest{
		Membership: membership,
	}
	resp_ := &baseNetworkSocketWithCtxBaseSocketAddIpMembershipResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketBaseSocketAddIpMembershipOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *BaseNetworkSocketWithCtxInterface) BaseSocketDropIpMembership(ctx_ _bindings.Context, membership IpMulticastMembership) (BaseNetworkSocketBaseSocketDropIpMembershipResult, error) {
	req_ := &baseNetworkSocketWithCtxBaseSocketDropIpMembershipRequest{
		Membership: membership,
	}
	resp_ := &baseNetworkSocketWithCtxBaseSocketDropIpMembershipResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketBaseSocketDropIpMembershipOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *BaseNetworkSocketWithCtxInterface) BaseSocketAddIpv6Membership(ctx_ _bindings.Context, membership Ipv6MulticastMembership) (BaseNetworkSocketBaseSocketAddIpv6MembershipResult, error) {
	req_ := &baseNetworkSocketWithCtxBaseSocketAddIpv6MembershipRequest{
		Membership: membership,
	}
	resp_ := &baseNetworkSocketWithCtxBaseSocketAddIpv6MembershipResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketBaseSocketAddIpv6MembershipOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *BaseNetworkSocketWithCtxInterface) BaseSocketDropIpv6Membership(ctx_ _bindings.Context, membership Ipv6MulticastMembership) (BaseNetworkSocketBaseSocketDropIpv6MembershipResult, error) {
	req_ := &baseNetworkSocketWithCtxBaseSocketDropIpv6MembershipRequest{
		Membership: membership,
	}
	resp_ := &baseNetworkSocketWithCtxBaseSocketDropIpv6MembershipResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketBaseSocketDropIpv6MembershipOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *BaseNetworkSocketWithCtxInterface) BaseSocketSetIpv6MulticastInterface(ctx_ _bindings.Context, value uint64) (BaseNetworkSocketBaseSocketSetIpv6MulticastInterfaceResult, error) {
	req_ := &baseNetworkSocketWithCtxBaseSocketSetIpv6MulticastInterfaceRequest{
		Value: value,
	}
	resp_ := &baseNetworkSocketWithCtxBaseSocketSetIpv6MulticastInterfaceResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketBaseSocketSetIpv6MulticastInterfaceOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *BaseNetworkSocketWithCtxInterface) BaseSocketGetIpv6MulticastInterface(ctx_ _bindings.Context) (BaseNetworkSocketBaseSocketGetIpv6MulticastInterfaceResult, error) {
	var req_ _bindings.Message
	resp_ := &baseNetworkSocketWithCtxBaseSocketGetIpv6MulticastInterfaceResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketBaseSocketGetIpv6MulticastInterfaceOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *BaseNetworkSocketWithCtxInterface) BaseSocketSetIpv6MulticastHops(ctx_ _bindings.Context, value OptionalUint8) (BaseNetworkSocketBaseSocketSetIpv6MulticastHopsResult, error) {
	req_ := &baseNetworkSocketWithCtxBaseSocketSetIpv6MulticastHopsRequest{
		Value: value,
	}
	resp_ := &baseNetworkSocketWithCtxBaseSocketSetIpv6MulticastHopsResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketBaseSocketSetIpv6MulticastHopsOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *BaseNetworkSocketWithCtxInterface) BaseSocketGetIpv6MulticastHops(ctx_ _bindings.Context) (BaseNetworkSocketBaseSocketGetIpv6MulticastHopsResult, error) {
	var req_ _bindings.Message
	resp_ := &baseNetworkSocketWithCtxBaseSocketGetIpv6MulticastHopsResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketBaseSocketGetIpv6MulticastHopsOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *BaseNetworkSocketWithCtxInterface) BaseSocketSetIpv6MulticastLoopback(ctx_ _bindings.Context, value bool) (BaseNetworkSocketBaseSocketSetIpv6MulticastLoopbackResult, error) {
	req_ := &baseNetworkSocketWithCtxBaseSocketSetIpv6MulticastLoopbackRequest{
		Value: value,
	}
	resp_ := &baseNetworkSocketWithCtxBaseSocketSetIpv6MulticastLoopbackResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketBaseSocketSetIpv6MulticastLoopbackOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *BaseNetworkSocketWithCtxInterface) BaseSocketGetIpv6MulticastLoopback(ctx_ _bindings.Context) (BaseNetworkSocketBaseSocketGetIpv6MulticastLoopbackResult, error) {
	var req_ _bindings.Message
	resp_ := &baseNetworkSocketWithCtxBaseSocketGetIpv6MulticastLoopbackResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketBaseSocketGetIpv6MulticastLoopbackOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *BaseNetworkSocketWithCtxInterface) BaseSocketSetIpv6Only(ctx_ _bindings.Context, value bool) (BaseNetworkSocketBaseSocketSetIpv6OnlyResult, error) {
	req_ := &baseNetworkSocketWithCtxBaseSocketSetIpv6OnlyRequest{
		Value: value,
	}
	resp_ := &baseNetworkSocketWithCtxBaseSocketSetIpv6OnlyResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketBaseSocketSetIpv6OnlyOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *BaseNetworkSocketWithCtxInterface) BaseSocketGetIpv6Only(ctx_ _bindings.Context) (BaseNetworkSocketBaseSocketGetIpv6OnlyResult, error) {
	var req_ _bindings.Message
	resp_ := &baseNetworkSocketWithCtxBaseSocketGetIpv6OnlyResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketBaseSocketGetIpv6OnlyOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *BaseNetworkSocketWithCtxInterface) BaseSocketSetIpv6ReceiveTrafficClass(ctx_ _bindings.Context, value bool) (BaseNetworkSocketBaseSocketSetIpv6ReceiveTrafficClassResult, error) {
	req_ := &baseNetworkSocketWithCtxBaseSocketSetIpv6ReceiveTrafficClassRequest{
		Value: value,
	}
	resp_ := &baseNetworkSocketWithCtxBaseSocketSetIpv6ReceiveTrafficClassResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketBaseSocketSetIpv6ReceiveTrafficClassOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *BaseNetworkSocketWithCtxInterface) BaseSocketGetIpv6ReceiveTrafficClass(ctx_ _bindings.Context) (BaseNetworkSocketBaseSocketGetIpv6ReceiveTrafficClassResult, error) {
	var req_ _bindings.Message
	resp_ := &baseNetworkSocketWithCtxBaseSocketGetIpv6ReceiveTrafficClassResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketBaseSocketGetIpv6ReceiveTrafficClassOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *BaseNetworkSocketWithCtxInterface) BaseSocketSetIpv6TrafficClass(ctx_ _bindings.Context, value OptionalUint8) (BaseNetworkSocketBaseSocketSetIpv6TrafficClassResult, error) {
	req_ := &baseNetworkSocketWithCtxBaseSocketSetIpv6TrafficClassRequest{
		Value: value,
	}
	resp_ := &baseNetworkSocketWithCtxBaseSocketSetIpv6TrafficClassResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketBaseSocketSetIpv6TrafficClassOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *BaseNetworkSocketWithCtxInterface) BaseSocketGetIpv6TrafficClass(ctx_ _bindings.Context) (BaseNetworkSocketBaseSocketGetIpv6TrafficClassResult, error) {
	var req_ _bindings.Message
	resp_ := &baseNetworkSocketWithCtxBaseSocketGetIpv6TrafficClassResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketBaseSocketGetIpv6TrafficClassOrdinal, req_, resp_)
	return resp_.Result, err_
}

// A network socket.
type BaseNetworkSocketWithCtx 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)
	// 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)
	// Sets the local address used for the socket.
	Bind(ctx_ _bindings.Context, addr fuchsianet.SocketAddress) (BaseNetworkSocketBindResult, error)
	// Initiates a connection to a remote address.
	Connect(ctx_ _bindings.Context, addr fuchsianet.SocketAddress) (BaseNetworkSocketConnectResult, error)
	// Clears connection information from this socket.
	Disconnect(ctx_ _bindings.Context) (BaseNetworkSocketDisconnectResult, error)
	// Retrieves the local socket address.
	GetSockName(ctx_ _bindings.Context) (BaseNetworkSocketGetSockNameResult, error)
	// Retrieves the remote socket address.
	GetPeerName(ctx_ _bindings.Context) (BaseNetworkSocketGetPeerNameResult, error)
	// Shuts down part of the socket.
	Shutdown(ctx_ _bindings.Context, mode ShutdownMode) (BaseNetworkSocketShutdownResult, error)
	Shutdown2(ctx_ _bindings.Context, mode ShutdownMode) (BaseNetworkSocketShutdown2Result, error)
	// Set `SOL_IP` -> `IP_TOS`.
	SetIpTypeOfService(ctx_ _bindings.Context, value uint8) (BaseNetworkSocketSetIpTypeOfServiceResult, error)
	// Get `SOL_IP` -> `IP_TOS`.
	GetIpTypeOfService(ctx_ _bindings.Context) (BaseNetworkSocketGetIpTypeOfServiceResult, error)
	// Set `SOL_IP` -> `IP_TTL`.
	SetIpTtl(ctx_ _bindings.Context, value OptionalUint8) (BaseNetworkSocketSetIpTtlResult, error)
	// Get `SOL_IP` -> `IP_TTL`.
	GetIpTtl(ctx_ _bindings.Context) (BaseNetworkSocketGetIpTtlResult, error)
	// Set `SOL_IP` -> `IP_PKTINFO`.
	SetIpPacketInfo(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpPacketInfoResult, error)
	// Get `SOL_IP` -> `IP_PKTINFO`.
	GetIpPacketInfo(ctx_ _bindings.Context) (BaseNetworkSocketGetIpPacketInfoResult, error)
	// Set `SOL_IP` -> `IP_RECVTOS`.
	SetIpReceiveTypeOfService(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpReceiveTypeOfServiceResult, error)
	// Get `SOL_IP` -> `IP_RECVTOS`.
	GetIpReceiveTypeOfService(ctx_ _bindings.Context) (BaseNetworkSocketGetIpReceiveTypeOfServiceResult, error)
	// Set `SOL_IP` -> `IP_MULTICAST_IF`.
	SetIpMulticastInterface(ctx_ _bindings.Context, iface uint64, address fuchsianet.Ipv4Address) (BaseNetworkSocketSetIpMulticastInterfaceResult, error)
	// Get `SOL_IP` -> `IP_MULTICAST_IF`.
	GetIpMulticastInterface(ctx_ _bindings.Context) (BaseNetworkSocketGetIpMulticastInterfaceResult, error)
	// Set `SOL_IP` -> `IP_MULTICAST_TTL`.
	SetIpMulticastTtl(ctx_ _bindings.Context, value OptionalUint8) (BaseNetworkSocketSetIpMulticastTtlResult, error)
	// Get `SOL_IP` -> `IP_MULTICAST_TTL`.
	GetIpMulticastTtl(ctx_ _bindings.Context) (BaseNetworkSocketGetIpMulticastTtlResult, error)
	// Set `SOL_IP` -> `IP_MULTICAST_LOOP`.
	SetIpMulticastLoopback(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpMulticastLoopbackResult, error)
	// Get `SOL_IP` -> `IP_MULTICAST_LOOP`.
	GetIpMulticastLoopback(ctx_ _bindings.Context) (BaseNetworkSocketGetIpMulticastLoopbackResult, error)
	// Set `SOL_IP` -> `IP_ADD_MEMBERSHIP`
	AddIpMembership(ctx_ _bindings.Context, membership IpMulticastMembership) (BaseNetworkSocketAddIpMembershipResult, error)
	// Set `SOL_IP` -> `IP_DROP_MEMBERSHIP`
	DropIpMembership(ctx_ _bindings.Context, membership IpMulticastMembership) (BaseNetworkSocketDropIpMembershipResult, error)
	// Set `SOL_IPV6` -> `IPV6_ADD_MEMBERSHIP`.
	AddIpv6Membership(ctx_ _bindings.Context, membership Ipv6MulticastMembership) (BaseNetworkSocketAddIpv6MembershipResult, error)
	// Set `SOL_IPV6` -> `IPV6_DROP_MEMBERSHIP`.
	DropIpv6Membership(ctx_ _bindings.Context, membership Ipv6MulticastMembership) (BaseNetworkSocketDropIpv6MembershipResult, error)
	// Set `SOL_IPV6` -> `IPV6_MULTICAST_IF`.
	SetIpv6MulticastInterface(ctx_ _bindings.Context, value uint64) (BaseNetworkSocketSetIpv6MulticastInterfaceResult, error)
	// Get `SOL_IPV6` -> `IPV6_MULTICAST_IF`.
	GetIpv6MulticastInterface(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6MulticastInterfaceResult, error)
	// Set `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`.
	SetIpv6MulticastHops(ctx_ _bindings.Context, value OptionalUint8) (BaseNetworkSocketSetIpv6MulticastHopsResult, error)
	// Get `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`.
	GetIpv6MulticastHops(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6MulticastHopsResult, error)
	// Set `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`.
	SetIpv6MulticastLoopback(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpv6MulticastLoopbackResult, error)
	// Get `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`.
	GetIpv6MulticastLoopback(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6MulticastLoopbackResult, error)
	// Set `SOL_IPV6` -> `IPV6_V6ONLY`.
	SetIpv6Only(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpv6OnlyResult, error)
	// Get `SOL_IPV6` -> `IPV6_V6ONLY`.
	GetIpv6Only(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6OnlyResult, error)
	// Set `SOL_IPV6` -> `IPV6_RECVTCLASS`.
	SetIpv6ReceiveTrafficClass(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpv6ReceiveTrafficClassResult, error)
	// Get `SOL_IPV6` -> `IPV6_RECVTCLASS`.
	GetIpv6ReceiveTrafficClass(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6ReceiveTrafficClassResult, error)
	// Set `SOL_IPV6` -> `IPV6_TCLASS`
	SetIpv6TrafficClass(ctx_ _bindings.Context, value OptionalUint8) (BaseNetworkSocketSetIpv6TrafficClassResult, error)
	// Get `SOL_IPV6` -> `IPV6_TCLASS`.
	GetIpv6TrafficClass(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6TrafficClassResult, error)
	BaseSocketBind(ctx_ _bindings.Context, addr fuchsianet.SocketAddress) (BaseNetworkSocketBaseSocketBindResult, error)
	BaseSocketConnect(ctx_ _bindings.Context, addr fuchsianet.SocketAddress) (BaseNetworkSocketBaseSocketConnectResult, error)
	BaseSocketDisconnect(ctx_ _bindings.Context) (BaseNetworkSocketBaseSocketDisconnectResult, error)
	BaseSocketGetSockName(ctx_ _bindings.Context) (BaseNetworkSocketBaseSocketGetSockNameResult, error)
	BaseSocketGetPeerName(ctx_ _bindings.Context) (BaseNetworkSocketBaseSocketGetPeerNameResult, error)
	BaseSocketShutdown(ctx_ _bindings.Context, mode ShutdownMode) (BaseNetworkSocketBaseSocketShutdownResult, error)
	BaseSocketShutdown2(ctx_ _bindings.Context, mode ShutdownMode) (BaseNetworkSocketBaseSocketShutdown2Result, error)
	BaseSocketSetIpTypeOfService(ctx_ _bindings.Context, value uint8) (BaseNetworkSocketBaseSocketSetIpTypeOfServiceResult, error)
	BaseSocketGetIpTypeOfService(ctx_ _bindings.Context) (BaseNetworkSocketBaseSocketGetIpTypeOfServiceResult, error)
	BaseSocketSetIpTtl(ctx_ _bindings.Context, value OptionalUint8) (BaseNetworkSocketBaseSocketSetIpTtlResult, error)
	BaseSocketGetIpTtl(ctx_ _bindings.Context) (BaseNetworkSocketBaseSocketGetIpTtlResult, error)
	BaseSocketSetIpPacketInfo(ctx_ _bindings.Context, value bool) (BaseNetworkSocketBaseSocketSetIpPacketInfoResult, error)
	BaseSocketGetIpPacketInfo(ctx_ _bindings.Context) (BaseNetworkSocketBaseSocketGetIpPacketInfoResult, error)
	BaseSocketSetIpReceiveTypeOfService(ctx_ _bindings.Context, value bool) (BaseNetworkSocketBaseSocketSetIpReceiveTypeOfServiceResult, error)
	BaseSocketGetIpReceiveTypeOfService(ctx_ _bindings.Context) (BaseNetworkSocketBaseSocketGetIpReceiveTypeOfServiceResult, error)
	BaseSocketSetIpMulticastInterface(ctx_ _bindings.Context, iface uint64, address fuchsianet.Ipv4Address) (BaseNetworkSocketBaseSocketSetIpMulticastInterfaceResult, error)
	BaseSocketGetIpMulticastInterface(ctx_ _bindings.Context) (BaseNetworkSocketBaseSocketGetIpMulticastInterfaceResult, error)
	BaseSocketSetIpMulticastTtl(ctx_ _bindings.Context, value OptionalUint8) (BaseNetworkSocketBaseSocketSetIpMulticastTtlResult, error)
	BaseSocketGetIpMulticastTtl(ctx_ _bindings.Context) (BaseNetworkSocketBaseSocketGetIpMulticastTtlResult, error)
	BaseSocketSetIpMulticastLoopback(ctx_ _bindings.Context, value bool) (BaseNetworkSocketBaseSocketSetIpMulticastLoopbackResult, error)
	BaseSocketGetIpMulticastLoopback(ctx_ _bindings.Context) (BaseNetworkSocketBaseSocketGetIpMulticastLoopbackResult, error)
	BaseSocketAddIpMembership(ctx_ _bindings.Context, membership IpMulticastMembership) (BaseNetworkSocketBaseSocketAddIpMembershipResult, error)
	BaseSocketDropIpMembership(ctx_ _bindings.Context, membership IpMulticastMembership) (BaseNetworkSocketBaseSocketDropIpMembershipResult, error)
	BaseSocketAddIpv6Membership(ctx_ _bindings.Context, membership Ipv6MulticastMembership) (BaseNetworkSocketBaseSocketAddIpv6MembershipResult, error)
	BaseSocketDropIpv6Membership(ctx_ _bindings.Context, membership Ipv6MulticastMembership) (BaseNetworkSocketBaseSocketDropIpv6MembershipResult, error)
	BaseSocketSetIpv6MulticastInterface(ctx_ _bindings.Context, value uint64) (BaseNetworkSocketBaseSocketSetIpv6MulticastInterfaceResult, error)
	BaseSocketGetIpv6MulticastInterface(ctx_ _bindings.Context) (BaseNetworkSocketBaseSocketGetIpv6MulticastInterfaceResult, error)
	BaseSocketSetIpv6MulticastHops(ctx_ _bindings.Context, value OptionalUint8) (BaseNetworkSocketBaseSocketSetIpv6MulticastHopsResult, error)
	BaseSocketGetIpv6MulticastHops(ctx_ _bindings.Context) (BaseNetworkSocketBaseSocketGetIpv6MulticastHopsResult, error)
	BaseSocketSetIpv6MulticastLoopback(ctx_ _bindings.Context, value bool) (BaseNetworkSocketBaseSocketSetIpv6MulticastLoopbackResult, error)
	BaseSocketGetIpv6MulticastLoopback(ctx_ _bindings.Context) (BaseNetworkSocketBaseSocketGetIpv6MulticastLoopbackResult, error)
	BaseSocketSetIpv6Only(ctx_ _bindings.Context, value bool) (BaseNetworkSocketBaseSocketSetIpv6OnlyResult, error)
	BaseSocketGetIpv6Only(ctx_ _bindings.Context) (BaseNetworkSocketBaseSocketGetIpv6OnlyResult, error)
	BaseSocketSetIpv6ReceiveTrafficClass(ctx_ _bindings.Context, value bool) (BaseNetworkSocketBaseSocketSetIpv6ReceiveTrafficClassResult, error)
	BaseSocketGetIpv6ReceiveTrafficClass(ctx_ _bindings.Context) (BaseNetworkSocketBaseSocketGetIpv6ReceiveTrafficClassResult, error)
	BaseSocketSetIpv6TrafficClass(ctx_ _bindings.Context, value OptionalUint8) (BaseNetworkSocketBaseSocketSetIpv6TrafficClassResult, error)
	BaseSocketGetIpv6TrafficClass(ctx_ _bindings.Context) (BaseNetworkSocketBaseSocketGetIpv6TrafficClassResult, error)
}

type BaseNetworkSocketWithCtxTransitionalBase struct{}

func (_ *BaseNetworkSocketWithCtxTransitionalBase) NodeGetFlags(ctx_ _bindings.Context) (int32, uint32, error) {
	panic("Not Implemented")
}
func (_ *BaseNetworkSocketWithCtxTransitionalBase) NodeSetFlags(ctx_ _bindings.Context, flags uint32) (int32, error) {
	panic("Not Implemented")
}

type BaseNetworkSocketWithCtxInterfaceRequest _bindings.InterfaceRequest

func NewBaseNetworkSocketWithCtxInterfaceRequest() (BaseNetworkSocketWithCtxInterfaceRequest, *BaseNetworkSocketWithCtxInterface, error) {
	req, cli, err := _bindings.NewInterfaceRequest()
	return BaseNetworkSocketWithCtxInterfaceRequest(req), (*BaseNetworkSocketWithCtxInterface)(cli), err
}

type BaseNetworkSocketWithCtxStub struct {
	Impl BaseNetworkSocketWithCtx
}

func (s_ *BaseNetworkSocketWithCtxStub) Dispatch(args_ _bindings.DispatchArgs) (_bindings.Message, bool, error) {
	switch args_.Ordinal {
	case BaseNetworkSocketCloneOrdinal:
		in_ := baseNetworkSocketWithCtxCloneRequest{}
		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 BaseNetworkSocketCloseOrdinal:
		s, err_ := s_.Impl.Close(args_.Ctx)
		out_ := baseNetworkSocketWithCtxCloseResponse{}
		out_.S = s
		return &out_, true, err_
	case BaseNetworkSocketDescribeOrdinal:
		info, err_ := s_.Impl.Describe(args_.Ctx)
		out_ := baseNetworkSocketWithCtxDescribeResponse{}
		out_.Info = info
		return &out_, true, err_
	case BaseNetworkSocketSyncOrdinal:
		s, err_ := s_.Impl.Sync(args_.Ctx)
		out_ := baseNetworkSocketWithCtxSyncResponse{}
		out_.S = s
		return &out_, true, err_
	case BaseNetworkSocketGetAttrOrdinal:
		s, attributes, err_ := s_.Impl.GetAttr(args_.Ctx)
		out_ := baseNetworkSocketWithCtxGetAttrResponse{}
		out_.S = s
		out_.Attributes = attributes
		return &out_, true, err_
	case BaseNetworkSocketSetAttrOrdinal:
		in_ := baseNetworkSocketWithCtxSetAttrRequest{}
		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_ := baseNetworkSocketWithCtxSetAttrResponse{}
		out_.S = s
		return &out_, true, err_
	case BaseNetworkSocketNodeGetFlagsOrdinal:
		s, flags, err_ := s_.Impl.NodeGetFlags(args_.Ctx)
		out_ := baseNetworkSocketWithCtxNodeGetFlagsResponse{}
		out_.S = s
		out_.Flags = flags
		return &out_, true, err_
	case BaseNetworkSocketNodeSetFlagsOrdinal:
		in_ := baseNetworkSocketWithCtxNodeSetFlagsRequest{}
		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_ := baseNetworkSocketWithCtxNodeSetFlagsResponse{}
		out_.S = s
		return &out_, true, err_
	case BaseNetworkSocketSetReuseAddressOrdinal:
		in_ := baseNetworkSocketWithCtxSetReuseAddressRequest{}
		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_ := baseNetworkSocketWithCtxSetReuseAddressResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseNetworkSocketGetReuseAddressOrdinal:
		result, err_ := s_.Impl.GetReuseAddress(args_.Ctx)
		out_ := baseNetworkSocketWithCtxGetReuseAddressResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseNetworkSocketGetErrorOrdinal:
		result, err_ := s_.Impl.GetError(args_.Ctx)
		out_ := baseNetworkSocketWithCtxGetErrorResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseNetworkSocketSetBroadcastOrdinal:
		in_ := baseNetworkSocketWithCtxSetBroadcastRequest{}
		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_ := baseNetworkSocketWithCtxSetBroadcastResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseNetworkSocketGetBroadcastOrdinal:
		result, err_ := s_.Impl.GetBroadcast(args_.Ctx)
		out_ := baseNetworkSocketWithCtxGetBroadcastResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseNetworkSocketSetSendBufferOrdinal:
		in_ := baseNetworkSocketWithCtxSetSendBufferRequest{}
		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_ := baseNetworkSocketWithCtxSetSendBufferResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseNetworkSocketGetSendBufferOrdinal:
		result, err_ := s_.Impl.GetSendBuffer(args_.Ctx)
		out_ := baseNetworkSocketWithCtxGetSendBufferResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseNetworkSocketSetReceiveBufferOrdinal:
		in_ := baseNetworkSocketWithCtxSetReceiveBufferRequest{}
		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_ := baseNetworkSocketWithCtxSetReceiveBufferResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseNetworkSocketGetReceiveBufferOrdinal:
		result, err_ := s_.Impl.GetReceiveBuffer(args_.Ctx)
		out_ := baseNetworkSocketWithCtxGetReceiveBufferResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseNetworkSocketSetKeepAliveOrdinal:
		in_ := baseNetworkSocketWithCtxSetKeepAliveRequest{}
		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_ := baseNetworkSocketWithCtxSetKeepAliveResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseNetworkSocketGetKeepAliveOrdinal:
		result, err_ := s_.Impl.GetKeepAlive(args_.Ctx)
		out_ := baseNetworkSocketWithCtxGetKeepAliveResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseNetworkSocketSetOutOfBandInlineOrdinal:
		in_ := baseNetworkSocketWithCtxSetOutOfBandInlineRequest{}
		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_ := baseNetworkSocketWithCtxSetOutOfBandInlineResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseNetworkSocketGetOutOfBandInlineOrdinal:
		result, err_ := s_.Impl.GetOutOfBandInline(args_.Ctx)
		out_ := baseNetworkSocketWithCtxGetOutOfBandInlineResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseNetworkSocketSetNoCheckOrdinal:
		in_ := baseNetworkSocketWithCtxSetNoCheckRequest{}
		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_ := baseNetworkSocketWithCtxSetNoCheckResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseNetworkSocketGetNoCheckOrdinal:
		result, err_ := s_.Impl.GetNoCheck(args_.Ctx)
		out_ := baseNetworkSocketWithCtxGetNoCheckResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseNetworkSocketSetLingerOrdinal:
		in_ := baseNetworkSocketWithCtxSetLingerRequest{}
		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_ := baseNetworkSocketWithCtxSetLingerResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseNetworkSocketGetLingerOrdinal:
		result, err_ := s_.Impl.GetLinger(args_.Ctx)
		out_ := baseNetworkSocketWithCtxGetLingerResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseNetworkSocketSetReusePortOrdinal:
		in_ := baseNetworkSocketWithCtxSetReusePortRequest{}
		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_ := baseNetworkSocketWithCtxSetReusePortResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseNetworkSocketGetReusePortOrdinal:
		result, err_ := s_.Impl.GetReusePort(args_.Ctx)
		out_ := baseNetworkSocketWithCtxGetReusePortResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseNetworkSocketGetAcceptConnOrdinal:
		result, err_ := s_.Impl.GetAcceptConn(args_.Ctx)
		out_ := baseNetworkSocketWithCtxGetAcceptConnResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseNetworkSocketSetBindToDeviceOrdinal:
		in_ := baseNetworkSocketWithCtxSetBindToDeviceRequest{}
		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_ := baseNetworkSocketWithCtxSetBindToDeviceResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseNetworkSocketGetBindToDeviceOrdinal:
		result, err_ := s_.Impl.GetBindToDevice(args_.Ctx)
		out_ := baseNetworkSocketWithCtxGetBindToDeviceResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseNetworkSocketSetTimestampOrdinal:
		in_ := baseNetworkSocketWithCtxSetTimestampRequest{}
		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_ := baseNetworkSocketWithCtxSetTimestampResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseNetworkSocketGetTimestampOrdinal:
		result, err_ := s_.Impl.GetTimestamp(args_.Ctx)
		out_ := baseNetworkSocketWithCtxGetTimestampResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseNetworkSocketBindOrdinal:
		in_ := baseNetworkSocketWithCtxBindRequest{}
		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_ := baseNetworkSocketWithCtxBindResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseNetworkSocketConnectOrdinal:
		in_ := baseNetworkSocketWithCtxConnectRequest{}
		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_ := baseNetworkSocketWithCtxConnectResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseNetworkSocketDisconnectOrdinal:
		result, err_ := s_.Impl.Disconnect(args_.Ctx)
		out_ := baseNetworkSocketWithCtxDisconnectResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseNetworkSocketGetSockNameOrdinal:
		result, err_ := s_.Impl.GetSockName(args_.Ctx)
		out_ := baseNetworkSocketWithCtxGetSockNameResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseNetworkSocketGetPeerNameOrdinal:
		result, err_ := s_.Impl.GetPeerName(args_.Ctx)
		out_ := baseNetworkSocketWithCtxGetPeerNameResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseNetworkSocketShutdownOrdinal:
		in_ := baseNetworkSocketWithCtxShutdownRequest{}
		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_ := baseNetworkSocketWithCtxShutdownResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseNetworkSocketShutdown2Ordinal:
		in_ := baseNetworkSocketWithCtxShutdown2Request{}
		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_ := baseNetworkSocketWithCtxShutdown2Response{}
		out_.Result = result
		return &out_, true, err_
	case BaseNetworkSocketSetIpTypeOfServiceOrdinal:
		in_ := baseNetworkSocketWithCtxSetIpTypeOfServiceRequest{}
		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_ := baseNetworkSocketWithCtxSetIpTypeOfServiceResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseNetworkSocketGetIpTypeOfServiceOrdinal:
		result, err_ := s_.Impl.GetIpTypeOfService(args_.Ctx)
		out_ := baseNetworkSocketWithCtxGetIpTypeOfServiceResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseNetworkSocketSetIpTtlOrdinal:
		in_ := baseNetworkSocketWithCtxSetIpTtlRequest{}
		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_ := baseNetworkSocketWithCtxSetIpTtlResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseNetworkSocketGetIpTtlOrdinal:
		result, err_ := s_.Impl.GetIpTtl(args_.Ctx)
		out_ := baseNetworkSocketWithCtxGetIpTtlResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseNetworkSocketSetIpPacketInfoOrdinal:
		in_ := baseNetworkSocketWithCtxSetIpPacketInfoRequest{}
		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_ := baseNetworkSocketWithCtxSetIpPacketInfoResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseNetworkSocketGetIpPacketInfoOrdinal:
		result, err_ := s_.Impl.GetIpPacketInfo(args_.Ctx)
		out_ := baseNetworkSocketWithCtxGetIpPacketInfoResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseNetworkSocketSetIpReceiveTypeOfServiceOrdinal:
		in_ := baseNetworkSocketWithCtxSetIpReceiveTypeOfServiceRequest{}
		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_ := baseNetworkSocketWithCtxSetIpReceiveTypeOfServiceResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseNetworkSocketGetIpReceiveTypeOfServiceOrdinal:
		result, err_ := s_.Impl.GetIpReceiveTypeOfService(args_.Ctx)
		out_ := baseNetworkSocketWithCtxGetIpReceiveTypeOfServiceResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseNetworkSocketSetIpMulticastInterfaceOrdinal:
		in_ := baseNetworkSocketWithCtxSetIpMulticastInterfaceRequest{}
		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_ := baseNetworkSocketWithCtxSetIpMulticastInterfaceResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseNetworkSocketGetIpMulticastInterfaceOrdinal:
		result, err_ := s_.Impl.GetIpMulticastInterface(args_.Ctx)
		out_ := baseNetworkSocketWithCtxGetIpMulticastInterfaceResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseNetworkSocketSetIpMulticastTtlOrdinal:
		in_ := baseNetworkSocketWithCtxSetIpMulticastTtlRequest{}
		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_ := baseNetworkSocketWithCtxSetIpMulticastTtlResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseNetworkSocketGetIpMulticastTtlOrdinal:
		result, err_ := s_.Impl.GetIpMulticastTtl(args_.Ctx)
		out_ := baseNetworkSocketWithCtxGetIpMulticastTtlResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseNetworkSocketSetIpMulticastLoopbackOrdinal:
		in_ := baseNetworkSocketWithCtxSetIpMulticastLoopbackRequest{}
		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_ := baseNetworkSocketWithCtxSetIpMulticastLoopbackResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseNetworkSocketGetIpMulticastLoopbackOrdinal:
		result, err_ := s_.Impl.GetIpMulticastLoopback(args_.Ctx)
		out_ := baseNetworkSocketWithCtxGetIpMulticastLoopbackResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseNetworkSocketAddIpMembershipOrdinal:
		in_ := baseNetworkSocketWithCtxAddIpMembershipRequest{}
		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_ := baseNetworkSocketWithCtxAddIpMembershipResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseNetworkSocketDropIpMembershipOrdinal:
		in_ := baseNetworkSocketWithCtxDropIpMembershipRequest{}
		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_ := baseNetworkSocketWithCtxDropIpMembershipResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseNetworkSocketAddIpv6MembershipOrdinal:
		in_ := baseNetworkSocketWithCtxAddIpv6MembershipRequest{}
		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_ := baseNetworkSocketWithCtxAddIpv6MembershipResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseNetworkSocketDropIpv6MembershipOrdinal:
		in_ := baseNetworkSocketWithCtxDropIpv6MembershipRequest{}
		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_ := baseNetworkSocketWithCtxDropIpv6MembershipResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseNetworkSocketSetIpv6MulticastInterfaceOrdinal:
		in_ := baseNetworkSocketWithCtxSetIpv6MulticastInterfaceRequest{}
		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_ := baseNetworkSocketWithCtxSetIpv6MulticastInterfaceResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseNetworkSocketGetIpv6MulticastInterfaceOrdinal:
		result, err_ := s_.Impl.GetIpv6MulticastInterface(args_.Ctx)
		out_ := baseNetworkSocketWithCtxGetIpv6MulticastInterfaceResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseNetworkSocketSetIpv6MulticastHopsOrdinal:
		in_ := baseNetworkSocketWithCtxSetIpv6MulticastHopsRequest{}
		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_ := baseNetworkSocketWithCtxSetIpv6MulticastHopsResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseNetworkSocketGetIpv6MulticastHopsOrdinal:
		result, err_ := s_.Impl.GetIpv6MulticastHops(args_.Ctx)
		out_ := baseNetworkSocketWithCtxGetIpv6MulticastHopsResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseNetworkSocketSetIpv6MulticastLoopbackOrdinal:
		in_ := baseNetworkSocketWithCtxSetIpv6MulticastLoopbackRequest{}
		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_ := baseNetworkSocketWithCtxSetIpv6MulticastLoopbackResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseNetworkSocketGetIpv6MulticastLoopbackOrdinal:
		result, err_ := s_.Impl.GetIpv6MulticastLoopback(args_.Ctx)
		out_ := baseNetworkSocketWithCtxGetIpv6MulticastLoopbackResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseNetworkSocketSetIpv6OnlyOrdinal:
		in_ := baseNetworkSocketWithCtxSetIpv6OnlyRequest{}
		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_ := baseNetworkSocketWithCtxSetIpv6OnlyResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseNetworkSocketGetIpv6OnlyOrdinal:
		result, err_ := s_.Impl.GetIpv6Only(args_.Ctx)
		out_ := baseNetworkSocketWithCtxGetIpv6OnlyResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseNetworkSocketSetIpv6ReceiveTrafficClassOrdinal:
		in_ := baseNetworkSocketWithCtxSetIpv6ReceiveTrafficClassRequest{}
		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_ := baseNetworkSocketWithCtxSetIpv6ReceiveTrafficClassResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseNetworkSocketGetIpv6ReceiveTrafficClassOrdinal:
		result, err_ := s_.Impl.GetIpv6ReceiveTrafficClass(args_.Ctx)
		out_ := baseNetworkSocketWithCtxGetIpv6ReceiveTrafficClassResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseNetworkSocketSetIpv6TrafficClassOrdinal:
		in_ := baseNetworkSocketWithCtxSetIpv6TrafficClassRequest{}
		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_ := baseNetworkSocketWithCtxSetIpv6TrafficClassResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseNetworkSocketGetIpv6TrafficClassOrdinal:
		result, err_ := s_.Impl.GetIpv6TrafficClass(args_.Ctx)
		out_ := baseNetworkSocketWithCtxGetIpv6TrafficClassResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseNetworkSocketBaseSocketBindOrdinal:
		in_ := baseNetworkSocketWithCtxBaseSocketBindRequest{}
		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.BaseSocketBind(args_.Ctx, in_.Addr)
		out_ := baseNetworkSocketWithCtxBaseSocketBindResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseNetworkSocketBaseSocketConnectOrdinal:
		in_ := baseNetworkSocketWithCtxBaseSocketConnectRequest{}
		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.BaseSocketConnect(args_.Ctx, in_.Addr)
		out_ := baseNetworkSocketWithCtxBaseSocketConnectResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseNetworkSocketBaseSocketDisconnectOrdinal:
		result, err_ := s_.Impl.BaseSocketDisconnect(args_.Ctx)
		out_ := baseNetworkSocketWithCtxBaseSocketDisconnectResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseNetworkSocketBaseSocketGetSockNameOrdinal:
		result, err_ := s_.Impl.BaseSocketGetSockName(args_.Ctx)
		out_ := baseNetworkSocketWithCtxBaseSocketGetSockNameResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseNetworkSocketBaseSocketGetPeerNameOrdinal:
		result, err_ := s_.Impl.BaseSocketGetPeerName(args_.Ctx)
		out_ := baseNetworkSocketWithCtxBaseSocketGetPeerNameResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseNetworkSocketBaseSocketShutdownOrdinal:
		in_ := baseNetworkSocketWithCtxBaseSocketShutdownRequest{}
		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.BaseSocketShutdown(args_.Ctx, in_.Mode)
		out_ := baseNetworkSocketWithCtxBaseSocketShutdownResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseNetworkSocketBaseSocketShutdown2Ordinal:
		in_ := baseNetworkSocketWithCtxBaseSocketShutdown2Request{}
		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.BaseSocketShutdown2(args_.Ctx, in_.Mode)
		out_ := baseNetworkSocketWithCtxBaseSocketShutdown2Response{}
		out_.Result = result
		return &out_, true, err_
	case BaseNetworkSocketBaseSocketSetIpTypeOfServiceOrdinal:
		in_ := baseNetworkSocketWithCtxBaseSocketSetIpTypeOfServiceRequest{}
		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.BaseSocketSetIpTypeOfService(args_.Ctx, in_.Value)
		out_ := baseNetworkSocketWithCtxBaseSocketSetIpTypeOfServiceResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseNetworkSocketBaseSocketGetIpTypeOfServiceOrdinal:
		result, err_ := s_.Impl.BaseSocketGetIpTypeOfService(args_.Ctx)
		out_ := baseNetworkSocketWithCtxBaseSocketGetIpTypeOfServiceResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseNetworkSocketBaseSocketSetIpTtlOrdinal:
		in_ := baseNetworkSocketWithCtxBaseSocketSetIpTtlRequest{}
		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.BaseSocketSetIpTtl(args_.Ctx, in_.Value)
		out_ := baseNetworkSocketWithCtxBaseSocketSetIpTtlResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseNetworkSocketBaseSocketGetIpTtlOrdinal:
		result, err_ := s_.Impl.BaseSocketGetIpTtl(args_.Ctx)
		out_ := baseNetworkSocketWithCtxBaseSocketGetIpTtlResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseNetworkSocketBaseSocketSetIpPacketInfoOrdinal:
		in_ := baseNetworkSocketWithCtxBaseSocketSetIpPacketInfoRequest{}
		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.BaseSocketSetIpPacketInfo(args_.Ctx, in_.Value)
		out_ := baseNetworkSocketWithCtxBaseSocketSetIpPacketInfoResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseNetworkSocketBaseSocketGetIpPacketInfoOrdinal:
		result, err_ := s_.Impl.BaseSocketGetIpPacketInfo(args_.Ctx)
		out_ := baseNetworkSocketWithCtxBaseSocketGetIpPacketInfoResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseNetworkSocketBaseSocketSetIpReceiveTypeOfServiceOrdinal:
		in_ := baseNetworkSocketWithCtxBaseSocketSetIpReceiveTypeOfServiceRequest{}
		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.BaseSocketSetIpReceiveTypeOfService(args_.Ctx, in_.Value)
		out_ := baseNetworkSocketWithCtxBaseSocketSetIpReceiveTypeOfServiceResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseNetworkSocketBaseSocketGetIpReceiveTypeOfServiceOrdinal:
		result, err_ := s_.Impl.BaseSocketGetIpReceiveTypeOfService(args_.Ctx)
		out_ := baseNetworkSocketWithCtxBaseSocketGetIpReceiveTypeOfServiceResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseNetworkSocketBaseSocketSetIpMulticastInterfaceOrdinal:
		in_ := baseNetworkSocketWithCtxBaseSocketSetIpMulticastInterfaceRequest{}
		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.BaseSocketSetIpMulticastInterface(args_.Ctx, in_.Iface, in_.Address)
		out_ := baseNetworkSocketWithCtxBaseSocketSetIpMulticastInterfaceResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseNetworkSocketBaseSocketGetIpMulticastInterfaceOrdinal:
		result, err_ := s_.Impl.BaseSocketGetIpMulticastInterface(args_.Ctx)
		out_ := baseNetworkSocketWithCtxBaseSocketGetIpMulticastInterfaceResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseNetworkSocketBaseSocketSetIpMulticastTtlOrdinal:
		in_ := baseNetworkSocketWithCtxBaseSocketSetIpMulticastTtlRequest{}
		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.BaseSocketSetIpMulticastTtl(args_.Ctx, in_.Value)
		out_ := baseNetworkSocketWithCtxBaseSocketSetIpMulticastTtlResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseNetworkSocketBaseSocketGetIpMulticastTtlOrdinal:
		result, err_ := s_.Impl.BaseSocketGetIpMulticastTtl(args_.Ctx)
		out_ := baseNetworkSocketWithCtxBaseSocketGetIpMulticastTtlResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseNetworkSocketBaseSocketSetIpMulticastLoopbackOrdinal:
		in_ := baseNetworkSocketWithCtxBaseSocketSetIpMulticastLoopbackRequest{}
		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.BaseSocketSetIpMulticastLoopback(args_.Ctx, in_.Value)
		out_ := baseNetworkSocketWithCtxBaseSocketSetIpMulticastLoopbackResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseNetworkSocketBaseSocketGetIpMulticastLoopbackOrdinal:
		result, err_ := s_.Impl.BaseSocketGetIpMulticastLoopback(args_.Ctx)
		out_ := baseNetworkSocketWithCtxBaseSocketGetIpMulticastLoopbackResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseNetworkSocketBaseSocketAddIpMembershipOrdinal:
		in_ := baseNetworkSocketWithCtxBaseSocketAddIpMembershipRequest{}
		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.BaseSocketAddIpMembership(args_.Ctx, in_.Membership)
		out_ := baseNetworkSocketWithCtxBaseSocketAddIpMembershipResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseNetworkSocketBaseSocketDropIpMembershipOrdinal:
		in_ := baseNetworkSocketWithCtxBaseSocketDropIpMembershipRequest{}
		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.BaseSocketDropIpMembership(args_.Ctx, in_.Membership)
		out_ := baseNetworkSocketWithCtxBaseSocketDropIpMembershipResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseNetworkSocketBaseSocketAddIpv6MembershipOrdinal:
		in_ := baseNetworkSocketWithCtxBaseSocketAddIpv6MembershipRequest{}
		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.BaseSocketAddIpv6Membership(args_.Ctx, in_.Membership)
		out_ := baseNetworkSocketWithCtxBaseSocketAddIpv6MembershipResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseNetworkSocketBaseSocketDropIpv6MembershipOrdinal:
		in_ := baseNetworkSocketWithCtxBaseSocketDropIpv6MembershipRequest{}
		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.BaseSocketDropIpv6Membership(args_.Ctx, in_.Membership)
		out_ := baseNetworkSocketWithCtxBaseSocketDropIpv6MembershipResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseNetworkSocketBaseSocketSetIpv6MulticastInterfaceOrdinal:
		in_ := baseNetworkSocketWithCtxBaseSocketSetIpv6MulticastInterfaceRequest{}
		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.BaseSocketSetIpv6MulticastInterface(args_.Ctx, in_.Value)
		out_ := baseNetworkSocketWithCtxBaseSocketSetIpv6MulticastInterfaceResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseNetworkSocketBaseSocketGetIpv6MulticastInterfaceOrdinal:
		result, err_ := s_.Impl.BaseSocketGetIpv6MulticastInterface(args_.Ctx)
		out_ := baseNetworkSocketWithCtxBaseSocketGetIpv6MulticastInterfaceResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseNetworkSocketBaseSocketSetIpv6MulticastHopsOrdinal:
		in_ := baseNetworkSocketWithCtxBaseSocketSetIpv6MulticastHopsRequest{}
		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.BaseSocketSetIpv6MulticastHops(args_.Ctx, in_.Value)
		out_ := baseNetworkSocketWithCtxBaseSocketSetIpv6MulticastHopsResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseNetworkSocketBaseSocketGetIpv6MulticastHopsOrdinal:
		result, err_ := s_.Impl.BaseSocketGetIpv6MulticastHops(args_.Ctx)
		out_ := baseNetworkSocketWithCtxBaseSocketGetIpv6MulticastHopsResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseNetworkSocketBaseSocketSetIpv6MulticastLoopbackOrdinal:
		in_ := baseNetworkSocketWithCtxBaseSocketSetIpv6MulticastLoopbackRequest{}
		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.BaseSocketSetIpv6MulticastLoopback(args_.Ctx, in_.Value)
		out_ := baseNetworkSocketWithCtxBaseSocketSetIpv6MulticastLoopbackResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseNetworkSocketBaseSocketGetIpv6MulticastLoopbackOrdinal:
		result, err_ := s_.Impl.BaseSocketGetIpv6MulticastLoopback(args_.Ctx)
		out_ := baseNetworkSocketWithCtxBaseSocketGetIpv6MulticastLoopbackResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseNetworkSocketBaseSocketSetIpv6OnlyOrdinal:
		in_ := baseNetworkSocketWithCtxBaseSocketSetIpv6OnlyRequest{}
		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.BaseSocketSetIpv6Only(args_.Ctx, in_.Value)
		out_ := baseNetworkSocketWithCtxBaseSocketSetIpv6OnlyResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseNetworkSocketBaseSocketGetIpv6OnlyOrdinal:
		result, err_ := s_.Impl.BaseSocketGetIpv6Only(args_.Ctx)
		out_ := baseNetworkSocketWithCtxBaseSocketGetIpv6OnlyResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseNetworkSocketBaseSocketSetIpv6ReceiveTrafficClassOrdinal:
		in_ := baseNetworkSocketWithCtxBaseSocketSetIpv6ReceiveTrafficClassRequest{}
		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.BaseSocketSetIpv6ReceiveTrafficClass(args_.Ctx, in_.Value)
		out_ := baseNetworkSocketWithCtxBaseSocketSetIpv6ReceiveTrafficClassResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseNetworkSocketBaseSocketGetIpv6ReceiveTrafficClassOrdinal:
		result, err_ := s_.Impl.BaseSocketGetIpv6ReceiveTrafficClass(args_.Ctx)
		out_ := baseNetworkSocketWithCtxBaseSocketGetIpv6ReceiveTrafficClassResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseNetworkSocketBaseSocketSetIpv6TrafficClassOrdinal:
		in_ := baseNetworkSocketWithCtxBaseSocketSetIpv6TrafficClassRequest{}
		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.BaseSocketSetIpv6TrafficClass(args_.Ctx, in_.Value)
		out_ := baseNetworkSocketWithCtxBaseSocketSetIpv6TrafficClassResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseNetworkSocketBaseSocketGetIpv6TrafficClassOrdinal:
		result, err_ := s_.Impl.BaseSocketGetIpv6TrafficClass(args_.Ctx)
		out_ := baseNetworkSocketWithCtxBaseSocketGetIpv6TrafficClassResponse{}
		out_.Result = result
		return &out_, true, err_
	}
	return nil, false, _bindings.ErrUnknownOrdinal
}

type BaseNetworkSocketEventProxy _bindings.ChannelProxy

func (p *BaseNetworkSocketEventProxy) OnOpen(s int32, info *fuchsiaio.NodeInfo) error {
	event_ := &baseNetworkSocketWithCtxOnOpenResponse{
		S:    s,
		Info: info,
	}
	return ((*_bindings.ChannelProxy)(p)).Send(BaseNetworkSocketOnOpenOrdinal, 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
	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
	DatagramSocketBindOrdinal                                 uint64 = 0x4bc6400ae92125d
	DatagramSocketConnectOrdinal                              uint64 = 0x5f05f19bfdd38871
	DatagramSocketDisconnectOrdinal                           uint64 = 0x74e63b91f7b29b2
	DatagramSocketGetSockNameOrdinal                          uint64 = 0x475f23f84a1a4f85
	DatagramSocketGetPeerNameOrdinal                          uint64 = 0x1ffecf4bd5b6432e
	DatagramSocketShutdownOrdinal                             uint64 = 0x247f38b6db68c336
	DatagramSocketShutdown2Ordinal                            uint64 = 0x421055d9d50e4f48
	DatagramSocketSetIpTypeOfServiceOrdinal                   uint64 = 0x995c600475b6d46
	DatagramSocketGetIpTypeOfServiceOrdinal                   uint64 = 0x3814a04259f75fcb
	DatagramSocketSetIpTtlOrdinal                             uint64 = 0x29e2424b433ae1ef
	DatagramSocketGetIpTtlOrdinal                             uint64 = 0x47e47fa1f24da471
	DatagramSocketSetIpPacketInfoOrdinal                      uint64 = 0x392d16bee20c0e16
	DatagramSocketGetIpPacketInfoOrdinal                      uint64 = 0x54b505f242280740
	DatagramSocketSetIpReceiveTypeOfServiceOrdinal            uint64 = 0x6c4f6714995f84ef
	DatagramSocketGetIpReceiveTypeOfServiceOrdinal            uint64 = 0x4158ba7dc2795960
	DatagramSocketSetIpMulticastInterfaceOrdinal              uint64 = 0x752fbfa9b12befe
	DatagramSocketGetIpMulticastInterfaceOrdinal              uint64 = 0x320bd14c4df046c4
	DatagramSocketSetIpMulticastTtlOrdinal                    uint64 = 0x63134d53772916a1
	DatagramSocketGetIpMulticastTtlOrdinal                    uint64 = 0x4665cd378f39e1a
	DatagramSocketSetIpMulticastLoopbackOrdinal               uint64 = 0x20c55c11f00943ea
	DatagramSocketGetIpMulticastLoopbackOrdinal               uint64 = 0x3b6b26ff558298f2
	DatagramSocketAddIpMembershipOrdinal                      uint64 = 0x76bc7df115a3b4d0
	DatagramSocketDropIpMembershipOrdinal                     uint64 = 0x2888f3099188d03
	DatagramSocketAddIpv6MembershipOrdinal                    uint64 = 0x7c94727acb4ea4b3
	DatagramSocketDropIpv6MembershipOrdinal                   uint64 = 0x42104c70ccaba304
	DatagramSocketSetIpv6MulticastInterfaceOrdinal            uint64 = 0x135f76db3774ab3b
	DatagramSocketGetIpv6MulticastInterfaceOrdinal            uint64 = 0x1f26fcdd348f1882
	DatagramSocketSetIpv6MulticastHopsOrdinal                 uint64 = 0x25b9cd4d181f82c1
	DatagramSocketGetIpv6MulticastHopsOrdinal                 uint64 = 0x52916948a365012a
	DatagramSocketSetIpv6MulticastLoopbackOrdinal             uint64 = 0x55701c409ff41b40
	DatagramSocketGetIpv6MulticastLoopbackOrdinal             uint64 = 0x4415b701fde319c3
	DatagramSocketSetIpv6OnlyOrdinal                          uint64 = 0x4873f1364758cbba
	DatagramSocketGetIpv6OnlyOrdinal                          uint64 = 0x4aa3340a1a26b89c
	DatagramSocketSetIpv6ReceiveTrafficClassOrdinal           uint64 = 0x58f07c8788d099a0
	DatagramSocketGetIpv6ReceiveTrafficClassOrdinal           uint64 = 0x2e334df1da553ffa
	DatagramSocketSetIpv6TrafficClassOrdinal                  uint64 = 0x6af077800c5a0b4f
	DatagramSocketGetIpv6TrafficClassOrdinal                  uint64 = 0x6baf6eed8fc2f04
	DatagramSocketBaseSocketBindOrdinal                       uint64 = 0xf8457e6b05e15bc
	DatagramSocketBaseSocketConnectOrdinal                    uint64 = 0x17abeee0b9843bb1
	DatagramSocketBaseSocketDisconnectOrdinal                 uint64 = 0x20eaedba2e0f70a4
	DatagramSocketBaseSocketGetSockNameOrdinal                uint64 = 0x41a618ef19a91f9d
	DatagramSocketBaseSocketGetPeerNameOrdinal                uint64 = 0x4009d08a4beb5e95
	DatagramSocketBaseSocketShutdownOrdinal                   uint64 = 0x382080a1d15b2111
	DatagramSocketBaseSocketShutdown2Ordinal                  uint64 = 0x57d3458f9754763b
	DatagramSocketBaseSocketSetIpTypeOfServiceOrdinal         uint64 = 0x559849ba9574834a
	DatagramSocketBaseSocketGetIpTypeOfServiceOrdinal         uint64 = 0x2740d6bfa379deb1
	DatagramSocketBaseSocketSetIpTtlOrdinal                   uint64 = 0x67395f7176d7918e
	DatagramSocketBaseSocketGetIpTtlOrdinal                   uint64 = 0x789d5ddfe26b97ac
	DatagramSocketBaseSocketSetIpPacketInfoOrdinal            uint64 = 0x3e02030a2fd13c03
	DatagramSocketBaseSocketGetIpPacketInfoOrdinal            uint64 = 0x176f008d5a0dab15
	DatagramSocketBaseSocketSetIpReceiveTypeOfServiceOrdinal  uint64 = 0x17148064e563dde5
	DatagramSocketBaseSocketGetIpReceiveTypeOfServiceOrdinal  uint64 = 0x26cc26653b0fa460
	DatagramSocketBaseSocketSetIpMulticastInterfaceOrdinal    uint64 = 0x6566fdb7061bbcf8
	DatagramSocketBaseSocketGetIpMulticastInterfaceOrdinal    uint64 = 0x44415752b16ff024
	DatagramSocketBaseSocketSetIpMulticastTtlOrdinal          uint64 = 0x7d1a477776ba00d3
	DatagramSocketBaseSocketGetIpMulticastTtlOrdinal          uint64 = 0x17cbd4bd9246fc40
	DatagramSocketBaseSocketSetIpMulticastLoopbackOrdinal     uint64 = 0x2a56b32f8f02369
	DatagramSocketBaseSocketGetIpMulticastLoopbackOrdinal     uint64 = 0x27b16d7883c08ca8
	DatagramSocketBaseSocketAddIpMembershipOrdinal            uint64 = 0x39a4eda6580147a0
	DatagramSocketBaseSocketDropIpMembershipOrdinal           uint64 = 0x6d16e8fbaf496254
	DatagramSocketBaseSocketAddIpv6MembershipOrdinal          uint64 = 0x231556bfce3194c1
	DatagramSocketBaseSocketDropIpv6MembershipOrdinal         uint64 = 0x629c12db293444c0
	DatagramSocketBaseSocketSetIpv6MulticastInterfaceOrdinal  uint64 = 0x5d2a568e67b54234
	DatagramSocketBaseSocketGetIpv6MulticastInterfaceOrdinal  uint64 = 0x7b8f38fe354f32bc
	DatagramSocketBaseSocketSetIpv6MulticastHopsOrdinal       uint64 = 0x2b2167d12c8a495d
	DatagramSocketBaseSocketGetIpv6MulticastHopsOrdinal       uint64 = 0x51a3c8257b1a2745
	DatagramSocketBaseSocketSetIpv6MulticastLoopbackOrdinal   uint64 = 0x97706949c4163b7
	DatagramSocketBaseSocketGetIpv6MulticastLoopbackOrdinal   uint64 = 0x78d6544e48794935
	DatagramSocketBaseSocketSetIpv6OnlyOrdinal                uint64 = 0x1d87ce5c02d8bcb2
	DatagramSocketBaseSocketGetIpv6OnlyOrdinal                uint64 = 0x25d6755dbe2e9c7e
	DatagramSocketBaseSocketSetIpv6ReceiveTrafficClassOrdinal uint64 = 0x53b93b71c9431fe4
	DatagramSocketBaseSocketGetIpv6ReceiveTrafficClassOrdinal uint64 = 0x1c8433af11cd4596
	DatagramSocketBaseSocketSetIpv6TrafficClassOrdinal        uint64 = 0x32da0ca485fad782
	DatagramSocketBaseSocketGetIpv6TrafficClassOrdinal        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_
}

// 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_
}

// Sets the local address used for the socket.
func (p *DatagramSocketWithCtxInterface) Bind(ctx_ _bindings.Context, addr fuchsianet.SocketAddress) (BaseNetworkSocketBindResult, 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) (BaseNetworkSocketConnectResult, 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) (BaseNetworkSocketDisconnectResult, 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) (BaseNetworkSocketGetSockNameResult, 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) (BaseNetworkSocketGetPeerNameResult, 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) (BaseNetworkSocketShutdownResult, 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) (BaseNetworkSocketShutdown2Result, error) {
	req_ := &datagramSocketWithCtxShutdown2Request{
		Mode: mode,
	}
	resp_ := &datagramSocketWithCtxShutdown2Response{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketShutdown2Ordinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_IP` -> `IP_TOS`.
func (p *DatagramSocketWithCtxInterface) SetIpTypeOfService(ctx_ _bindings.Context, value uint8) (BaseNetworkSocketSetIpTypeOfServiceResult, 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) (BaseNetworkSocketGetIpTypeOfServiceResult, 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) (BaseNetworkSocketSetIpTtlResult, 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) (BaseNetworkSocketGetIpTtlResult, 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) (BaseNetworkSocketSetIpPacketInfoResult, 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) (BaseNetworkSocketGetIpPacketInfoResult, 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) (BaseNetworkSocketSetIpReceiveTypeOfServiceResult, 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) (BaseNetworkSocketGetIpReceiveTypeOfServiceResult, 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) (BaseNetworkSocketSetIpMulticastInterfaceResult, 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) (BaseNetworkSocketGetIpMulticastInterfaceResult, 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) (BaseNetworkSocketSetIpMulticastTtlResult, 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) (BaseNetworkSocketGetIpMulticastTtlResult, 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) (BaseNetworkSocketSetIpMulticastLoopbackResult, 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) (BaseNetworkSocketGetIpMulticastLoopbackResult, 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) (BaseNetworkSocketAddIpMembershipResult, 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) (BaseNetworkSocketDropIpMembershipResult, 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) (BaseNetworkSocketAddIpv6MembershipResult, 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) (BaseNetworkSocketDropIpv6MembershipResult, 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) (BaseNetworkSocketSetIpv6MulticastInterfaceResult, 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) (BaseNetworkSocketGetIpv6MulticastInterfaceResult, 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) (BaseNetworkSocketSetIpv6MulticastHopsResult, 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) (BaseNetworkSocketGetIpv6MulticastHopsResult, 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) (BaseNetworkSocketSetIpv6MulticastLoopbackResult, 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) (BaseNetworkSocketGetIpv6MulticastLoopbackResult, 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) (BaseNetworkSocketSetIpv6OnlyResult, 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) (BaseNetworkSocketGetIpv6OnlyResult, 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) (BaseNetworkSocketSetIpv6ReceiveTrafficClassResult, 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) (BaseNetworkSocketGetIpv6ReceiveTrafficClassResult, 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) (BaseNetworkSocketSetIpv6TrafficClassResult, 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) (BaseNetworkSocketGetIpv6TrafficClassResult, error) {
	var req_ _bindings.Message
	resp_ := &datagramSocketWithCtxGetIpv6TrafficClassResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketGetIpv6TrafficClassOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *DatagramSocketWithCtxInterface) BaseSocketBind(ctx_ _bindings.Context, addr fuchsianet.SocketAddress) (BaseNetworkSocketBaseSocketBindResult, error) {
	req_ := &datagramSocketWithCtxBaseSocketBindRequest{
		Addr: addr,
	}
	resp_ := &datagramSocketWithCtxBaseSocketBindResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketBaseSocketBindOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *DatagramSocketWithCtxInterface) BaseSocketConnect(ctx_ _bindings.Context, addr fuchsianet.SocketAddress) (BaseNetworkSocketBaseSocketConnectResult, error) {
	req_ := &datagramSocketWithCtxBaseSocketConnectRequest{
		Addr: addr,
	}
	resp_ := &datagramSocketWithCtxBaseSocketConnectResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketBaseSocketConnectOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *DatagramSocketWithCtxInterface) BaseSocketDisconnect(ctx_ _bindings.Context) (BaseNetworkSocketBaseSocketDisconnectResult, error) {
	var req_ _bindings.Message
	resp_ := &datagramSocketWithCtxBaseSocketDisconnectResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketBaseSocketDisconnectOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *DatagramSocketWithCtxInterface) BaseSocketGetSockName(ctx_ _bindings.Context) (BaseNetworkSocketBaseSocketGetSockNameResult, error) {
	var req_ _bindings.Message
	resp_ := &datagramSocketWithCtxBaseSocketGetSockNameResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketBaseSocketGetSockNameOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *DatagramSocketWithCtxInterface) BaseSocketGetPeerName(ctx_ _bindings.Context) (BaseNetworkSocketBaseSocketGetPeerNameResult, error) {
	var req_ _bindings.Message
	resp_ := &datagramSocketWithCtxBaseSocketGetPeerNameResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketBaseSocketGetPeerNameOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *DatagramSocketWithCtxInterface) BaseSocketShutdown(ctx_ _bindings.Context, mode ShutdownMode) (BaseNetworkSocketBaseSocketShutdownResult, error) {
	req_ := &datagramSocketWithCtxBaseSocketShutdownRequest{
		Mode: mode,
	}
	resp_ := &datagramSocketWithCtxBaseSocketShutdownResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketBaseSocketShutdownOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *DatagramSocketWithCtxInterface) BaseSocketShutdown2(ctx_ _bindings.Context, mode ShutdownMode) (BaseNetworkSocketBaseSocketShutdown2Result, error) {
	req_ := &datagramSocketWithCtxBaseSocketShutdown2Request{
		Mode: mode,
	}
	resp_ := &datagramSocketWithCtxBaseSocketShutdown2Response{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketBaseSocketShutdown2Ordinal, req_, resp_)
	return resp_.Result, err_
}

func (p *DatagramSocketWithCtxInterface) BaseSocketSetIpTypeOfService(ctx_ _bindings.Context, value uint8) (BaseNetworkSocketBaseSocketSetIpTypeOfServiceResult, error) {
	req_ := &datagramSocketWithCtxBaseSocketSetIpTypeOfServiceRequest{
		Value: value,
	}
	resp_ := &datagramSocketWithCtxBaseSocketSetIpTypeOfServiceResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketBaseSocketSetIpTypeOfServiceOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *DatagramSocketWithCtxInterface) BaseSocketGetIpTypeOfService(ctx_ _bindings.Context) (BaseNetworkSocketBaseSocketGetIpTypeOfServiceResult, error) {
	var req_ _bindings.Message
	resp_ := &datagramSocketWithCtxBaseSocketGetIpTypeOfServiceResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketBaseSocketGetIpTypeOfServiceOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *DatagramSocketWithCtxInterface) BaseSocketSetIpTtl(ctx_ _bindings.Context, value OptionalUint8) (BaseNetworkSocketBaseSocketSetIpTtlResult, error) {
	req_ := &datagramSocketWithCtxBaseSocketSetIpTtlRequest{
		Value: value,
	}
	resp_ := &datagramSocketWithCtxBaseSocketSetIpTtlResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketBaseSocketSetIpTtlOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *DatagramSocketWithCtxInterface) BaseSocketGetIpTtl(ctx_ _bindings.Context) (BaseNetworkSocketBaseSocketGetIpTtlResult, error) {
	var req_ _bindings.Message
	resp_ := &datagramSocketWithCtxBaseSocketGetIpTtlResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketBaseSocketGetIpTtlOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *DatagramSocketWithCtxInterface) BaseSocketSetIpPacketInfo(ctx_ _bindings.Context, value bool) (BaseNetworkSocketBaseSocketSetIpPacketInfoResult, error) {
	req_ := &datagramSocketWithCtxBaseSocketSetIpPacketInfoRequest{
		Value: value,
	}
	resp_ := &datagramSocketWithCtxBaseSocketSetIpPacketInfoResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketBaseSocketSetIpPacketInfoOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *DatagramSocketWithCtxInterface) BaseSocketGetIpPacketInfo(ctx_ _bindings.Context) (BaseNetworkSocketBaseSocketGetIpPacketInfoResult, error) {
	var req_ _bindings.Message
	resp_ := &datagramSocketWithCtxBaseSocketGetIpPacketInfoResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketBaseSocketGetIpPacketInfoOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *DatagramSocketWithCtxInterface) BaseSocketSetIpReceiveTypeOfService(ctx_ _bindings.Context, value bool) (BaseNetworkSocketBaseSocketSetIpReceiveTypeOfServiceResult, error) {
	req_ := &datagramSocketWithCtxBaseSocketSetIpReceiveTypeOfServiceRequest{
		Value: value,
	}
	resp_ := &datagramSocketWithCtxBaseSocketSetIpReceiveTypeOfServiceResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketBaseSocketSetIpReceiveTypeOfServiceOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *DatagramSocketWithCtxInterface) BaseSocketGetIpReceiveTypeOfService(ctx_ _bindings.Context) (BaseNetworkSocketBaseSocketGetIpReceiveTypeOfServiceResult, error) {
	var req_ _bindings.Message
	resp_ := &datagramSocketWithCtxBaseSocketGetIpReceiveTypeOfServiceResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketBaseSocketGetIpReceiveTypeOfServiceOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *DatagramSocketWithCtxInterface) BaseSocketSetIpMulticastInterface(ctx_ _bindings.Context, iface uint64, address fuchsianet.Ipv4Address) (BaseNetworkSocketBaseSocketSetIpMulticastInterfaceResult, error) {
	req_ := &datagramSocketWithCtxBaseSocketSetIpMulticastInterfaceRequest{
		Iface:   iface,
		Address: address,
	}
	resp_ := &datagramSocketWithCtxBaseSocketSetIpMulticastInterfaceResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketBaseSocketSetIpMulticastInterfaceOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *DatagramSocketWithCtxInterface) BaseSocketGetIpMulticastInterface(ctx_ _bindings.Context) (BaseNetworkSocketBaseSocketGetIpMulticastInterfaceResult, error) {
	var req_ _bindings.Message
	resp_ := &datagramSocketWithCtxBaseSocketGetIpMulticastInterfaceResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketBaseSocketGetIpMulticastInterfaceOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *DatagramSocketWithCtxInterface) BaseSocketSetIpMulticastTtl(ctx_ _bindings.Context, value OptionalUint8) (BaseNetworkSocketBaseSocketSetIpMulticastTtlResult, error) {
	req_ := &datagramSocketWithCtxBaseSocketSetIpMulticastTtlRequest{
		Value: value,
	}
	resp_ := &datagramSocketWithCtxBaseSocketSetIpMulticastTtlResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketBaseSocketSetIpMulticastTtlOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *DatagramSocketWithCtxInterface) BaseSocketGetIpMulticastTtl(ctx_ _bindings.Context) (BaseNetworkSocketBaseSocketGetIpMulticastTtlResult, error) {
	var req_ _bindings.Message
	resp_ := &datagramSocketWithCtxBaseSocketGetIpMulticastTtlResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketBaseSocketGetIpMulticastTtlOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *DatagramSocketWithCtxInterface) BaseSocketSetIpMulticastLoopback(ctx_ _bindings.Context, value bool) (BaseNetworkSocketBaseSocketSetIpMulticastLoopbackResult, error) {
	req_ := &datagramSocketWithCtxBaseSocketSetIpMulticastLoopbackRequest{
		Value: value,
	}
	resp_ := &datagramSocketWithCtxBaseSocketSetIpMulticastLoopbackResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketBaseSocketSetIpMulticastLoopbackOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *DatagramSocketWithCtxInterface) BaseSocketGetIpMulticastLoopback(ctx_ _bindings.Context) (BaseNetworkSocketBaseSocketGetIpMulticastLoopbackResult, error) {
	var req_ _bindings.Message
	resp_ := &datagramSocketWithCtxBaseSocketGetIpMulticastLoopbackResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketBaseSocketGetIpMulticastLoopbackOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *DatagramSocketWithCtxInterface) BaseSocketAddIpMembership(ctx_ _bindings.Context, membership IpMulticastMembership) (BaseNetworkSocketBaseSocketAddIpMembershipResult, error) {
	req_ := &datagramSocketWithCtxBaseSocketAddIpMembershipRequest{
		Membership: membership,
	}
	resp_ := &datagramSocketWithCtxBaseSocketAddIpMembershipResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketBaseSocketAddIpMembershipOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *DatagramSocketWithCtxInterface) BaseSocketDropIpMembership(ctx_ _bindings.Context, membership IpMulticastMembership) (BaseNetworkSocketBaseSocketDropIpMembershipResult, error) {
	req_ := &datagramSocketWithCtxBaseSocketDropIpMembershipRequest{
		Membership: membership,
	}
	resp_ := &datagramSocketWithCtxBaseSocketDropIpMembershipResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketBaseSocketDropIpMembershipOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *DatagramSocketWithCtxInterface) BaseSocketAddIpv6Membership(ctx_ _bindings.Context, membership Ipv6MulticastMembership) (BaseNetworkSocketBaseSocketAddIpv6MembershipResult, error) {
	req_ := &datagramSocketWithCtxBaseSocketAddIpv6MembershipRequest{
		Membership: membership,
	}
	resp_ := &datagramSocketWithCtxBaseSocketAddIpv6MembershipResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketBaseSocketAddIpv6MembershipOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *DatagramSocketWithCtxInterface) BaseSocketDropIpv6Membership(ctx_ _bindings.Context, membership Ipv6MulticastMembership) (BaseNetworkSocketBaseSocketDropIpv6MembershipResult, error) {
	req_ := &datagramSocketWithCtxBaseSocketDropIpv6MembershipRequest{
		Membership: membership,
	}
	resp_ := &datagramSocketWithCtxBaseSocketDropIpv6MembershipResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketBaseSocketDropIpv6MembershipOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *DatagramSocketWithCtxInterface) BaseSocketSetIpv6MulticastInterface(ctx_ _bindings.Context, value uint64) (BaseNetworkSocketBaseSocketSetIpv6MulticastInterfaceResult, error) {
	req_ := &datagramSocketWithCtxBaseSocketSetIpv6MulticastInterfaceRequest{
		Value: value,
	}
	resp_ := &datagramSocketWithCtxBaseSocketSetIpv6MulticastInterfaceResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketBaseSocketSetIpv6MulticastInterfaceOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *DatagramSocketWithCtxInterface) BaseSocketGetIpv6MulticastInterface(ctx_ _bindings.Context) (BaseNetworkSocketBaseSocketGetIpv6MulticastInterfaceResult, error) {
	var req_ _bindings.Message
	resp_ := &datagramSocketWithCtxBaseSocketGetIpv6MulticastInterfaceResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketBaseSocketGetIpv6MulticastInterfaceOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *DatagramSocketWithCtxInterface) BaseSocketSetIpv6MulticastHops(ctx_ _bindings.Context, value OptionalUint8) (BaseNetworkSocketBaseSocketSetIpv6MulticastHopsResult, error) {
	req_ := &datagramSocketWithCtxBaseSocketSetIpv6MulticastHopsRequest{
		Value: value,
	}
	resp_ := &datagramSocketWithCtxBaseSocketSetIpv6MulticastHopsResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketBaseSocketSetIpv6MulticastHopsOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *DatagramSocketWithCtxInterface) BaseSocketGetIpv6MulticastHops(ctx_ _bindings.Context) (BaseNetworkSocketBaseSocketGetIpv6MulticastHopsResult, error) {
	var req_ _bindings.Message
	resp_ := &datagramSocketWithCtxBaseSocketGetIpv6MulticastHopsResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketBaseSocketGetIpv6MulticastHopsOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *DatagramSocketWithCtxInterface) BaseSocketSetIpv6MulticastLoopback(ctx_ _bindings.Context, value bool) (BaseNetworkSocketBaseSocketSetIpv6MulticastLoopbackResult, error) {
	req_ := &datagramSocketWithCtxBaseSocketSetIpv6MulticastLoopbackRequest{
		Value: value,
	}
	resp_ := &datagramSocketWithCtxBaseSocketSetIpv6MulticastLoopbackResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketBaseSocketSetIpv6MulticastLoopbackOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *DatagramSocketWithCtxInterface) BaseSocketGetIpv6MulticastLoopback(ctx_ _bindings.Context) (BaseNetworkSocketBaseSocketGetIpv6MulticastLoopbackResult, error) {
	var req_ _bindings.Message
	resp_ := &datagramSocketWithCtxBaseSocketGetIpv6MulticastLoopbackResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketBaseSocketGetIpv6MulticastLoopbackOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *DatagramSocketWithCtxInterface) BaseSocketSetIpv6Only(ctx_ _bindings.Context, value bool) (BaseNetworkSocketBaseSocketSetIpv6OnlyResult, error) {
	req_ := &datagramSocketWithCtxBaseSocketSetIpv6OnlyRequest{
		Value: value,
	}
	resp_ := &datagramSocketWithCtxBaseSocketSetIpv6OnlyResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketBaseSocketSetIpv6OnlyOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *DatagramSocketWithCtxInterface) BaseSocketGetIpv6Only(ctx_ _bindings.Context) (BaseNetworkSocketBaseSocketGetIpv6OnlyResult, error) {
	var req_ _bindings.Message
	resp_ := &datagramSocketWithCtxBaseSocketGetIpv6OnlyResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketBaseSocketGetIpv6OnlyOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *DatagramSocketWithCtxInterface) BaseSocketSetIpv6ReceiveTrafficClass(ctx_ _bindings.Context, value bool) (BaseNetworkSocketBaseSocketSetIpv6ReceiveTrafficClassResult, error) {
	req_ := &datagramSocketWithCtxBaseSocketSetIpv6ReceiveTrafficClassRequest{
		Value: value,
	}
	resp_ := &datagramSocketWithCtxBaseSocketSetIpv6ReceiveTrafficClassResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketBaseSocketSetIpv6ReceiveTrafficClassOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *DatagramSocketWithCtxInterface) BaseSocketGetIpv6ReceiveTrafficClass(ctx_ _bindings.Context) (BaseNetworkSocketBaseSocketGetIpv6ReceiveTrafficClassResult, error) {
	var req_ _bindings.Message
	resp_ := &datagramSocketWithCtxBaseSocketGetIpv6ReceiveTrafficClassResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketBaseSocketGetIpv6ReceiveTrafficClassOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *DatagramSocketWithCtxInterface) BaseSocketSetIpv6TrafficClass(ctx_ _bindings.Context, value OptionalUint8) (BaseNetworkSocketBaseSocketSetIpv6TrafficClassResult, error) {
	req_ := &datagramSocketWithCtxBaseSocketSetIpv6TrafficClassRequest{
		Value: value,
	}
	resp_ := &datagramSocketWithCtxBaseSocketSetIpv6TrafficClassResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketBaseSocketSetIpv6TrafficClassOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *DatagramSocketWithCtxInterface) BaseSocketGetIpv6TrafficClass(ctx_ _bindings.Context) (BaseNetworkSocketBaseSocketGetIpv6TrafficClassResult, error) {
	var req_ _bindings.Message
	resp_ := &datagramSocketWithCtxBaseSocketGetIpv6TrafficClassResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketBaseSocketGetIpv6TrafficClassOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Receives a message from the socket.
//
// + request `want_addr` request message's source address information to be
//   returned.
// + request `data_len` the maximum allowed length of the response data
//   buffer.
// + request `want_control` request ancillary data to be returned.
// + request `flags` flags for the receive request.
// - response `addr` the message's source address information, if requested.
// - response `data` the message.
// - response `control` control messages, if requested.
// - response `truncated` indicates whether or not the returned message was
//   truncated.
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.
//
// + request `addr` the address to send the message to. If unset, will send
//   to the connected peer.
// + request `data` the message.
// + request `control` ancillary data.
// + request `flags` flags for the send request.
// - response `len` the number of bytes sent.
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.
//
// - response `domain` the socket's associated domain.
// - response `proto` the socket's associated protocol.
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.
//
// *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 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)
	// 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)
	// Sets the local address used for the socket.
	Bind(ctx_ _bindings.Context, addr fuchsianet.SocketAddress) (BaseNetworkSocketBindResult, error)
	// Initiates a connection to a remote address.
	Connect(ctx_ _bindings.Context, addr fuchsianet.SocketAddress) (BaseNetworkSocketConnectResult, error)
	// Clears connection information from this socket.
	Disconnect(ctx_ _bindings.Context) (BaseNetworkSocketDisconnectResult, error)
	// Retrieves the local socket address.
	GetSockName(ctx_ _bindings.Context) (BaseNetworkSocketGetSockNameResult, error)
	// Retrieves the remote socket address.
	GetPeerName(ctx_ _bindings.Context) (BaseNetworkSocketGetPeerNameResult, error)
	// Shuts down part of the socket.
	Shutdown(ctx_ _bindings.Context, mode ShutdownMode) (BaseNetworkSocketShutdownResult, error)
	Shutdown2(ctx_ _bindings.Context, mode ShutdownMode) (BaseNetworkSocketShutdown2Result, error)
	// Set `SOL_IP` -> `IP_TOS`.
	SetIpTypeOfService(ctx_ _bindings.Context, value uint8) (BaseNetworkSocketSetIpTypeOfServiceResult, error)
	// Get `SOL_IP` -> `IP_TOS`.
	GetIpTypeOfService(ctx_ _bindings.Context) (BaseNetworkSocketGetIpTypeOfServiceResult, error)
	// Set `SOL_IP` -> `IP_TTL`.
	SetIpTtl(ctx_ _bindings.Context, value OptionalUint8) (BaseNetworkSocketSetIpTtlResult, error)
	// Get `SOL_IP` -> `IP_TTL`.
	GetIpTtl(ctx_ _bindings.Context) (BaseNetworkSocketGetIpTtlResult, error)
	// Set `SOL_IP` -> `IP_PKTINFO`.
	SetIpPacketInfo(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpPacketInfoResult, error)
	// Get `SOL_IP` -> `IP_PKTINFO`.
	GetIpPacketInfo(ctx_ _bindings.Context) (BaseNetworkSocketGetIpPacketInfoResult, error)
	// Set `SOL_IP` -> `IP_RECVTOS`.
	SetIpReceiveTypeOfService(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpReceiveTypeOfServiceResult, error)
	// Get `SOL_IP` -> `IP_RECVTOS`.
	GetIpReceiveTypeOfService(ctx_ _bindings.Context) (BaseNetworkSocketGetIpReceiveTypeOfServiceResult, error)
	// Set `SOL_IP` -> `IP_MULTICAST_IF`.
	SetIpMulticastInterface(ctx_ _bindings.Context, iface uint64, address fuchsianet.Ipv4Address) (BaseNetworkSocketSetIpMulticastInterfaceResult, error)
	// Get `SOL_IP` -> `IP_MULTICAST_IF`.
	GetIpMulticastInterface(ctx_ _bindings.Context) (BaseNetworkSocketGetIpMulticastInterfaceResult, error)
	// Set `SOL_IP` -> `IP_MULTICAST_TTL`.
	SetIpMulticastTtl(ctx_ _bindings.Context, value OptionalUint8) (BaseNetworkSocketSetIpMulticastTtlResult, error)
	// Get `SOL_IP` -> `IP_MULTICAST_TTL`.
	GetIpMulticastTtl(ctx_ _bindings.Context) (BaseNetworkSocketGetIpMulticastTtlResult, error)
	// Set `SOL_IP` -> `IP_MULTICAST_LOOP`.
	SetIpMulticastLoopback(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpMulticastLoopbackResult, error)
	// Get `SOL_IP` -> `IP_MULTICAST_LOOP`.
	GetIpMulticastLoopback(ctx_ _bindings.Context) (BaseNetworkSocketGetIpMulticastLoopbackResult, error)
	// Set `SOL_IP` -> `IP_ADD_MEMBERSHIP`
	AddIpMembership(ctx_ _bindings.Context, membership IpMulticastMembership) (BaseNetworkSocketAddIpMembershipResult, error)
	// Set `SOL_IP` -> `IP_DROP_MEMBERSHIP`
	DropIpMembership(ctx_ _bindings.Context, membership IpMulticastMembership) (BaseNetworkSocketDropIpMembershipResult, error)
	// Set `SOL_IPV6` -> `IPV6_ADD_MEMBERSHIP`.
	AddIpv6Membership(ctx_ _bindings.Context, membership Ipv6MulticastMembership) (BaseNetworkSocketAddIpv6MembershipResult, error)
	// Set `SOL_IPV6` -> `IPV6_DROP_MEMBERSHIP`.
	DropIpv6Membership(ctx_ _bindings.Context, membership Ipv6MulticastMembership) (BaseNetworkSocketDropIpv6MembershipResult, error)
	// Set `SOL_IPV6` -> `IPV6_MULTICAST_IF`.
	SetIpv6MulticastInterface(ctx_ _bindings.Context, value uint64) (BaseNetworkSocketSetIpv6MulticastInterfaceResult, error)
	// Get `SOL_IPV6` -> `IPV6_MULTICAST_IF`.
	GetIpv6MulticastInterface(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6MulticastInterfaceResult, error)
	// Set `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`.
	SetIpv6MulticastHops(ctx_ _bindings.Context, value OptionalUint8) (BaseNetworkSocketSetIpv6MulticastHopsResult, error)
	// Get `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`.
	GetIpv6MulticastHops(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6MulticastHopsResult, error)
	// Set `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`.
	SetIpv6MulticastLoopback(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpv6MulticastLoopbackResult, error)
	// Get `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`.
	GetIpv6MulticastLoopback(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6MulticastLoopbackResult, error)
	// Set `SOL_IPV6` -> `IPV6_V6ONLY`.
	SetIpv6Only(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpv6OnlyResult, error)
	// Get `SOL_IPV6` -> `IPV6_V6ONLY`.
	GetIpv6Only(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6OnlyResult, error)
	// Set `SOL_IPV6` -> `IPV6_RECVTCLASS`.
	SetIpv6ReceiveTrafficClass(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpv6ReceiveTrafficClassResult, error)
	// Get `SOL_IPV6` -> `IPV6_RECVTCLASS`.
	GetIpv6ReceiveTrafficClass(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6ReceiveTrafficClassResult, error)
	// Set `SOL_IPV6` -> `IPV6_TCLASS`
	SetIpv6TrafficClass(ctx_ _bindings.Context, value OptionalUint8) (BaseNetworkSocketSetIpv6TrafficClassResult, error)
	// Get `SOL_IPV6` -> `IPV6_TCLASS`.
	GetIpv6TrafficClass(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6TrafficClassResult, error)
	BaseSocketBind(ctx_ _bindings.Context, addr fuchsianet.SocketAddress) (BaseNetworkSocketBaseSocketBindResult, error)
	BaseSocketConnect(ctx_ _bindings.Context, addr fuchsianet.SocketAddress) (BaseNetworkSocketBaseSocketConnectResult, error)
	BaseSocketDisconnect(ctx_ _bindings.Context) (BaseNetworkSocketBaseSocketDisconnectResult, error)
	BaseSocketGetSockName(ctx_ _bindings.Context) (BaseNetworkSocketBaseSocketGetSockNameResult, error)
	BaseSocketGetPeerName(ctx_ _bindings.Context) (BaseNetworkSocketBaseSocketGetPeerNameResult, error)
	BaseSocketShutdown(ctx_ _bindings.Context, mode ShutdownMode) (BaseNetworkSocketBaseSocketShutdownResult, error)
	BaseSocketShutdown2(ctx_ _bindings.Context, mode ShutdownMode) (BaseNetworkSocketBaseSocketShutdown2Result, error)
	BaseSocketSetIpTypeOfService(ctx_ _bindings.Context, value uint8) (BaseNetworkSocketBaseSocketSetIpTypeOfServiceResult, error)
	BaseSocketGetIpTypeOfService(ctx_ _bindings.Context) (BaseNetworkSocketBaseSocketGetIpTypeOfServiceResult, error)
	BaseSocketSetIpTtl(ctx_ _bindings.Context, value OptionalUint8) (BaseNetworkSocketBaseSocketSetIpTtlResult, error)
	BaseSocketGetIpTtl(ctx_ _bindings.Context) (BaseNetworkSocketBaseSocketGetIpTtlResult, error)
	BaseSocketSetIpPacketInfo(ctx_ _bindings.Context, value bool) (BaseNetworkSocketBaseSocketSetIpPacketInfoResult, error)
	BaseSocketGetIpPacketInfo(ctx_ _bindings.Context) (BaseNetworkSocketBaseSocketGetIpPacketInfoResult, error)
	BaseSocketSetIpReceiveTypeOfService(ctx_ _bindings.Context, value bool) (BaseNetworkSocketBaseSocketSetIpReceiveTypeOfServiceResult, error)
	BaseSocketGetIpReceiveTypeOfService(ctx_ _bindings.Context) (BaseNetworkSocketBaseSocketGetIpReceiveTypeOfServiceResult, error)
	BaseSocketSetIpMulticastInterface(ctx_ _bindings.Context, iface uint64, address fuchsianet.Ipv4Address) (BaseNetworkSocketBaseSocketSetIpMulticastInterfaceResult, error)
	BaseSocketGetIpMulticastInterface(ctx_ _bindings.Context) (BaseNetworkSocketBaseSocketGetIpMulticastInterfaceResult, error)
	BaseSocketSetIpMulticastTtl(ctx_ _bindings.Context, value OptionalUint8) (BaseNetworkSocketBaseSocketSetIpMulticastTtlResult, error)
	BaseSocketGetIpMulticastTtl(ctx_ _bindings.Context) (BaseNetworkSocketBaseSocketGetIpMulticastTtlResult, error)
	BaseSocketSetIpMulticastLoopback(ctx_ _bindings.Context, value bool) (BaseNetworkSocketBaseSocketSetIpMulticastLoopbackResult, error)
	BaseSocketGetIpMulticastLoopback(ctx_ _bindings.Context) (BaseNetworkSocketBaseSocketGetIpMulticastLoopbackResult, error)
	BaseSocketAddIpMembership(ctx_ _bindings.Context, membership IpMulticastMembership) (BaseNetworkSocketBaseSocketAddIpMembershipResult, error)
	BaseSocketDropIpMembership(ctx_ _bindings.Context, membership IpMulticastMembership) (BaseNetworkSocketBaseSocketDropIpMembershipResult, error)
	BaseSocketAddIpv6Membership(ctx_ _bindings.Context, membership Ipv6MulticastMembership) (BaseNetworkSocketBaseSocketAddIpv6MembershipResult, error)
	BaseSocketDropIpv6Membership(ctx_ _bindings.Context, membership Ipv6MulticastMembership) (BaseNetworkSocketBaseSocketDropIpv6MembershipResult, error)
	BaseSocketSetIpv6MulticastInterface(ctx_ _bindings.Context, value uint64) (BaseNetworkSocketBaseSocketSetIpv6MulticastInterfaceResult, error)
	BaseSocketGetIpv6MulticastInterface(ctx_ _bindings.Context) (BaseNetworkSocketBaseSocketGetIpv6MulticastInterfaceResult, error)
	BaseSocketSetIpv6MulticastHops(ctx_ _bindings.Context, value OptionalUint8) (BaseNetworkSocketBaseSocketSetIpv6MulticastHopsResult, error)
	BaseSocketGetIpv6MulticastHops(ctx_ _bindings.Context) (BaseNetworkSocketBaseSocketGetIpv6MulticastHopsResult, error)
	BaseSocketSetIpv6MulticastLoopback(ctx_ _bindings.Context, value bool) (BaseNetworkSocketBaseSocketSetIpv6MulticastLoopbackResult, error)
	BaseSocketGetIpv6MulticastLoopback(ctx_ _bindings.Context) (BaseNetworkSocketBaseSocketGetIpv6MulticastLoopbackResult, error)
	BaseSocketSetIpv6Only(ctx_ _bindings.Context, value bool) (BaseNetworkSocketBaseSocketSetIpv6OnlyResult, error)
	BaseSocketGetIpv6Only(ctx_ _bindings.Context) (BaseNetworkSocketBaseSocketGetIpv6OnlyResult, error)
	BaseSocketSetIpv6ReceiveTrafficClass(ctx_ _bindings.Context, value bool) (BaseNetworkSocketBaseSocketSetIpv6ReceiveTrafficClassResult, error)
	BaseSocketGetIpv6ReceiveTrafficClass(ctx_ _bindings.Context) (BaseNetworkSocketBaseSocketGetIpv6ReceiveTrafficClassResult, error)
	BaseSocketSetIpv6TrafficClass(ctx_ _bindings.Context, value OptionalUint8) (BaseNetworkSocketBaseSocketSetIpv6TrafficClassResult, error)
	BaseSocketGetIpv6TrafficClass(ctx_ _bindings.Context) (BaseNetworkSocketBaseSocketGetIpv6TrafficClassResult, error)
	// Receives a message from the socket.
	//
	// + request `want_addr` request message's source address information to be
	//   returned.
	// + request `data_len` the maximum allowed length of the response data
	//   buffer.
	// + request `want_control` request ancillary data to be returned.
	// + request `flags` flags for the receive request.
	// - response `addr` the message's source address information, if requested.
	// - response `data` the message.
	// - response `control` control messages, if requested.
	// - response `truncated` indicates whether or not the returned message was
	//   truncated.
	RecvMsg(ctx_ _bindings.Context, wantAddr bool, dataLen uint32, wantControl bool, flags RecvMsgFlags) (DatagramSocketRecvMsgResult, error)
	// Sends a message on the socket.
	//
	// + request `addr` the address to send the message to. If unset, will send
	//   to the connected peer.
	// + request `data` the message.
	// + request `control` ancillary data.
	// + request `flags` flags for the send request.
	// - response `len` the number of bytes sent.
	SendMsg(ctx_ _bindings.Context, addr *fuchsianet.SocketAddress, data []uint8, control SendControlData, flags SendMsgFlags) (DatagramSocketSendMsgResult, error)
	// Retrieves creation information from the socket.
	//
	// - response `domain` the socket's associated domain.
	// - response `proto` the socket's associated protocol.
	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 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 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 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 DatagramSocketBaseSocketBindOrdinal:
		in_ := datagramSocketWithCtxBaseSocketBindRequest{}
		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.BaseSocketBind(args_.Ctx, in_.Addr)
		out_ := datagramSocketWithCtxBaseSocketBindResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketBaseSocketConnectOrdinal:
		in_ := datagramSocketWithCtxBaseSocketConnectRequest{}
		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.BaseSocketConnect(args_.Ctx, in_.Addr)
		out_ := datagramSocketWithCtxBaseSocketConnectResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketBaseSocketDisconnectOrdinal:
		result, err_ := s_.Impl.BaseSocketDisconnect(args_.Ctx)
		out_ := datagramSocketWithCtxBaseSocketDisconnectResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketBaseSocketGetSockNameOrdinal:
		result, err_ := s_.Impl.BaseSocketGetSockName(args_.Ctx)
		out_ := datagramSocketWithCtxBaseSocketGetSockNameResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketBaseSocketGetPeerNameOrdinal:
		result, err_ := s_.Impl.BaseSocketGetPeerName(args_.Ctx)
		out_ := datagramSocketWithCtxBaseSocketGetPeerNameResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketBaseSocketShutdownOrdinal:
		in_ := datagramSocketWithCtxBaseSocketShutdownRequest{}
		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.BaseSocketShutdown(args_.Ctx, in_.Mode)
		out_ := datagramSocketWithCtxBaseSocketShutdownResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketBaseSocketShutdown2Ordinal:
		in_ := datagramSocketWithCtxBaseSocketShutdown2Request{}
		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.BaseSocketShutdown2(args_.Ctx, in_.Mode)
		out_ := datagramSocketWithCtxBaseSocketShutdown2Response{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketBaseSocketSetIpTypeOfServiceOrdinal:
		in_ := datagramSocketWithCtxBaseSocketSetIpTypeOfServiceRequest{}
		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.BaseSocketSetIpTypeOfService(args_.Ctx, in_.Value)
		out_ := datagramSocketWithCtxBaseSocketSetIpTypeOfServiceResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketBaseSocketGetIpTypeOfServiceOrdinal:
		result, err_ := s_.Impl.BaseSocketGetIpTypeOfService(args_.Ctx)
		out_ := datagramSocketWithCtxBaseSocketGetIpTypeOfServiceResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketBaseSocketSetIpTtlOrdinal:
		in_ := datagramSocketWithCtxBaseSocketSetIpTtlRequest{}
		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.BaseSocketSetIpTtl(args_.Ctx, in_.Value)
		out_ := datagramSocketWithCtxBaseSocketSetIpTtlResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketBaseSocketGetIpTtlOrdinal:
		result, err_ := s_.Impl.BaseSocketGetIpTtl(args_.Ctx)
		out_ := datagramSocketWithCtxBaseSocketGetIpTtlResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketBaseSocketSetIpPacketInfoOrdinal:
		in_ := datagramSocketWithCtxBaseSocketSetIpPacketInfoRequest{}
		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.BaseSocketSetIpPacketInfo(args_.Ctx, in_.Value)
		out_ := datagramSocketWithCtxBaseSocketSetIpPacketInfoResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketBaseSocketGetIpPacketInfoOrdinal:
		result, err_ := s_.Impl.BaseSocketGetIpPacketInfo(args_.Ctx)
		out_ := datagramSocketWithCtxBaseSocketGetIpPacketInfoResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketBaseSocketSetIpReceiveTypeOfServiceOrdinal:
		in_ := datagramSocketWithCtxBaseSocketSetIpReceiveTypeOfServiceRequest{}
		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.BaseSocketSetIpReceiveTypeOfService(args_.Ctx, in_.Value)
		out_ := datagramSocketWithCtxBaseSocketSetIpReceiveTypeOfServiceResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketBaseSocketGetIpReceiveTypeOfServiceOrdinal:
		result, err_ := s_.Impl.BaseSocketGetIpReceiveTypeOfService(args_.Ctx)
		out_ := datagramSocketWithCtxBaseSocketGetIpReceiveTypeOfServiceResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketBaseSocketSetIpMulticastInterfaceOrdinal:
		in_ := datagramSocketWithCtxBaseSocketSetIpMulticastInterfaceRequest{}
		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.BaseSocketSetIpMulticastInterface(args_.Ctx, in_.Iface, in_.Address)
		out_ := datagramSocketWithCtxBaseSocketSetIpMulticastInterfaceResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketBaseSocketGetIpMulticastInterfaceOrdinal:
		result, err_ := s_.Impl.BaseSocketGetIpMulticastInterface(args_.Ctx)
		out_ := datagramSocketWithCtxBaseSocketGetIpMulticastInterfaceResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketBaseSocketSetIpMulticastTtlOrdinal:
		in_ := datagramSocketWithCtxBaseSocketSetIpMulticastTtlRequest{}
		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.BaseSocketSetIpMulticastTtl(args_.Ctx, in_.Value)
		out_ := datagramSocketWithCtxBaseSocketSetIpMulticastTtlResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketBaseSocketGetIpMulticastTtlOrdinal:
		result, err_ := s_.Impl.BaseSocketGetIpMulticastTtl(args_.Ctx)
		out_ := datagramSocketWithCtxBaseSocketGetIpMulticastTtlResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketBaseSocketSetIpMulticastLoopbackOrdinal:
		in_ := datagramSocketWithCtxBaseSocketSetIpMulticastLoopbackRequest{}
		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.BaseSocketSetIpMulticastLoopback(args_.Ctx, in_.Value)
		out_ := datagramSocketWithCtxBaseSocketSetIpMulticastLoopbackResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketBaseSocketGetIpMulticastLoopbackOrdinal:
		result, err_ := s_.Impl.BaseSocketGetIpMulticastLoopback(args_.Ctx)
		out_ := datagramSocketWithCtxBaseSocketGetIpMulticastLoopbackResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketBaseSocketAddIpMembershipOrdinal:
		in_ := datagramSocketWithCtxBaseSocketAddIpMembershipRequest{}
		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.BaseSocketAddIpMembership(args_.Ctx, in_.Membership)
		out_ := datagramSocketWithCtxBaseSocketAddIpMembershipResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketBaseSocketDropIpMembershipOrdinal:
		in_ := datagramSocketWithCtxBaseSocketDropIpMembershipRequest{}
		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.BaseSocketDropIpMembership(args_.Ctx, in_.Membership)
		out_ := datagramSocketWithCtxBaseSocketDropIpMembershipResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketBaseSocketAddIpv6MembershipOrdinal:
		in_ := datagramSocketWithCtxBaseSocketAddIpv6MembershipRequest{}
		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.BaseSocketAddIpv6Membership(args_.Ctx, in_.Membership)
		out_ := datagramSocketWithCtxBaseSocketAddIpv6MembershipResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketBaseSocketDropIpv6MembershipOrdinal:
		in_ := datagramSocketWithCtxBaseSocketDropIpv6MembershipRequest{}
		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.BaseSocketDropIpv6Membership(args_.Ctx, in_.Membership)
		out_ := datagramSocketWithCtxBaseSocketDropIpv6MembershipResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketBaseSocketSetIpv6MulticastInterfaceOrdinal:
		in_ := datagramSocketWithCtxBaseSocketSetIpv6MulticastInterfaceRequest{}
		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.BaseSocketSetIpv6MulticastInterface(args_.Ctx, in_.Value)
		out_ := datagramSocketWithCtxBaseSocketSetIpv6MulticastInterfaceResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketBaseSocketGetIpv6MulticastInterfaceOrdinal:
		result, err_ := s_.Impl.BaseSocketGetIpv6MulticastInterface(args_.Ctx)
		out_ := datagramSocketWithCtxBaseSocketGetIpv6MulticastInterfaceResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketBaseSocketSetIpv6MulticastHopsOrdinal:
		in_ := datagramSocketWithCtxBaseSocketSetIpv6MulticastHopsRequest{}
		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.BaseSocketSetIpv6MulticastHops(args_.Ctx, in_.Value)
		out_ := datagramSocketWithCtxBaseSocketSetIpv6MulticastHopsResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketBaseSocketGetIpv6MulticastHopsOrdinal:
		result, err_ := s_.Impl.BaseSocketGetIpv6MulticastHops(args_.Ctx)
		out_ := datagramSocketWithCtxBaseSocketGetIpv6MulticastHopsResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketBaseSocketSetIpv6MulticastLoopbackOrdinal:
		in_ := datagramSocketWithCtxBaseSocketSetIpv6MulticastLoopbackRequest{}
		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.BaseSocketSetIpv6MulticastLoopback(args_.Ctx, in_.Value)
		out_ := datagramSocketWithCtxBaseSocketSetIpv6MulticastLoopbackResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketBaseSocketGetIpv6MulticastLoopbackOrdinal:
		result, err_ := s_.Impl.BaseSocketGetIpv6MulticastLoopback(args_.Ctx)
		out_ := datagramSocketWithCtxBaseSocketGetIpv6MulticastLoopbackResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketBaseSocketSetIpv6OnlyOrdinal:
		in_ := datagramSocketWithCtxBaseSocketSetIpv6OnlyRequest{}
		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.BaseSocketSetIpv6Only(args_.Ctx, in_.Value)
		out_ := datagramSocketWithCtxBaseSocketSetIpv6OnlyResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketBaseSocketGetIpv6OnlyOrdinal:
		result, err_ := s_.Impl.BaseSocketGetIpv6Only(args_.Ctx)
		out_ := datagramSocketWithCtxBaseSocketGetIpv6OnlyResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketBaseSocketSetIpv6ReceiveTrafficClassOrdinal:
		in_ := datagramSocketWithCtxBaseSocketSetIpv6ReceiveTrafficClassRequest{}
		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.BaseSocketSetIpv6ReceiveTrafficClass(args_.Ctx, in_.Value)
		out_ := datagramSocketWithCtxBaseSocketSetIpv6ReceiveTrafficClassResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketBaseSocketGetIpv6ReceiveTrafficClassOrdinal:
		result, err_ := s_.Impl.BaseSocketGetIpv6ReceiveTrafficClass(args_.Ctx)
		out_ := datagramSocketWithCtxBaseSocketGetIpv6ReceiveTrafficClassResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketBaseSocketSetIpv6TrafficClassOrdinal:
		in_ := datagramSocketWithCtxBaseSocketSetIpv6TrafficClassRequest{}
		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.BaseSocketSetIpv6TrafficClass(args_.Ctx, in_.Value)
		out_ := datagramSocketWithCtxBaseSocketSetIpv6TrafficClassResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketBaseSocketGetIpv6TrafficClassOrdinal:
		result, err_ := s_.Impl.BaseSocketGetIpv6TrafficClass(args_.Ctx)
		out_ := datagramSocketWithCtxBaseSocketGetIpv6TrafficClassResponse{}
		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
	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
	StreamSocketBindOrdinal                                 uint64 = 0x4bc6400ae92125d
	StreamSocketConnectOrdinal                              uint64 = 0x5f05f19bfdd38871
	StreamSocketDisconnectOrdinal                           uint64 = 0x74e63b91f7b29b2
	StreamSocketGetSockNameOrdinal                          uint64 = 0x475f23f84a1a4f85
	StreamSocketGetPeerNameOrdinal                          uint64 = 0x1ffecf4bd5b6432e
	StreamSocketShutdownOrdinal                             uint64 = 0x247f38b6db68c336
	StreamSocketShutdown2Ordinal                            uint64 = 0x421055d9d50e4f48
	StreamSocketSetIpTypeOfServiceOrdinal                   uint64 = 0x995c600475b6d46
	StreamSocketGetIpTypeOfServiceOrdinal                   uint64 = 0x3814a04259f75fcb
	StreamSocketSetIpTtlOrdinal                             uint64 = 0x29e2424b433ae1ef
	StreamSocketGetIpTtlOrdinal                             uint64 = 0x47e47fa1f24da471
	StreamSocketSetIpPacketInfoOrdinal                      uint64 = 0x392d16bee20c0e16
	StreamSocketGetIpPacketInfoOrdinal                      uint64 = 0x54b505f242280740
	StreamSocketSetIpReceiveTypeOfServiceOrdinal            uint64 = 0x6c4f6714995f84ef
	StreamSocketGetIpReceiveTypeOfServiceOrdinal            uint64 = 0x4158ba7dc2795960
	StreamSocketSetIpMulticastInterfaceOrdinal              uint64 = 0x752fbfa9b12befe
	StreamSocketGetIpMulticastInterfaceOrdinal              uint64 = 0x320bd14c4df046c4
	StreamSocketSetIpMulticastTtlOrdinal                    uint64 = 0x63134d53772916a1
	StreamSocketGetIpMulticastTtlOrdinal                    uint64 = 0x4665cd378f39e1a
	StreamSocketSetIpMulticastLoopbackOrdinal               uint64 = 0x20c55c11f00943ea
	StreamSocketGetIpMulticastLoopbackOrdinal               uint64 = 0x3b6b26ff558298f2
	StreamSocketAddIpMembershipOrdinal                      uint64 = 0x76bc7df115a3b4d0
	StreamSocketDropIpMembershipOrdinal                     uint64 = 0x2888f3099188d03
	StreamSocketAddIpv6MembershipOrdinal                    uint64 = 0x7c94727acb4ea4b3
	StreamSocketDropIpv6MembershipOrdinal                   uint64 = 0x42104c70ccaba304
	StreamSocketSetIpv6MulticastInterfaceOrdinal            uint64 = 0x135f76db3774ab3b
	StreamSocketGetIpv6MulticastInterfaceOrdinal            uint64 = 0x1f26fcdd348f1882
	StreamSocketSetIpv6MulticastHopsOrdinal                 uint64 = 0x25b9cd4d181f82c1
	StreamSocketGetIpv6MulticastHopsOrdinal                 uint64 = 0x52916948a365012a
	StreamSocketSetIpv6MulticastLoopbackOrdinal             uint64 = 0x55701c409ff41b40
	StreamSocketGetIpv6MulticastLoopbackOrdinal             uint64 = 0x4415b701fde319c3
	StreamSocketSetIpv6OnlyOrdinal                          uint64 = 0x4873f1364758cbba
	StreamSocketGetIpv6OnlyOrdinal                          uint64 = 0x4aa3340a1a26b89c
	StreamSocketSetIpv6ReceiveTrafficClassOrdinal           uint64 = 0x58f07c8788d099a0
	StreamSocketGetIpv6ReceiveTrafficClassOrdinal           uint64 = 0x2e334df1da553ffa
	StreamSocketSetIpv6TrafficClassOrdinal                  uint64 = 0x6af077800c5a0b4f
	StreamSocketGetIpv6TrafficClassOrdinal                  uint64 = 0x6baf6eed8fc2f04
	StreamSocketBaseSocketBindOrdinal                       uint64 = 0xf8457e6b05e15bc
	StreamSocketBaseSocketConnectOrdinal                    uint64 = 0x17abeee0b9843bb1
	StreamSocketBaseSocketDisconnectOrdinal                 uint64 = 0x20eaedba2e0f70a4
	StreamSocketBaseSocketGetSockNameOrdinal                uint64 = 0x41a618ef19a91f9d
	StreamSocketBaseSocketGetPeerNameOrdinal                uint64 = 0x4009d08a4beb5e95
	StreamSocketBaseSocketShutdownOrdinal                   uint64 = 0x382080a1d15b2111
	StreamSocketBaseSocketShutdown2Ordinal                  uint64 = 0x57d3458f9754763b
	StreamSocketBaseSocketSetIpTypeOfServiceOrdinal         uint64 = 0x559849ba9574834a
	StreamSocketBaseSocketGetIpTypeOfServiceOrdinal         uint64 = 0x2740d6bfa379deb1
	StreamSocketBaseSocketSetIpTtlOrdinal                   uint64 = 0x67395f7176d7918e
	StreamSocketBaseSocketGetIpTtlOrdinal                   uint64 = 0x789d5ddfe26b97ac
	StreamSocketBaseSocketSetIpPacketInfoOrdinal            uint64 = 0x3e02030a2fd13c03
	StreamSocketBaseSocketGetIpPacketInfoOrdinal            uint64 = 0x176f008d5a0dab15
	StreamSocketBaseSocketSetIpReceiveTypeOfServiceOrdinal  uint64 = 0x17148064e563dde5
	StreamSocketBaseSocketGetIpReceiveTypeOfServiceOrdinal  uint64 = 0x26cc26653b0fa460
	StreamSocketBaseSocketSetIpMulticastInterfaceOrdinal    uint64 = 0x6566fdb7061bbcf8
	StreamSocketBaseSocketGetIpMulticastInterfaceOrdinal    uint64 = 0x44415752b16ff024
	StreamSocketBaseSocketSetIpMulticastTtlOrdinal          uint64 = 0x7d1a477776ba00d3
	StreamSocketBaseSocketGetIpMulticastTtlOrdinal          uint64 = 0x17cbd4bd9246fc40
	StreamSocketBaseSocketSetIpMulticastLoopbackOrdinal     uint64 = 0x2a56b32f8f02369
	StreamSocketBaseSocketGetIpMulticastLoopbackOrdinal     uint64 = 0x27b16d7883c08ca8
	StreamSocketBaseSocketAddIpMembershipOrdinal            uint64 = 0x39a4eda6580147a0
	StreamSocketBaseSocketDropIpMembershipOrdinal           uint64 = 0x6d16e8fbaf496254
	StreamSocketBaseSocketAddIpv6MembershipOrdinal          uint64 = 0x231556bfce3194c1
	StreamSocketBaseSocketDropIpv6MembershipOrdinal         uint64 = 0x629c12db293444c0
	StreamSocketBaseSocketSetIpv6MulticastInterfaceOrdinal  uint64 = 0x5d2a568e67b54234
	StreamSocketBaseSocketGetIpv6MulticastInterfaceOrdinal  uint64 = 0x7b8f38fe354f32bc
	StreamSocketBaseSocketSetIpv6MulticastHopsOrdinal       uint64 = 0x2b2167d12c8a495d
	StreamSocketBaseSocketGetIpv6MulticastHopsOrdinal       uint64 = 0x51a3c8257b1a2745
	StreamSocketBaseSocketSetIpv6MulticastLoopbackOrdinal   uint64 = 0x97706949c4163b7
	StreamSocketBaseSocketGetIpv6MulticastLoopbackOrdinal   uint64 = 0x78d6544e48794935
	StreamSocketBaseSocketSetIpv6OnlyOrdinal                uint64 = 0x1d87ce5c02d8bcb2
	StreamSocketBaseSocketGetIpv6OnlyOrdinal                uint64 = 0x25d6755dbe2e9c7e
	StreamSocketBaseSocketSetIpv6ReceiveTrafficClassOrdinal uint64 = 0x53b93b71c9431fe4
	StreamSocketBaseSocketGetIpv6ReceiveTrafficClassOrdinal uint64 = 0x1c8433af11cd4596
	StreamSocketBaseSocketSetIpv6TrafficClassOrdinal        uint64 = 0x32da0ca485fad782
	StreamSocketBaseSocketGetIpv6TrafficClassOrdinal        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_
}

// 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_
}

// Sets the local address used for the socket.
func (p *StreamSocketWithCtxInterface) Bind(ctx_ _bindings.Context, addr fuchsianet.SocketAddress) (BaseNetworkSocketBindResult, 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) (BaseNetworkSocketConnectResult, 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) (BaseNetworkSocketDisconnectResult, 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) (BaseNetworkSocketGetSockNameResult, 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) (BaseNetworkSocketGetPeerNameResult, 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) (BaseNetworkSocketShutdownResult, 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) (BaseNetworkSocketShutdown2Result, error) {
	req_ := &streamSocketWithCtxShutdown2Request{
		Mode: mode,
	}
	resp_ := &streamSocketWithCtxShutdown2Response{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketShutdown2Ordinal, req_, resp_)
	return resp_.Result, err_
}

// Set `SOL_IP` -> `IP_TOS`.
func (p *StreamSocketWithCtxInterface) SetIpTypeOfService(ctx_ _bindings.Context, value uint8) (BaseNetworkSocketSetIpTypeOfServiceResult, 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) (BaseNetworkSocketGetIpTypeOfServiceResult, 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) (BaseNetworkSocketSetIpTtlResult, 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) (BaseNetworkSocketGetIpTtlResult, 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) (BaseNetworkSocketSetIpPacketInfoResult, 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) (BaseNetworkSocketGetIpPacketInfoResult, 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) (BaseNetworkSocketSetIpReceiveTypeOfServiceResult, 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) (BaseNetworkSocketGetIpReceiveTypeOfServiceResult, 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) (BaseNetworkSocketSetIpMulticastInterfaceResult, 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) (BaseNetworkSocketGetIpMulticastInterfaceResult, 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) (BaseNetworkSocketSetIpMulticastTtlResult, 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) (BaseNetworkSocketGetIpMulticastTtlResult, 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) (BaseNetworkSocketSetIpMulticastLoopbackResult, 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) (BaseNetworkSocketGetIpMulticastLoopbackResult, 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) (BaseNetworkSocketAddIpMembershipResult, 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) (BaseNetworkSocketDropIpMembershipResult, 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) (BaseNetworkSocketAddIpv6MembershipResult, 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) (BaseNetworkSocketDropIpv6MembershipResult, 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) (BaseNetworkSocketSetIpv6MulticastInterfaceResult, 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) (BaseNetworkSocketGetIpv6MulticastInterfaceResult, 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) (BaseNetworkSocketSetIpv6MulticastHopsResult, 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) (BaseNetworkSocketGetIpv6MulticastHopsResult, 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) (BaseNetworkSocketSetIpv6MulticastLoopbackResult, 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) (BaseNetworkSocketGetIpv6MulticastLoopbackResult, 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) (BaseNetworkSocketSetIpv6OnlyResult, 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) (BaseNetworkSocketGetIpv6OnlyResult, 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) (BaseNetworkSocketSetIpv6ReceiveTrafficClassResult, 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) (BaseNetworkSocketGetIpv6ReceiveTrafficClassResult, 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) (BaseNetworkSocketSetIpv6TrafficClassResult, 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) (BaseNetworkSocketGetIpv6TrafficClassResult, error) {
	var req_ _bindings.Message
	resp_ := &streamSocketWithCtxGetIpv6TrafficClassResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetIpv6TrafficClassOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *StreamSocketWithCtxInterface) BaseSocketBind(ctx_ _bindings.Context, addr fuchsianet.SocketAddress) (BaseNetworkSocketBaseSocketBindResult, error) {
	req_ := &streamSocketWithCtxBaseSocketBindRequest{
		Addr: addr,
	}
	resp_ := &streamSocketWithCtxBaseSocketBindResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketBaseSocketBindOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *StreamSocketWithCtxInterface) BaseSocketConnect(ctx_ _bindings.Context, addr fuchsianet.SocketAddress) (BaseNetworkSocketBaseSocketConnectResult, error) {
	req_ := &streamSocketWithCtxBaseSocketConnectRequest{
		Addr: addr,
	}
	resp_ := &streamSocketWithCtxBaseSocketConnectResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketBaseSocketConnectOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *StreamSocketWithCtxInterface) BaseSocketDisconnect(ctx_ _bindings.Context) (BaseNetworkSocketBaseSocketDisconnectResult, error) {
	var req_ _bindings.Message
	resp_ := &streamSocketWithCtxBaseSocketDisconnectResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketBaseSocketDisconnectOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *StreamSocketWithCtxInterface) BaseSocketGetSockName(ctx_ _bindings.Context) (BaseNetworkSocketBaseSocketGetSockNameResult, error) {
	var req_ _bindings.Message
	resp_ := &streamSocketWithCtxBaseSocketGetSockNameResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketBaseSocketGetSockNameOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *StreamSocketWithCtxInterface) BaseSocketGetPeerName(ctx_ _bindings.Context) (BaseNetworkSocketBaseSocketGetPeerNameResult, error) {
	var req_ _bindings.Message
	resp_ := &streamSocketWithCtxBaseSocketGetPeerNameResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketBaseSocketGetPeerNameOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *StreamSocketWithCtxInterface) BaseSocketShutdown(ctx_ _bindings.Context, mode ShutdownMode) (BaseNetworkSocketBaseSocketShutdownResult, error) {
	req_ := &streamSocketWithCtxBaseSocketShutdownRequest{
		Mode: mode,
	}
	resp_ := &streamSocketWithCtxBaseSocketShutdownResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketBaseSocketShutdownOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *StreamSocketWithCtxInterface) BaseSocketShutdown2(ctx_ _bindings.Context, mode ShutdownMode) (BaseNetworkSocketBaseSocketShutdown2Result, error) {
	req_ := &streamSocketWithCtxBaseSocketShutdown2Request{
		Mode: mode,
	}
	resp_ := &streamSocketWithCtxBaseSocketShutdown2Response{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketBaseSocketShutdown2Ordinal, req_, resp_)
	return resp_.Result, err_
}

func (p *StreamSocketWithCtxInterface) BaseSocketSetIpTypeOfService(ctx_ _bindings.Context, value uint8) (BaseNetworkSocketBaseSocketSetIpTypeOfServiceResult, error) {
	req_ := &streamSocketWithCtxBaseSocketSetIpTypeOfServiceRequest{
		Value: value,
	}
	resp_ := &streamSocketWithCtxBaseSocketSetIpTypeOfServiceResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketBaseSocketSetIpTypeOfServiceOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *StreamSocketWithCtxInterface) BaseSocketGetIpTypeOfService(ctx_ _bindings.Context) (BaseNetworkSocketBaseSocketGetIpTypeOfServiceResult, error) {
	var req_ _bindings.Message
	resp_ := &streamSocketWithCtxBaseSocketGetIpTypeOfServiceResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketBaseSocketGetIpTypeOfServiceOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *StreamSocketWithCtxInterface) BaseSocketSetIpTtl(ctx_ _bindings.Context, value OptionalUint8) (BaseNetworkSocketBaseSocketSetIpTtlResult, error) {
	req_ := &streamSocketWithCtxBaseSocketSetIpTtlRequest{
		Value: value,
	}
	resp_ := &streamSocketWithCtxBaseSocketSetIpTtlResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketBaseSocketSetIpTtlOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *StreamSocketWithCtxInterface) BaseSocketGetIpTtl(ctx_ _bindings.Context) (BaseNetworkSocketBaseSocketGetIpTtlResult, error) {
	var req_ _bindings.Message
	resp_ := &streamSocketWithCtxBaseSocketGetIpTtlResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketBaseSocketGetIpTtlOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *StreamSocketWithCtxInterface) BaseSocketSetIpPacketInfo(ctx_ _bindings.Context, value bool) (BaseNetworkSocketBaseSocketSetIpPacketInfoResult, error) {
	req_ := &streamSocketWithCtxBaseSocketSetIpPacketInfoRequest{
		Value: value,
	}
	resp_ := &streamSocketWithCtxBaseSocketSetIpPacketInfoResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketBaseSocketSetIpPacketInfoOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *StreamSocketWithCtxInterface) BaseSocketGetIpPacketInfo(ctx_ _bindings.Context) (BaseNetworkSocketBaseSocketGetIpPacketInfoResult, error) {
	var req_ _bindings.Message
	resp_ := &streamSocketWithCtxBaseSocketGetIpPacketInfoResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketBaseSocketGetIpPacketInfoOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *StreamSocketWithCtxInterface) BaseSocketSetIpReceiveTypeOfService(ctx_ _bindings.Context, value bool) (BaseNetworkSocketBaseSocketSetIpReceiveTypeOfServiceResult, error) {
	req_ := &streamSocketWithCtxBaseSocketSetIpReceiveTypeOfServiceRequest{
		Value: value,
	}
	resp_ := &streamSocketWithCtxBaseSocketSetIpReceiveTypeOfServiceResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketBaseSocketSetIpReceiveTypeOfServiceOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *StreamSocketWithCtxInterface) BaseSocketGetIpReceiveTypeOfService(ctx_ _bindings.Context) (BaseNetworkSocketBaseSocketGetIpReceiveTypeOfServiceResult, error) {
	var req_ _bindings.Message
	resp_ := &streamSocketWithCtxBaseSocketGetIpReceiveTypeOfServiceResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketBaseSocketGetIpReceiveTypeOfServiceOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *StreamSocketWithCtxInterface) BaseSocketSetIpMulticastInterface(ctx_ _bindings.Context, iface uint64, address fuchsianet.Ipv4Address) (BaseNetworkSocketBaseSocketSetIpMulticastInterfaceResult, error) {
	req_ := &streamSocketWithCtxBaseSocketSetIpMulticastInterfaceRequest{
		Iface:   iface,
		Address: address,
	}
	resp_ := &streamSocketWithCtxBaseSocketSetIpMulticastInterfaceResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketBaseSocketSetIpMulticastInterfaceOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *StreamSocketWithCtxInterface) BaseSocketGetIpMulticastInterface(ctx_ _bindings.Context) (BaseNetworkSocketBaseSocketGetIpMulticastInterfaceResult, error) {
	var req_ _bindings.Message
	resp_ := &streamSocketWithCtxBaseSocketGetIpMulticastInterfaceResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketBaseSocketGetIpMulticastInterfaceOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *StreamSocketWithCtxInterface) BaseSocketSetIpMulticastTtl(ctx_ _bindings.Context, value OptionalUint8) (BaseNetworkSocketBaseSocketSetIpMulticastTtlResult, error) {
	req_ := &streamSocketWithCtxBaseSocketSetIpMulticastTtlRequest{
		Value: value,
	}
	resp_ := &streamSocketWithCtxBaseSocketSetIpMulticastTtlResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketBaseSocketSetIpMulticastTtlOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *StreamSocketWithCtxInterface) BaseSocketGetIpMulticastTtl(ctx_ _bindings.Context) (BaseNetworkSocketBaseSocketGetIpMulticastTtlResult, error) {
	var req_ _bindings.Message
	resp_ := &streamSocketWithCtxBaseSocketGetIpMulticastTtlResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketBaseSocketGetIpMulticastTtlOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *StreamSocketWithCtxInterface) BaseSocketSetIpMulticastLoopback(ctx_ _bindings.Context, value bool) (BaseNetworkSocketBaseSocketSetIpMulticastLoopbackResult, error) {
	req_ := &streamSocketWithCtxBaseSocketSetIpMulticastLoopbackRequest{
		Value: value,
	}
	resp_ := &streamSocketWithCtxBaseSocketSetIpMulticastLoopbackResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketBaseSocketSetIpMulticastLoopbackOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *StreamSocketWithCtxInterface) BaseSocketGetIpMulticastLoopback(ctx_ _bindings.Context) (BaseNetworkSocketBaseSocketGetIpMulticastLoopbackResult, error) {
	var req_ _bindings.Message
	resp_ := &streamSocketWithCtxBaseSocketGetIpMulticastLoopbackResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketBaseSocketGetIpMulticastLoopbackOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *StreamSocketWithCtxInterface) BaseSocketAddIpMembership(ctx_ _bindings.Context, membership IpMulticastMembership) (BaseNetworkSocketBaseSocketAddIpMembershipResult, error) {
	req_ := &streamSocketWithCtxBaseSocketAddIpMembershipRequest{
		Membership: membership,
	}
	resp_ := &streamSocketWithCtxBaseSocketAddIpMembershipResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketBaseSocketAddIpMembershipOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *StreamSocketWithCtxInterface) BaseSocketDropIpMembership(ctx_ _bindings.Context, membership IpMulticastMembership) (BaseNetworkSocketBaseSocketDropIpMembershipResult, error) {
	req_ := &streamSocketWithCtxBaseSocketDropIpMembershipRequest{
		Membership: membership,
	}
	resp_ := &streamSocketWithCtxBaseSocketDropIpMembershipResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketBaseSocketDropIpMembershipOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *StreamSocketWithCtxInterface) BaseSocketAddIpv6Membership(ctx_ _bindings.Context, membership Ipv6MulticastMembership) (BaseNetworkSocketBaseSocketAddIpv6MembershipResult, error) {
	req_ := &streamSocketWithCtxBaseSocketAddIpv6MembershipRequest{
		Membership: membership,
	}
	resp_ := &streamSocketWithCtxBaseSocketAddIpv6MembershipResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketBaseSocketAddIpv6MembershipOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *StreamSocketWithCtxInterface) BaseSocketDropIpv6Membership(ctx_ _bindings.Context, membership Ipv6MulticastMembership) (BaseNetworkSocketBaseSocketDropIpv6MembershipResult, error) {
	req_ := &streamSocketWithCtxBaseSocketDropIpv6MembershipRequest{
		Membership: membership,
	}
	resp_ := &streamSocketWithCtxBaseSocketDropIpv6MembershipResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketBaseSocketDropIpv6MembershipOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *StreamSocketWithCtxInterface) BaseSocketSetIpv6MulticastInterface(ctx_ _bindings.Context, value uint64) (BaseNetworkSocketBaseSocketSetIpv6MulticastInterfaceResult, error) {
	req_ := &streamSocketWithCtxBaseSocketSetIpv6MulticastInterfaceRequest{
		Value: value,
	}
	resp_ := &streamSocketWithCtxBaseSocketSetIpv6MulticastInterfaceResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketBaseSocketSetIpv6MulticastInterfaceOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *StreamSocketWithCtxInterface) BaseSocketGetIpv6MulticastInterface(ctx_ _bindings.Context) (BaseNetworkSocketBaseSocketGetIpv6MulticastInterfaceResult, error) {
	var req_ _bindings.Message
	resp_ := &streamSocketWithCtxBaseSocketGetIpv6MulticastInterfaceResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketBaseSocketGetIpv6MulticastInterfaceOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *StreamSocketWithCtxInterface) BaseSocketSetIpv6MulticastHops(ctx_ _bindings.Context, value OptionalUint8) (BaseNetworkSocketBaseSocketSetIpv6MulticastHopsResult, error) {
	req_ := &streamSocketWithCtxBaseSocketSetIpv6MulticastHopsRequest{
		Value: value,
	}
	resp_ := &streamSocketWithCtxBaseSocketSetIpv6MulticastHopsResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketBaseSocketSetIpv6MulticastHopsOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *StreamSocketWithCtxInterface) BaseSocketGetIpv6MulticastHops(ctx_ _bindings.Context) (BaseNetworkSocketBaseSocketGetIpv6MulticastHopsResult, error) {
	var req_ _bindings.Message
	resp_ := &streamSocketWithCtxBaseSocketGetIpv6MulticastHopsResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketBaseSocketGetIpv6MulticastHopsOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *StreamSocketWithCtxInterface) BaseSocketSetIpv6MulticastLoopback(ctx_ _bindings.Context, value bool) (BaseNetworkSocketBaseSocketSetIpv6MulticastLoopbackResult, error) {
	req_ := &streamSocketWithCtxBaseSocketSetIpv6MulticastLoopbackRequest{
		Value: value,
	}
	resp_ := &streamSocketWithCtxBaseSocketSetIpv6MulticastLoopbackResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketBaseSocketSetIpv6MulticastLoopbackOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *StreamSocketWithCtxInterface) BaseSocketGetIpv6MulticastLoopback(ctx_ _bindings.Context) (BaseNetworkSocketBaseSocketGetIpv6MulticastLoopbackResult, error) {
	var req_ _bindings.Message
	resp_ := &streamSocketWithCtxBaseSocketGetIpv6MulticastLoopbackResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketBaseSocketGetIpv6MulticastLoopbackOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *StreamSocketWithCtxInterface) BaseSocketSetIpv6Only(ctx_ _bindings.Context, value bool) (BaseNetworkSocketBaseSocketSetIpv6OnlyResult, error) {
	req_ := &streamSocketWithCtxBaseSocketSetIpv6OnlyRequest{
		Value: value,
	}
	resp_ := &streamSocketWithCtxBaseSocketSetIpv6OnlyResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketBaseSocketSetIpv6OnlyOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *StreamSocketWithCtxInterface) BaseSocketGetIpv6Only(ctx_ _bindings.Context) (BaseNetworkSocketBaseSocketGetIpv6OnlyResult, error) {
	var req_ _bindings.Message
	resp_ := &streamSocketWithCtxBaseSocketGetIpv6OnlyResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketBaseSocketGetIpv6OnlyOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *StreamSocketWithCtxInterface) BaseSocketSetIpv6ReceiveTrafficClass(ctx_ _bindings.Context, value bool) (BaseNetworkSocketBaseSocketSetIpv6ReceiveTrafficClassResult, error) {
	req_ := &streamSocketWithCtxBaseSocketSetIpv6ReceiveTrafficClassRequest{
		Value: value,
	}
	resp_ := &streamSocketWithCtxBaseSocketSetIpv6ReceiveTrafficClassResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketBaseSocketSetIpv6ReceiveTrafficClassOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *StreamSocketWithCtxInterface) BaseSocketGetIpv6ReceiveTrafficClass(ctx_ _bindings.Context) (BaseNetworkSocketBaseSocketGetIpv6ReceiveTrafficClassResult, error) {
	var req_ _bindings.Message
	resp_ := &streamSocketWithCtxBaseSocketGetIpv6ReceiveTrafficClassResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketBaseSocketGetIpv6ReceiveTrafficClassOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *StreamSocketWithCtxInterface) BaseSocketSetIpv6TrafficClass(ctx_ _bindings.Context, value OptionalUint8) (BaseNetworkSocketBaseSocketSetIpv6TrafficClassResult, error) {
	req_ := &streamSocketWithCtxBaseSocketSetIpv6TrafficClassRequest{
		Value: value,
	}
	resp_ := &streamSocketWithCtxBaseSocketSetIpv6TrafficClassResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketBaseSocketSetIpv6TrafficClassOrdinal, req_, resp_)
	return resp_.Result, err_
}

func (p *StreamSocketWithCtxInterface) BaseSocketGetIpv6TrafficClass(ctx_ _bindings.Context) (BaseNetworkSocketBaseSocketGetIpv6TrafficClassResult, error) {
	var req_ _bindings.Message
	resp_ := &streamSocketWithCtxBaseSocketGetIpv6TrafficClassResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketBaseSocketGetIpv6TrafficClassOrdinal, 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.
//
// *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 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)
	// 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)
	// Sets the local address used for the socket.
	Bind(ctx_ _bindings.Context, addr fuchsianet.SocketAddress) (BaseNetworkSocketBindResult, error)
	// Initiates a connection to a remote address.
	Connect(ctx_ _bindings.Context, addr fuchsianet.SocketAddress) (BaseNetworkSocketConnectResult, error)
	// Clears connection information from this socket.
	Disconnect(ctx_ _bindings.Context) (BaseNetworkSocketDisconnectResult, error)
	// Retrieves the local socket address.
	GetSockName(ctx_ _bindings.Context) (BaseNetworkSocketGetSockNameResult, error)
	// Retrieves the remote socket address.
	GetPeerName(ctx_ _bindings.Context) (BaseNetworkSocketGetPeerNameResult, error)
	// Shuts down part of the socket.
	Shutdown(ctx_ _bindings.Context, mode ShutdownMode) (BaseNetworkSocketShutdownResult, error)
	Shutdown2(ctx_ _bindings.Context, mode ShutdownMode) (BaseNetworkSocketShutdown2Result, error)
	// Set `SOL_IP` -> `IP_TOS`.
	SetIpTypeOfService(ctx_ _bindings.Context, value uint8) (BaseNetworkSocketSetIpTypeOfServiceResult, error)
	// Get `SOL_IP` -> `IP_TOS`.
	GetIpTypeOfService(ctx_ _bindings.Context) (BaseNetworkSocketGetIpTypeOfServiceResult, error)
	// Set `SOL_IP` -> `IP_TTL`.
	SetIpTtl(ctx_ _bindings.Context, value OptionalUint8) (BaseNetworkSocketSetIpTtlResult, error)
	// Get `SOL_IP` -> `IP_TTL`.
	GetIpTtl(ctx_ _bindings.Context) (BaseNetworkSocketGetIpTtlResult, error)
	// Set `SOL_IP` -> `IP_PKTINFO`.
	SetIpPacketInfo(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpPacketInfoResult, error)
	// Get `SOL_IP` -> `IP_PKTINFO`.
	GetIpPacketInfo(ctx_ _bindings.Context) (BaseNetworkSocketGetIpPacketInfoResult, error)
	// Set `SOL_IP` -> `IP_RECVTOS`.
	SetIpReceiveTypeOfService(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpReceiveTypeOfServiceResult, error)
	// Get `SOL_IP` -> `IP_RECVTOS`.
	GetIpReceiveTypeOfService(ctx_ _bindings.Context) (BaseNetworkSocketGetIpReceiveTypeOfServiceResult, error)
	// Set `SOL_IP` -> `IP_MULTICAST_IF`.
	SetIpMulticastInterface(ctx_ _bindings.Context, iface uint64, address fuchsianet.Ipv4Address) (BaseNetworkSocketSetIpMulticastInterfaceResult, error)
	// Get `SOL_IP` -> `IP_MULTICAST_IF`.
	GetIpMulticastInterface(ctx_ _bindings.Context) (BaseNetworkSocketGetIpMulticastInterfaceResult, error)
	// Set `SOL_IP` -> `IP_MULTICAST_TTL`.
	SetIpMulticastTtl(ctx_ _bindings.Context, value OptionalUint8) (BaseNetworkSocketSetIpMulticastTtlResult, error)
	// Get `SOL_IP` -> `IP_MULTICAST_TTL`.
	GetIpMulticastTtl(ctx_ _bindings.Context) (BaseNetworkSocketGetIpMulticastTtlResult, error)
	// Set `SOL_IP` -> `IP_MULTICAST_LOOP`.
	SetIpMulticastLoopback(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpMulticastLoopbackResult, error)
	// Get `SOL_IP` -> `IP_MULTICAST_LOOP`.
	GetIpMulticastLoopback(ctx_ _bindings.Context) (BaseNetworkSocketGetIpMulticastLoopbackResult, error)
	// Set `SOL_IP` -> `IP_ADD_MEMBERSHIP`
	AddIpMembership(ctx_ _bindings.Context, membership IpMulticastMembership) (BaseNetworkSocketAddIpMembershipResult, error)
	// Set `SOL_IP` -> `IP_DROP_MEMBERSHIP`
	DropIpMembership(ctx_ _bindings.Context, membership IpMulticastMembership) (BaseNetworkSocketDropIpMembershipResult, error)
	// Set `SOL_IPV6` -> `IPV6_ADD_MEMBERSHIP`.
	AddIpv6Membership(ctx_ _bindings.Context, membership Ipv6MulticastMembership) (BaseNetworkSocketAddIpv6MembershipResult, error)
	// Set `SOL_IPV6` -> `IPV6_DROP_MEMBERSHIP`.
	DropIpv6Membership(ctx_ _bindings.Context, membership Ipv6MulticastMembership) (BaseNetworkSocketDropIpv6MembershipResult, error)
	// Set `SOL_IPV6` -> `IPV6_MULTICAST_IF`.
	SetIpv6MulticastInterface(ctx_ _bindings.Context, value uint64) (BaseNetworkSocketSetIpv6MulticastInterfaceResult, error)
	// Get `SOL_IPV6` -> `IPV6_MULTICAST_IF`.
	GetIpv6MulticastInterface(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6MulticastInterfaceResult, error)
	// Set `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`.
	SetIpv6MulticastHops(ctx_ _bindings.Context, value OptionalUint8) (BaseNetworkSocketSetIpv6MulticastHopsResult, error)
	// Get `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`.
	GetIpv6MulticastHops(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6MulticastHopsResult, error)
	// Set `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`.
	SetIpv6MulticastLoopback(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpv6MulticastLoopbackResult, error)
	// Get `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`.
	GetIpv6MulticastLoopback(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6MulticastLoopbackResult, error)
	// Set `SOL_IPV6` -> `IPV6_V6ONLY`.
	SetIpv6Only(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpv6OnlyResult, error)
	// Get `SOL_IPV6` -> `IPV6_V6ONLY`.
	GetIpv6Only(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6OnlyResult, error)
	// Set `SOL_IPV6` -> `IPV6_RECVTCLASS`.
	SetIpv6ReceiveTrafficClass(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpv6ReceiveTrafficClassResult, error)
	// Get `SOL_IPV6` -> `IPV6_RECVTCLASS`.
	GetIpv6ReceiveTrafficClass(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6ReceiveTrafficClassResult, error)
	// Set `SOL_IPV6` -> `IPV6_TCLASS`
	SetIpv6TrafficClass(ctx_ _bindings.Context, value OptionalUint8) (BaseNetworkSocketSetIpv6TrafficClassResult, error)
	// Get `SOL_IPV6` -> `IPV6_TCLASS`.
	GetIpv6TrafficClass(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6TrafficClassResult, error)
	BaseSocketBind(ctx_ _bindings.Context, addr fuchsianet.SocketAddress) (BaseNetworkSocketBaseSocketBindResult, error)
	BaseSocketConnect(ctx_ _bindings.Context, addr fuchsianet.SocketAddress) (BaseNetworkSocketBaseSocketConnectResult, error)
	BaseSocketDisconnect(ctx_ _bindings.Context) (BaseNetworkSocketBaseSocketDisconnectResult, error)
	BaseSocketGetSockName(ctx_ _bindings.Context) (BaseNetworkSocketBaseSocketGetSockNameResult, error)
	BaseSocketGetPeerName(ctx_ _bindings.Context) (BaseNetworkSocketBaseSocketGetPeerNameResult, error)
	BaseSocketShutdown(ctx_ _bindings.Context, mode ShutdownMode) (BaseNetworkSocketBaseSocketShutdownResult, error)
	BaseSocketShutdown2(ctx_ _bindings.Context, mode ShutdownMode) (BaseNetworkSocketBaseSocketShutdown2Result, error)
	BaseSocketSetIpTypeOfService(ctx_ _bindings.Context, value uint8) (BaseNetworkSocketBaseSocketSetIpTypeOfServiceResult, error)
	BaseSocketGetIpTypeOfService(ctx_ _bindings.Context) (BaseNetworkSocketBaseSocketGetIpTypeOfServiceResult, error)
	BaseSocketSetIpTtl(ctx_ _bindings.Context, value OptionalUint8) (BaseNetworkSocketBaseSocketSetIpTtlResult, error)
	BaseSocketGetIpTtl(ctx_ _bindings.Context) (BaseNetworkSocketBaseSocketGetIpTtlResult, error)
	BaseSocketSetIpPacketInfo(ctx_ _bindings.Context, value bool) (BaseNetworkSocketBaseSocketSetIpPacketInfoResult, error)
	BaseSocketGetIpPacketInfo(ctx_ _bindings.Context) (BaseNetworkSocketBaseSocketGetIpPacketInfoResult, error)
	BaseSocketSetIpReceiveTypeOfService(ctx_ _bindings.Context, value bool) (BaseNetworkSocketBaseSocketSetIpReceiveTypeOfServiceResult, error)
	BaseSocketGetIpReceiveTypeOfService(ctx_ _bindings.Context) (BaseNetworkSocketBaseSocketGetIpReceiveTypeOfServiceResult, error)
	BaseSocketSetIpMulticastInterface(ctx_ _bindings.Context, iface uint64, address fuchsianet.Ipv4Address) (BaseNetworkSocketBaseSocketSetIpMulticastInterfaceResult, error)
	BaseSocketGetIpMulticastInterface(ctx_ _bindings.Context) (BaseNetworkSocketBaseSocketGetIpMulticastInterfaceResult, error)
	BaseSocketSetIpMulticastTtl(ctx_ _bindings.Context, value OptionalUint8) (BaseNetworkSocketBaseSocketSetIpMulticastTtlResult, error)
	BaseSocketGetIpMulticastTtl(ctx_ _bindings.Context) (BaseNetworkSocketBaseSocketGetIpMulticastTtlResult, error)
	BaseSocketSetIpMulticastLoopback(ctx_ _bindings.Context, value bool) (BaseNetworkSocketBaseSocketSetIpMulticastLoopbackResult, error)
	BaseSocketGetIpMulticastLoopback(ctx_ _bindings.Context) (BaseNetworkSocketBaseSocketGetIpMulticastLoopbackResult, error)
	BaseSocketAddIpMembership(ctx_ _bindings.Context, membership IpMulticastMembership) (BaseNetworkSocketBaseSocketAddIpMembershipResult, error)
	BaseSocketDropIpMembership(ctx_ _bindings.Context, membership IpMulticastMembership) (BaseNetworkSocketBaseSocketDropIpMembershipResult, error)
	BaseSocketAddIpv6Membership(ctx_ _bindings.Context, membership Ipv6MulticastMembership) (BaseNetworkSocketBaseSocketAddIpv6MembershipResult, error)
	BaseSocketDropIpv6Membership(ctx_ _bindings.Context, membership Ipv6MulticastMembership) (BaseNetworkSocketBaseSocketDropIpv6MembershipResult, error)
	BaseSocketSetIpv6MulticastInterface(ctx_ _bindings.Context, value uint64) (BaseNetworkSocketBaseSocketSetIpv6MulticastInterfaceResult, error)
	BaseSocketGetIpv6MulticastInterface(ctx_ _bindings.Context) (BaseNetworkSocketBaseSocketGetIpv6MulticastInterfaceResult, error)
	BaseSocketSetIpv6MulticastHops(ctx_ _bindings.Context, value OptionalUint8) (BaseNetworkSocketBaseSocketSetIpv6MulticastHopsResult, error)
	BaseSocketGetIpv6MulticastHops(ctx_ _bindings.Context) (BaseNetworkSocketBaseSocketGetIpv6MulticastHopsResult, error)
	BaseSocketSetIpv6MulticastLoopback(ctx_ _bindings.Context, value bool) (BaseNetworkSocketBaseSocketSetIpv6MulticastLoopbackResult, error)
	BaseSocketGetIpv6MulticastLoopback(ctx_ _bindings.Context) (BaseNetworkSocketBaseSocketGetIpv6MulticastLoopbackResult, error)
	BaseSocketSetIpv6Only(ctx_ _bindings.Context, value bool) (BaseNetworkSocketBaseSocketSetIpv6OnlyResult, error)
	BaseSocketGetIpv6Only(ctx_ _bindings.Context) (BaseNetworkSocketBaseSocketGetIpv6OnlyResult, error)
	BaseSocketSetIpv6ReceiveTrafficClass(ctx_ _bindings.Context, value bool) (BaseNetworkSocketBaseSocketSetIpv6ReceiveTrafficClassResult, error)
	BaseSocketGetIpv6ReceiveTrafficClass(ctx_ _bindings.Context) (BaseNetworkSocketBaseSocketGetIpv6ReceiveTrafficClassResult, error)
	BaseSocketSetIpv6TrafficClass(ctx_ _bindings.Context, value OptionalUint8) (BaseNetworkSocketBaseSocketSetIpv6TrafficClassResult, error)
	BaseSocketGetIpv6TrafficClass(ctx_ _bindings.Context) (BaseNetworkSocketBaseSocketGetIpv6TrafficClassResult, 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 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 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 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 StreamSocketBaseSocketBindOrdinal:
		in_ := streamSocketWithCtxBaseSocketBindRequest{}
		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.BaseSocketBind(args_.Ctx, in_.Addr)
		out_ := streamSocketWithCtxBaseSocketBindResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketBaseSocketConnectOrdinal:
		in_ := streamSocketWithCtxBaseSocketConnectRequest{}
		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.BaseSocketConnect(args_.Ctx, in_.Addr)
		out_ := streamSocketWithCtxBaseSocketConnectResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketBaseSocketDisconnectOrdinal:
		result, err_ := s_.Impl.BaseSocketDisconnect(args_.Ctx)
		out_ := streamSocketWithCtxBaseSocketDisconnectResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketBaseSocketGetSockNameOrdinal:
		result, err_ := s_.Impl.BaseSocketGetSockName(args_.Ctx)
		out_ := streamSocketWithCtxBaseSocketGetSockNameResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketBaseSocketGetPeerNameOrdinal:
		result, err_ := s_.Impl.BaseSocketGetPeerName(args_.Ctx)
		out_ := streamSocketWithCtxBaseSocketGetPeerNameResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketBaseSocketShutdownOrdinal:
		in_ := streamSocketWithCtxBaseSocketShutdownRequest{}
		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.BaseSocketShutdown(args_.Ctx, in_.Mode)
		out_ := streamSocketWithCtxBaseSocketShutdownResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketBaseSocketShutdown2Ordinal:
		in_ := streamSocketWithCtxBaseSocketShutdown2Request{}
		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.BaseSocketShutdown2(args_.Ctx, in_.Mode)
		out_ := streamSocketWithCtxBaseSocketShutdown2Response{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketBaseSocketSetIpTypeOfServiceOrdinal:
		in_ := streamSocketWithCtxBaseSocketSetIpTypeOfServiceRequest{}
		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.BaseSocketSetIpTypeOfService(args_.Ctx, in_.Value)
		out_ := streamSocketWithCtxBaseSocketSetIpTypeOfServiceResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketBaseSocketGetIpTypeOfServiceOrdinal:
		result, err_ := s_.Impl.BaseSocketGetIpTypeOfService(args_.Ctx)
		out_ := streamSocketWithCtxBaseSocketGetIpTypeOfServiceResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketBaseSocketSetIpTtlOrdinal:
		in_ := streamSocketWithCtxBaseSocketSetIpTtlRequest{}
		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.BaseSocketSetIpTtl(args_.Ctx, in_.Value)
		out_ := streamSocketWithCtxBaseSocketSetIpTtlResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketBaseSocketGetIpTtlOrdinal:
		result, err_ := s_.Impl.BaseSocketGetIpTtl(args_.Ctx)
		out_ := streamSocketWithCtxBaseSocketGetIpTtlResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketBaseSocketSetIpPacketInfoOrdinal:
		in_ := streamSocketWithCtxBaseSocketSetIpPacketInfoRequest{}
		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.BaseSocketSetIpPacketInfo(args_.Ctx, in_.Value)
		out_ := streamSocketWithCtxBaseSocketSetIpPacketInfoResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketBaseSocketGetIpPacketInfoOrdinal:
		result, err_ := s_.Impl.BaseSocketGetIpPacketInfo(args_.Ctx)
		out_ := streamSocketWithCtxBaseSocketGetIpPacketInfoResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketBaseSocketSetIpReceiveTypeOfServiceOrdinal:
		in_ := streamSocketWithCtxBaseSocketSetIpReceiveTypeOfServiceRequest{}
		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.BaseSocketSetIpReceiveTypeOfService(args_.Ctx, in_.Value)
		out_ := streamSocketWithCtxBaseSocketSetIpReceiveTypeOfServiceResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketBaseSocketGetIpReceiveTypeOfServiceOrdinal:
		result, err_ := s_.Impl.BaseSocketGetIpReceiveTypeOfService(args_.Ctx)
		out_ := streamSocketWithCtxBaseSocketGetIpReceiveTypeOfServiceResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketBaseSocketSetIpMulticastInterfaceOrdinal:
		in_ := streamSocketWithCtxBaseSocketSetIpMulticastInterfaceRequest{}
		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.BaseSocketSetIpMulticastInterface(args_.Ctx, in_.Iface, in_.Address)
		out_ := streamSocketWithCtxBaseSocketSetIpMulticastInterfaceResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketBaseSocketGetIpMulticastInterfaceOrdinal:
		result, err_ := s_.Impl.BaseSocketGetIpMulticastInterface(args_.Ctx)
		out_ := streamSocketWithCtxBaseSocketGetIpMulticastInterfaceResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketBaseSocketSetIpMulticastTtlOrdinal:
		in_ := streamSocketWithCtxBaseSocketSetIpMulticastTtlRequest{}
		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.BaseSocketSetIpMulticastTtl(args_.Ctx, in_.Value)
		out_ := streamSocketWithCtxBaseSocketSetIpMulticastTtlResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketBaseSocketGetIpMulticastTtlOrdinal:
		result, err_ := s_.Impl.BaseSocketGetIpMulticastTtl(args_.Ctx)
		out_ := streamSocketWithCtxBaseSocketGetIpMulticastTtlResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketBaseSocketSetIpMulticastLoopbackOrdinal:
		in_ := streamSocketWithCtxBaseSocketSetIpMulticastLoopbackRequest{}
		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.BaseSocketSetIpMulticastLoopback(args_.Ctx, in_.Value)
		out_ := streamSocketWithCtxBaseSocketSetIpMulticastLoopbackResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketBaseSocketGetIpMulticastLoopbackOrdinal:
		result, err_ := s_.Impl.BaseSocketGetIpMulticastLoopback(args_.Ctx)
		out_ := streamSocketWithCtxBaseSocketGetIpMulticastLoopbackResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketBaseSocketAddIpMembershipOrdinal:
		in_ := streamSocketWithCtxBaseSocketAddIpMembershipRequest{}
		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.BaseSocketAddIpMembership(args_.Ctx, in_.Membership)
		out_ := streamSocketWithCtxBaseSocketAddIpMembershipResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketBaseSocketDropIpMembershipOrdinal:
		in_ := streamSocketWithCtxBaseSocketDropIpMembershipRequest{}
		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.BaseSocketDropIpMembership(args_.Ctx, in_.Membership)
		out_ := streamSocketWithCtxBaseSocketDropIpMembershipResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketBaseSocketAddIpv6MembershipOrdinal:
		in_ := streamSocketWithCtxBaseSocketAddIpv6MembershipRequest{}
		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.BaseSocketAddIpv6Membership(args_.Ctx, in_.Membership)
		out_ := streamSocketWithCtxBaseSocketAddIpv6MembershipResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketBaseSocketDropIpv6MembershipOrdinal:
		in_ := streamSocketWithCtxBaseSocketDropIpv6MembershipRequest{}
		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.BaseSocketDropIpv6Membership(args_.Ctx, in_.Membership)
		out_ := streamSocketWithCtxBaseSocketDropIpv6MembershipResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketBaseSocketSetIpv6MulticastInterfaceOrdinal:
		in_ := streamSocketWithCtxBaseSocketSetIpv6MulticastInterfaceRequest{}
		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.BaseSocketSetIpv6MulticastInterface(args_.Ctx, in_.Value)
		out_ := streamSocketWithCtxBaseSocketSetIpv6MulticastInterfaceResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketBaseSocketGetIpv6MulticastInterfaceOrdinal:
		result, err_ := s_.Impl.BaseSocketGetIpv6MulticastInterface(args_.Ctx)
		out_ := streamSocketWithCtxBaseSocketGetIpv6MulticastInterfaceResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketBaseSocketSetIpv6MulticastHopsOrdinal:
		in_ := streamSocketWithCtxBaseSocketSetIpv6MulticastHopsRequest{}
		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.BaseSocketSetIpv6MulticastHops(args_.Ctx, in_.Value)
		out_ := streamSocketWithCtxBaseSocketSetIpv6MulticastHopsResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketBaseSocketGetIpv6MulticastHopsOrdinal:
		result, err_ := s_.Impl.BaseSocketGetIpv6MulticastHops(args_.Ctx)
		out_ := streamSocketWithCtxBaseSocketGetIpv6MulticastHopsResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketBaseSocketSetIpv6MulticastLoopbackOrdinal:
		in_ := streamSocketWithCtxBaseSocketSetIpv6MulticastLoopbackRequest{}
		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.BaseSocketSetIpv6MulticastLoopback(args_.Ctx, in_.Value)
		out_ := streamSocketWithCtxBaseSocketSetIpv6MulticastLoopbackResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketBaseSocketGetIpv6MulticastLoopbackOrdinal:
		result, err_ := s_.Impl.BaseSocketGetIpv6MulticastLoopback(args_.Ctx)
		out_ := streamSocketWithCtxBaseSocketGetIpv6MulticastLoopbackResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketBaseSocketSetIpv6OnlyOrdinal:
		in_ := streamSocketWithCtxBaseSocketSetIpv6OnlyRequest{}
		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.BaseSocketSetIpv6Only(args_.Ctx, in_.Value)
		out_ := streamSocketWithCtxBaseSocketSetIpv6OnlyResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketBaseSocketGetIpv6OnlyOrdinal:
		result, err_ := s_.Impl.BaseSocketGetIpv6Only(args_.Ctx)
		out_ := streamSocketWithCtxBaseSocketGetIpv6OnlyResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketBaseSocketSetIpv6ReceiveTrafficClassOrdinal:
		in_ := streamSocketWithCtxBaseSocketSetIpv6ReceiveTrafficClassRequest{}
		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.BaseSocketSetIpv6ReceiveTrafficClass(args_.Ctx, in_.Value)
		out_ := streamSocketWithCtxBaseSocketSetIpv6ReceiveTrafficClassResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketBaseSocketGetIpv6ReceiveTrafficClassOrdinal:
		result, err_ := s_.Impl.BaseSocketGetIpv6ReceiveTrafficClass(args_.Ctx)
		out_ := streamSocketWithCtxBaseSocketGetIpv6ReceiveTrafficClassResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketBaseSocketSetIpv6TrafficClassOrdinal:
		in_ := streamSocketWithCtxBaseSocketSetIpv6TrafficClassRequest{}
		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.BaseSocketSetIpv6TrafficClass(args_.Ctx, in_.Value)
		out_ := streamSocketWithCtxBaseSocketSetIpv6TrafficClassResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketBaseSocketGetIpv6TrafficClassOrdinal:
		result, err_ := s_.Impl.BaseSocketGetIpv6TrafficClass(args_.Ctx)
		out_ := streamSocketWithCtxBaseSocketGetIpv6TrafficClassResponse{}
		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.
//
// *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 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