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.

// +build fuchsia

package socket

import (
	_zx "syscall/zx"
	_bindings "syscall/zx/fidl"
	fuchsiaio "syscall/zx/io"
)

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

var _mBaseSocketBindResponse = _bindings.CreateLazyMarshaler(BaseSocketBindResponse{})

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

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

var _mBaseSocketConnectResponse = _bindings.CreateLazyMarshaler(BaseSocketConnectResponse{})

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

type BaseSocketGetSockNameResponse struct {
	_    struct{} `fidl:"s" fidl_size_v1:"16" fidl_alignment_v1:"8"`
	Addr []uint8  `fidl_offset_v1:"0" fidl_bounds:"128"`
}

var _mBaseSocketGetSockNameResponse = _bindings.CreateLazyMarshaler(BaseSocketGetSockNameResponse{})

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

type BaseSocketGetPeerNameResponse struct {
	_    struct{} `fidl:"s" fidl_size_v1:"16" fidl_alignment_v1:"8"`
	Addr []uint8  `fidl_offset_v1:"0" fidl_bounds:"128"`
}

var _mBaseSocketGetPeerNameResponse = _bindings.CreateLazyMarshaler(BaseSocketGetPeerNameResponse{})

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

type BaseSocketSetSockOptResponse struct {
	_ struct{} `fidl:"s" fidl_size_v1:"1" fidl_alignment_v1:"1"`
}

var _mBaseSocketSetSockOptResponse = _bindings.CreateLazyMarshaler(BaseSocketSetSockOptResponse{})

func (msg *BaseSocketSetSockOptResponse) Marshaler() _bindings.Marshaler {
	return _mBaseSocketSetSockOptResponse
}

type BaseSocketGetSockOptResponse struct {
	_      struct{} `fidl:"s" fidl_size_v1:"16" fidl_alignment_v1:"8"`
	Optval []uint8  `fidl_offset_v1:"0" fidl_bounds:"900"`
}

var _mBaseSocketGetSockOptResponse = _bindings.CreateLazyMarshaler(BaseSocketGetSockOptResponse{})

func (msg *BaseSocketGetSockOptResponse) Marshaler() _bindings.Marshaler {
	return _mBaseSocketGetSockOptResponse
}

type DatagramSocketShutdownResponse struct {
	_ struct{} `fidl:"s" fidl_size_v1:"1" fidl_alignment_v1:"1"`
}

var _mDatagramSocketShutdownResponse = _bindings.CreateLazyMarshaler(DatagramSocketShutdownResponse{})

func (msg *DatagramSocketShutdownResponse) Marshaler() _bindings.Marshaler {
	return _mDatagramSocketShutdownResponse
}

type DatagramSocketRecvMsgResponse struct {
	_         struct{} `fidl:"s" fidl_size_v1:"56" fidl_alignment_v1:"8"`
	Addr      []uint8  `fidl_offset_v1:"0" fidl_bounds:"128"`
	Data      []uint8  `fidl_offset_v1:"16" fidl_bounds:""`
	Control   []uint8  `fidl_offset_v1:"32" fidl_bounds:""`
	Truncated uint32   `fidl_offset_v1:"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"`
	Len int64    `fidl_offset_v1:"0"`
}

var _mDatagramSocketSendMsgResponse = _bindings.CreateLazyMarshaler(DatagramSocketSendMsgResponse{})

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

type DatagramSocketSendMsg2Response struct {
	_   struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8"`
	Len int64    `fidl_offset_v1:"0"`
}

var _mDatagramSocketSendMsg2Response = _bindings.CreateLazyMarshaler(DatagramSocketSendMsg2Response{})

func (msg *DatagramSocketSendMsg2Response) Marshaler() _bindings.Marshaler {
	return _mDatagramSocketSendMsg2Response
}

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

var _mStreamSocketListenResponse = _bindings.CreateLazyMarshaler(StreamSocketListenResponse{})

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

type StreamSocketAcceptResponse struct {
	_ struct{}                     `fidl:"s" fidl_size_v1:"4" fidl_alignment_v1:"4"`
	S StreamSocketWithCtxInterface `fidl_offset_v1:"0" fidl_handle_subtype:"4"`
}

var _mStreamSocketAcceptResponse = _bindings.CreateLazyMarshaler(StreamSocketAcceptResponse{})

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

type ProviderSocket2Response struct {
	_ struct{}                   `fidl:"s" fidl_size_v1:"4" fidl_alignment_v1:"4"`
	S BaseSocketWithCtxInterface `fidl_offset_v1:"0" fidl_handle_subtype:"4"`
}

var _mProviderSocket2Response = _bindings.CreateLazyMarshaler(ProviderSocket2Response{})

func (msg *ProviderSocket2Response) Marshaler() _bindings.Marshaler {
	return _mProviderSocket2Response
}

type ProviderInterfaceIndexToNameResponse struct {
	_    struct{} `fidl:"s" fidl_size_v1:"16" fidl_alignment_v1:"8"`
	Name string   `fidl_offset_v1:"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"`
	Index uint64   `fidl_offset_v1:"0"`
}

var _mProviderInterfaceNameToIndexResponse = _bindings.CreateLazyMarshaler(ProviderInterfaceNameToIndexResponse{})

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

type baseSocketWithCtxCloneRequest struct {
	_      struct{}                              `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8"`
	Flags  uint32                                `fidl_offset_v1:"0"`
	Object fuchsiaio.NodeWithCtxInterfaceRequest `fidl_offset_v1:"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"`
	S int32    `fidl_offset_v1:"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"`
	Info fuchsiaio.NodeInfo `fidl_offset_v1:"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"`
	S    int32               `fidl_offset_v1:"0"`
	Info *fuchsiaio.NodeInfo `fidl_offset_v1:"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"`
	S int32    `fidl_offset_v1:"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"`
	S          int32                    `fidl_offset_v1:"0"`
	Attributes fuchsiaio.NodeAttributes `fidl_offset_v1:"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"`
	Flags      uint32                   `fidl_offset_v1:"0"`
	Attributes fuchsiaio.NodeAttributes `fidl_offset_v1:"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"`
	S int32    `fidl_offset_v1:"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"`
	S     int32    `fidl_offset_v1:"0"`
	Flags uint32   `fidl_offset_v1:"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"`
	Flags uint32   `fidl_offset_v1:"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"`
	S int32    `fidl_offset_v1:"0"`
}

var _mbaseSocketWithCtxNodeSetFlagsResponse = _bindings.CreateLazyMarshaler(baseSocketWithCtxNodeSetFlagsResponse{})

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

type baseSocketWithCtxBindRequest struct {
	_    struct{} `fidl:"s" fidl_size_v1:"16" fidl_alignment_v1:"8"`
	Addr []uint8  `fidl_offset_v1:"0" fidl_bounds:"128"`
}

var _mbaseSocketWithCtxBindRequest = _bindings.CreateLazyMarshaler(baseSocketWithCtxBindRequest{})

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

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

var _mbaseSocketWithCtxBindResponse = _bindings.CreateLazyMarshaler(baseSocketWithCtxBindResponse{})

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

type baseSocketWithCtxConnectRequest struct {
	_    struct{} `fidl:"s" fidl_size_v1:"16" fidl_alignment_v1:"8"`
	Addr []uint8  `fidl_offset_v1:"0" fidl_bounds:"128"`
}

var _mbaseSocketWithCtxConnectRequest = _bindings.CreateLazyMarshaler(baseSocketWithCtxConnectRequest{})

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

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

var _mbaseSocketWithCtxConnectResponse = _bindings.CreateLazyMarshaler(baseSocketWithCtxConnectResponse{})

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

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

var _mbaseSocketWithCtxGetSockNameResponse = _bindings.CreateLazyMarshaler(baseSocketWithCtxGetSockNameResponse{})

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

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

var _mbaseSocketWithCtxGetPeerNameResponse = _bindings.CreateLazyMarshaler(baseSocketWithCtxGetPeerNameResponse{})

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

type baseSocketWithCtxSetSockOptRequest struct {
	_       struct{} `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8"`
	Level   int16    `fidl_offset_v1:"0"`
	Optname int16    `fidl_offset_v1:"2"`
	Optval  []uint8  `fidl_offset_v1:"8" fidl_bounds:"900"`
}

var _mbaseSocketWithCtxSetSockOptRequest = _bindings.CreateLazyMarshaler(baseSocketWithCtxSetSockOptRequest{})

func (msg *baseSocketWithCtxSetSockOptRequest) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxSetSockOptRequest
}

type baseSocketWithCtxSetSockOptResponse struct {
	_      struct{}                   `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8"`
	Result BaseSocketSetSockOptResult `fidl_offset_v1:"0"`
}

var _mbaseSocketWithCtxSetSockOptResponse = _bindings.CreateLazyMarshaler(baseSocketWithCtxSetSockOptResponse{})

func (msg *baseSocketWithCtxSetSockOptResponse) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxSetSockOptResponse
}

type baseSocketWithCtxGetSockOptRequest struct {
	_       struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8"`
	Level   int16    `fidl_offset_v1:"0"`
	Optname int16    `fidl_offset_v1:"2"`
}

var _mbaseSocketWithCtxGetSockOptRequest = _bindings.CreateLazyMarshaler(baseSocketWithCtxGetSockOptRequest{})

func (msg *baseSocketWithCtxGetSockOptRequest) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxGetSockOptRequest
}

type baseSocketWithCtxGetSockOptResponse struct {
	_      struct{}                   `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8"`
	Result BaseSocketGetSockOptResult `fidl_offset_v1:"0"`
}

var _mbaseSocketWithCtxGetSockOptResponse = _bindings.CreateLazyMarshaler(baseSocketWithCtxGetSockOptResponse{})

func (msg *baseSocketWithCtxGetSockOptResponse) Marshaler() _bindings.Marshaler {
	return _mbaseSocketWithCtxGetSockOptResponse
}

type datagramSocketWithCtxCloneRequest struct {
	_      struct{}                              `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8"`
	Flags  uint32                                `fidl_offset_v1:"0"`
	Object fuchsiaio.NodeWithCtxInterfaceRequest `fidl_offset_v1:"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"`
	S int32    `fidl_offset_v1:"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"`
	Info fuchsiaio.NodeInfo `fidl_offset_v1:"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"`
	S    int32               `fidl_offset_v1:"0"`
	Info *fuchsiaio.NodeInfo `fidl_offset_v1:"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"`
	S int32    `fidl_offset_v1:"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"`
	S          int32                    `fidl_offset_v1:"0"`
	Attributes fuchsiaio.NodeAttributes `fidl_offset_v1:"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"`
	Flags      uint32                   `fidl_offset_v1:"0"`
	Attributes fuchsiaio.NodeAttributes `fidl_offset_v1:"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"`
	S int32    `fidl_offset_v1:"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"`
	S     int32    `fidl_offset_v1:"0"`
	Flags uint32   `fidl_offset_v1:"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"`
	Flags uint32   `fidl_offset_v1:"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"`
	S int32    `fidl_offset_v1:"0"`
}

var _mdatagramSocketWithCtxNodeSetFlagsResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxNodeSetFlagsResponse{})

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

type datagramSocketWithCtxBindRequest struct {
	_    struct{} `fidl:"s" fidl_size_v1:"16" fidl_alignment_v1:"8"`
	Addr []uint8  `fidl_offset_v1:"0" fidl_bounds:"128"`
}

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"`
	Result BaseSocketBindResult `fidl_offset_v1:"0"`
}

var _mdatagramSocketWithCtxBindResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxBindResponse{})

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

type datagramSocketWithCtxConnectRequest struct {
	_    struct{} `fidl:"s" fidl_size_v1:"16" fidl_alignment_v1:"8"`
	Addr []uint8  `fidl_offset_v1:"0" fidl_bounds:"128"`
}

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"`
	Result BaseSocketConnectResult `fidl_offset_v1:"0"`
}

var _mdatagramSocketWithCtxConnectResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxConnectResponse{})

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

type datagramSocketWithCtxGetSockNameResponse struct {
	_      struct{}                    `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8"`
	Result BaseSocketGetSockNameResult `fidl_offset_v1:"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"`
	Result BaseSocketGetPeerNameResult `fidl_offset_v1:"0"`
}

var _mdatagramSocketWithCtxGetPeerNameResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxGetPeerNameResponse{})

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

type datagramSocketWithCtxSetSockOptRequest struct {
	_       struct{} `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8"`
	Level   int16    `fidl_offset_v1:"0"`
	Optname int16    `fidl_offset_v1:"2"`
	Optval  []uint8  `fidl_offset_v1:"8" fidl_bounds:"900"`
}

var _mdatagramSocketWithCtxSetSockOptRequest = _bindings.CreateLazyMarshaler(datagramSocketWithCtxSetSockOptRequest{})

func (msg *datagramSocketWithCtxSetSockOptRequest) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxSetSockOptRequest
}

type datagramSocketWithCtxSetSockOptResponse struct {
	_      struct{}                   `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8"`
	Result BaseSocketSetSockOptResult `fidl_offset_v1:"0"`
}

var _mdatagramSocketWithCtxSetSockOptResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxSetSockOptResponse{})

func (msg *datagramSocketWithCtxSetSockOptResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxSetSockOptResponse
}

type datagramSocketWithCtxGetSockOptRequest struct {
	_       struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8"`
	Level   int16    `fidl_offset_v1:"0"`
	Optname int16    `fidl_offset_v1:"2"`
}

var _mdatagramSocketWithCtxGetSockOptRequest = _bindings.CreateLazyMarshaler(datagramSocketWithCtxGetSockOptRequest{})

func (msg *datagramSocketWithCtxGetSockOptRequest) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxGetSockOptRequest
}

type datagramSocketWithCtxGetSockOptResponse struct {
	_      struct{}                   `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8"`
	Result BaseSocketGetSockOptResult `fidl_offset_v1:"0"`
}

var _mdatagramSocketWithCtxGetSockOptResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxGetSockOptResponse{})

func (msg *datagramSocketWithCtxGetSockOptResponse) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxGetSockOptResponse
}

type datagramSocketWithCtxShutdownRequest struct {
	_   struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8"`
	How int16    `fidl_offset_v1:"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"`
	Result DatagramSocketShutdownResult `fidl_offset_v1:"0"`
}

var _mdatagramSocketWithCtxShutdownResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxShutdownResponse{})

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

type datagramSocketWithCtxRecvMsgRequest struct {
	_          struct{} `fidl:"s" fidl_size_v1:"16" fidl_alignment_v1:"8"`
	AddrLen    uint32   `fidl_offset_v1:"0"`
	DataLen    uint32   `fidl_offset_v1:"4"`
	ControlLen uint32   `fidl_offset_v1:"8"`
	Flags      int16    `fidl_offset_v1:"12"`
}

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"`
	Result DatagramSocketRecvMsgResult `fidl_offset_v1:"0"`
}

var _mdatagramSocketWithCtxRecvMsgResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxRecvMsgResponse{})

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

type datagramSocketWithCtxSendMsgRequest struct {
	_       struct{}  `fidl:"s" fidl_size_v1:"56" fidl_alignment_v1:"8"`
	Addr    []uint8   `fidl_offset_v1:"0" fidl_bounds:"128"`
	Data    [][]uint8 `fidl_offset_v1:"16" fidl_bounds:""`
	Control []uint8   `fidl_offset_v1:"32" fidl_bounds:""`
	Flags   int16     `fidl_offset_v1:"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"`
	Result DatagramSocketSendMsgResult `fidl_offset_v1:"0"`
}

var _mdatagramSocketWithCtxSendMsgResponse = _bindings.CreateLazyMarshaler(datagramSocketWithCtxSendMsgResponse{})

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

type datagramSocketWithCtxSendMsg2Request struct {
	_       struct{} `fidl:"s" fidl_size_v1:"56" fidl_alignment_v1:"8"`
	Addr    []uint8  `fidl_offset_v1:"0" fidl_bounds:"128"`
	Data    []uint8  `fidl_offset_v1:"16" fidl_bounds:""`
	Control []uint8  `fidl_offset_v1:"32" fidl_bounds:""`
	Flags   int16    `fidl_offset_v1:"48"`
}

var _mdatagramSocketWithCtxSendMsg2Request = _bindings.CreateLazyMarshaler(datagramSocketWithCtxSendMsg2Request{})

func (msg *datagramSocketWithCtxSendMsg2Request) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxSendMsg2Request
}

type datagramSocketWithCtxSendMsg2Response struct {
	_      struct{}                     `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8"`
	Result DatagramSocketSendMsg2Result `fidl_offset_v1:"0"`
}

var _mdatagramSocketWithCtxSendMsg2Response = _bindings.CreateLazyMarshaler(datagramSocketWithCtxSendMsg2Response{})

func (msg *datagramSocketWithCtxSendMsg2Response) Marshaler() _bindings.Marshaler {
	return _mdatagramSocketWithCtxSendMsg2Response
}

type streamSocketWithCtxCloneRequest struct {
	_      struct{}                              `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8"`
	Flags  uint32                                `fidl_offset_v1:"0"`
	Object fuchsiaio.NodeWithCtxInterfaceRequest `fidl_offset_v1:"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"`
	S int32    `fidl_offset_v1:"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"`
	Info fuchsiaio.NodeInfo `fidl_offset_v1:"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"`
	S    int32               `fidl_offset_v1:"0"`
	Info *fuchsiaio.NodeInfo `fidl_offset_v1:"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"`
	S int32    `fidl_offset_v1:"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"`
	S          int32                    `fidl_offset_v1:"0"`
	Attributes fuchsiaio.NodeAttributes `fidl_offset_v1:"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"`
	Flags      uint32                   `fidl_offset_v1:"0"`
	Attributes fuchsiaio.NodeAttributes `fidl_offset_v1:"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"`
	S int32    `fidl_offset_v1:"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"`
	S     int32    `fidl_offset_v1:"0"`
	Flags uint32   `fidl_offset_v1:"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"`
	Flags uint32   `fidl_offset_v1:"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"`
	S int32    `fidl_offset_v1:"0"`
}

var _mstreamSocketWithCtxNodeSetFlagsResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxNodeSetFlagsResponse{})

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

type streamSocketWithCtxBindRequest struct {
	_    struct{} `fidl:"s" fidl_size_v1:"16" fidl_alignment_v1:"8"`
	Addr []uint8  `fidl_offset_v1:"0" fidl_bounds:"128"`
}

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"`
	Result BaseSocketBindResult `fidl_offset_v1:"0"`
}

var _mstreamSocketWithCtxBindResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxBindResponse{})

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

type streamSocketWithCtxConnectRequest struct {
	_    struct{} `fidl:"s" fidl_size_v1:"16" fidl_alignment_v1:"8"`
	Addr []uint8  `fidl_offset_v1:"0" fidl_bounds:"128"`
}

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"`
	Result BaseSocketConnectResult `fidl_offset_v1:"0"`
}

var _mstreamSocketWithCtxConnectResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxConnectResponse{})

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

type streamSocketWithCtxGetSockNameResponse struct {
	_      struct{}                    `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8"`
	Result BaseSocketGetSockNameResult `fidl_offset_v1:"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"`
	Result BaseSocketGetPeerNameResult `fidl_offset_v1:"0"`
}

var _mstreamSocketWithCtxGetPeerNameResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxGetPeerNameResponse{})

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

type streamSocketWithCtxSetSockOptRequest struct {
	_       struct{} `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8"`
	Level   int16    `fidl_offset_v1:"0"`
	Optname int16    `fidl_offset_v1:"2"`
	Optval  []uint8  `fidl_offset_v1:"8" fidl_bounds:"900"`
}

var _mstreamSocketWithCtxSetSockOptRequest = _bindings.CreateLazyMarshaler(streamSocketWithCtxSetSockOptRequest{})

func (msg *streamSocketWithCtxSetSockOptRequest) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxSetSockOptRequest
}

type streamSocketWithCtxSetSockOptResponse struct {
	_      struct{}                   `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8"`
	Result BaseSocketSetSockOptResult `fidl_offset_v1:"0"`
}

var _mstreamSocketWithCtxSetSockOptResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxSetSockOptResponse{})

func (msg *streamSocketWithCtxSetSockOptResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxSetSockOptResponse
}

type streamSocketWithCtxGetSockOptRequest struct {
	_       struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8"`
	Level   int16    `fidl_offset_v1:"0"`
	Optname int16    `fidl_offset_v1:"2"`
}

var _mstreamSocketWithCtxGetSockOptRequest = _bindings.CreateLazyMarshaler(streamSocketWithCtxGetSockOptRequest{})

func (msg *streamSocketWithCtxGetSockOptRequest) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxGetSockOptRequest
}

type streamSocketWithCtxGetSockOptResponse struct {
	_      struct{}                   `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8"`
	Result BaseSocketGetSockOptResult `fidl_offset_v1:"0"`
}

var _mstreamSocketWithCtxGetSockOptResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxGetSockOptResponse{})

func (msg *streamSocketWithCtxGetSockOptResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxGetSockOptResponse
}

type streamSocketWithCtxListenRequest struct {
	_       struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8"`
	Backlog int16    `fidl_offset_v1:"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"`
	Result StreamSocketListenResult `fidl_offset_v1:"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"`
	Flags int16    `fidl_offset_v1:"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"`
	Result StreamSocketAcceptResult `fidl_offset_v1:"0"`
}

var _mstreamSocketWithCtxAcceptResponse = _bindings.CreateLazyMarshaler(streamSocketWithCtxAcceptResponse{})

func (msg *streamSocketWithCtxAcceptResponse) Marshaler() _bindings.Marshaler {
	return _mstreamSocketWithCtxAcceptResponse
}

type providerWithCtxSocket2Request struct {
	_        struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8"`
	Domain   int16    `fidl_offset_v1:"0"`
	Type     int16    `fidl_offset_v1:"2"`
	Protocol int16    `fidl_offset_v1:"4"`
}

var _mproviderWithCtxSocket2Request = _bindings.CreateLazyMarshaler(providerWithCtxSocket2Request{})

func (msg *providerWithCtxSocket2Request) Marshaler() _bindings.Marshaler {
	return _mproviderWithCtxSocket2Request
}

type providerWithCtxSocket2Response struct {
	_      struct{}              `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8"`
	Result ProviderSocket2Result `fidl_offset_v1:"0"`
}

var _mproviderWithCtxSocket2Response = _bindings.CreateLazyMarshaler(providerWithCtxSocket2Response{})

func (msg *providerWithCtxSocket2Response) Marshaler() _bindings.Marshaler {
	return _mproviderWithCtxSocket2Response
}

type providerWithCtxInterfaceIndexToNameRequest struct {
	_     struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8"`
	Index uint64   `fidl_offset_v1:"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"`
	Result ProviderInterfaceIndexToNameResult `fidl_offset_v1:"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"`
	Name string   `fidl_offset_v1:"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"`
	Result ProviderInterfaceNameToIndexResult `fidl_offset_v1:"0"`
}

var _mproviderWithCtxInterfaceNameToIndexResponse = _bindings.CreateLazyMarshaler(providerWithCtxInterfaceNameToIndexResponse{})

func (msg *providerWithCtxInterfaceNameToIndexResponse) Marshaler() _bindings.Marshaler {
	return _mproviderWithCtxInterfaceNameToIndexResponse
}

type I_baseSocketBindResultTag uint64

const (
	BaseSocketBindResultResponse = 1 // 0x00000001
	BaseSocketBindResultErr      = 2 // 0x00000002
)

type BaseSocketBindResult struct {
	I_baseSocketBindResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8"`
	Response                  BaseSocketBindResponse `fidl_ordinal:"1"`
	Err                       int32                  `fidl_ordinal:"2"`
}

func (_m *BaseSocketBindResult) Which() I_baseSocketBindResultTag {
	return _m.I_baseSocketBindResultTag
}

func (_m *BaseSocketBindResult) Ordinal() uint64 {
	return uint64(_m.I_baseSocketBindResultTag)
}

func (_m *BaseSocketBindResult) SetResponse(response BaseSocketBindResponse) {
	_m.I_baseSocketBindResultTag = BaseSocketBindResultResponse
	_m.Response = response
}

func BaseSocketBindResultWithResponse(response BaseSocketBindResponse) BaseSocketBindResult {
	var _u BaseSocketBindResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseSocketBindResult) SetErr(err int32) {
	_m.I_baseSocketBindResultTag = BaseSocketBindResultErr
	_m.Err = err
}

func BaseSocketBindResultWithErr(err int32) BaseSocketBindResult {
	var _u BaseSocketBindResult
	_u.SetErr(err)
	return _u
}

type I_baseSocketConnectResultTag uint64

const (
	BaseSocketConnectResultResponse = 1 // 0x00000001
	BaseSocketConnectResultErr      = 2 // 0x00000002
)

type BaseSocketConnectResult struct {
	I_baseSocketConnectResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8"`
	Response                     BaseSocketConnectResponse `fidl_ordinal:"1"`
	Err                          int32                     `fidl_ordinal:"2"`
}

func (_m *BaseSocketConnectResult) Which() I_baseSocketConnectResultTag {
	return _m.I_baseSocketConnectResultTag
}

func (_m *BaseSocketConnectResult) Ordinal() uint64 {
	return uint64(_m.I_baseSocketConnectResultTag)
}

func (_m *BaseSocketConnectResult) SetResponse(response BaseSocketConnectResponse) {
	_m.I_baseSocketConnectResultTag = BaseSocketConnectResultResponse
	_m.Response = response
}

func BaseSocketConnectResultWithResponse(response BaseSocketConnectResponse) BaseSocketConnectResult {
	var _u BaseSocketConnectResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseSocketConnectResult) SetErr(err int32) {
	_m.I_baseSocketConnectResultTag = BaseSocketConnectResultErr
	_m.Err = err
}

func BaseSocketConnectResultWithErr(err int32) BaseSocketConnectResult {
	var _u BaseSocketConnectResult
	_u.SetErr(err)
	return _u
}

type I_baseSocketGetSockNameResultTag uint64

const (
	BaseSocketGetSockNameResultResponse = 1 // 0x00000001
	BaseSocketGetSockNameResultErr      = 2 // 0x00000002
)

type BaseSocketGetSockNameResult struct {
	I_baseSocketGetSockNameResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8"`
	Response                         BaseSocketGetSockNameResponse `fidl_ordinal:"1"`
	Err                              int32                         `fidl_ordinal:"2"`
}

func (_m *BaseSocketGetSockNameResult) Which() I_baseSocketGetSockNameResultTag {
	return _m.I_baseSocketGetSockNameResultTag
}

func (_m *BaseSocketGetSockNameResult) Ordinal() uint64 {
	return uint64(_m.I_baseSocketGetSockNameResultTag)
}

func (_m *BaseSocketGetSockNameResult) SetResponse(response BaseSocketGetSockNameResponse) {
	_m.I_baseSocketGetSockNameResultTag = BaseSocketGetSockNameResultResponse
	_m.Response = response
}

func BaseSocketGetSockNameResultWithResponse(response BaseSocketGetSockNameResponse) BaseSocketGetSockNameResult {
	var _u BaseSocketGetSockNameResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseSocketGetSockNameResult) SetErr(err int32) {
	_m.I_baseSocketGetSockNameResultTag = BaseSocketGetSockNameResultErr
	_m.Err = err
}

func BaseSocketGetSockNameResultWithErr(err int32) BaseSocketGetSockNameResult {
	var _u BaseSocketGetSockNameResult
	_u.SetErr(err)
	return _u
}

type I_baseSocketGetPeerNameResultTag uint64

const (
	BaseSocketGetPeerNameResultResponse = 1 // 0x00000001
	BaseSocketGetPeerNameResultErr      = 2 // 0x00000002
)

type BaseSocketGetPeerNameResult struct {
	I_baseSocketGetPeerNameResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8"`
	Response                         BaseSocketGetPeerNameResponse `fidl_ordinal:"1"`
	Err                              int32                         `fidl_ordinal:"2"`
}

func (_m *BaseSocketGetPeerNameResult) Which() I_baseSocketGetPeerNameResultTag {
	return _m.I_baseSocketGetPeerNameResultTag
}

func (_m *BaseSocketGetPeerNameResult) Ordinal() uint64 {
	return uint64(_m.I_baseSocketGetPeerNameResultTag)
}

func (_m *BaseSocketGetPeerNameResult) SetResponse(response BaseSocketGetPeerNameResponse) {
	_m.I_baseSocketGetPeerNameResultTag = BaseSocketGetPeerNameResultResponse
	_m.Response = response
}

func BaseSocketGetPeerNameResultWithResponse(response BaseSocketGetPeerNameResponse) BaseSocketGetPeerNameResult {
	var _u BaseSocketGetPeerNameResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseSocketGetPeerNameResult) SetErr(err int32) {
	_m.I_baseSocketGetPeerNameResultTag = BaseSocketGetPeerNameResultErr
	_m.Err = err
}

func BaseSocketGetPeerNameResultWithErr(err int32) BaseSocketGetPeerNameResult {
	var _u BaseSocketGetPeerNameResult
	_u.SetErr(err)
	return _u
}

type I_baseSocketSetSockOptResultTag uint64

const (
	BaseSocketSetSockOptResultResponse = 1 // 0x00000001
	BaseSocketSetSockOptResultErr      = 2 // 0x00000002
)

type BaseSocketSetSockOptResult struct {
	I_baseSocketSetSockOptResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8"`
	Response                        BaseSocketSetSockOptResponse `fidl_ordinal:"1"`
	Err                             int32                        `fidl_ordinal:"2"`
}

func (_m *BaseSocketSetSockOptResult) Which() I_baseSocketSetSockOptResultTag {
	return _m.I_baseSocketSetSockOptResultTag
}

func (_m *BaseSocketSetSockOptResult) Ordinal() uint64 {
	return uint64(_m.I_baseSocketSetSockOptResultTag)
}

func (_m *BaseSocketSetSockOptResult) SetResponse(response BaseSocketSetSockOptResponse) {
	_m.I_baseSocketSetSockOptResultTag = BaseSocketSetSockOptResultResponse
	_m.Response = response
}

func BaseSocketSetSockOptResultWithResponse(response BaseSocketSetSockOptResponse) BaseSocketSetSockOptResult {
	var _u BaseSocketSetSockOptResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseSocketSetSockOptResult) SetErr(err int32) {
	_m.I_baseSocketSetSockOptResultTag = BaseSocketSetSockOptResultErr
	_m.Err = err
}

func BaseSocketSetSockOptResultWithErr(err int32) BaseSocketSetSockOptResult {
	var _u BaseSocketSetSockOptResult
	_u.SetErr(err)
	return _u
}

type I_baseSocketGetSockOptResultTag uint64

const (
	BaseSocketGetSockOptResultResponse = 1 // 0x00000001
	BaseSocketGetSockOptResultErr      = 2 // 0x00000002
)

type BaseSocketGetSockOptResult struct {
	I_baseSocketGetSockOptResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8"`
	Response                        BaseSocketGetSockOptResponse `fidl_ordinal:"1"`
	Err                             int32                        `fidl_ordinal:"2"`
}

func (_m *BaseSocketGetSockOptResult) Which() I_baseSocketGetSockOptResultTag {
	return _m.I_baseSocketGetSockOptResultTag
}

func (_m *BaseSocketGetSockOptResult) Ordinal() uint64 {
	return uint64(_m.I_baseSocketGetSockOptResultTag)
}

func (_m *BaseSocketGetSockOptResult) SetResponse(response BaseSocketGetSockOptResponse) {
	_m.I_baseSocketGetSockOptResultTag = BaseSocketGetSockOptResultResponse
	_m.Response = response
}

func BaseSocketGetSockOptResultWithResponse(response BaseSocketGetSockOptResponse) BaseSocketGetSockOptResult {
	var _u BaseSocketGetSockOptResult
	_u.SetResponse(response)
	return _u
}

func (_m *BaseSocketGetSockOptResult) SetErr(err int32) {
	_m.I_baseSocketGetSockOptResultTag = BaseSocketGetSockOptResultErr
	_m.Err = err
}

func BaseSocketGetSockOptResultWithErr(err int32) BaseSocketGetSockOptResult {
	var _u BaseSocketGetSockOptResult
	_u.SetErr(err)
	return _u
}

type I_datagramSocketShutdownResultTag uint64

const (
	DatagramSocketShutdownResultResponse = 1 // 0x00000001
	DatagramSocketShutdownResultErr      = 2 // 0x00000002
)

type DatagramSocketShutdownResult struct {
	I_datagramSocketShutdownResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8"`
	Response                          DatagramSocketShutdownResponse `fidl_ordinal:"1"`
	Err                               int32                          `fidl_ordinal:"2"`
}

func (_m *DatagramSocketShutdownResult) Which() I_datagramSocketShutdownResultTag {
	return _m.I_datagramSocketShutdownResultTag
}

func (_m *DatagramSocketShutdownResult) Ordinal() uint64 {
	return uint64(_m.I_datagramSocketShutdownResultTag)
}

func (_m *DatagramSocketShutdownResult) SetResponse(response DatagramSocketShutdownResponse) {
	_m.I_datagramSocketShutdownResultTag = DatagramSocketShutdownResultResponse
	_m.Response = response
}

func DatagramSocketShutdownResultWithResponse(response DatagramSocketShutdownResponse) DatagramSocketShutdownResult {
	var _u DatagramSocketShutdownResult
	_u.SetResponse(response)
	return _u
}

func (_m *DatagramSocketShutdownResult) SetErr(err int32) {
	_m.I_datagramSocketShutdownResultTag = DatagramSocketShutdownResultErr
	_m.Err = err
}

func DatagramSocketShutdownResultWithErr(err int32) DatagramSocketShutdownResult {
	var _u DatagramSocketShutdownResult
	_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"`
	Response                         DatagramSocketRecvMsgResponse `fidl_ordinal:"1"`
	Err                              int32                         `fidl_ordinal:"2"`
}

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.I_datagramSocketRecvMsgResultTag = DatagramSocketRecvMsgResultResponse
	_m.Response = response
}

func DatagramSocketRecvMsgResultWithResponse(response DatagramSocketRecvMsgResponse) DatagramSocketRecvMsgResult {
	var _u DatagramSocketRecvMsgResult
	_u.SetResponse(response)
	return _u
}

func (_m *DatagramSocketRecvMsgResult) SetErr(err int32) {
	_m.I_datagramSocketRecvMsgResultTag = DatagramSocketRecvMsgResultErr
	_m.Err = err
}

func DatagramSocketRecvMsgResultWithErr(err int32) 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"`
	Response                         DatagramSocketSendMsgResponse `fidl_ordinal:"1"`
	Err                              int32                         `fidl_ordinal:"2"`
}

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.I_datagramSocketSendMsgResultTag = DatagramSocketSendMsgResultResponse
	_m.Response = response
}

func DatagramSocketSendMsgResultWithResponse(response DatagramSocketSendMsgResponse) DatagramSocketSendMsgResult {
	var _u DatagramSocketSendMsgResult
	_u.SetResponse(response)
	return _u
}

func (_m *DatagramSocketSendMsgResult) SetErr(err int32) {
	_m.I_datagramSocketSendMsgResultTag = DatagramSocketSendMsgResultErr
	_m.Err = err
}

func DatagramSocketSendMsgResultWithErr(err int32) DatagramSocketSendMsgResult {
	var _u DatagramSocketSendMsgResult
	_u.SetErr(err)
	return _u
}

type I_datagramSocketSendMsg2ResultTag uint64

const (
	DatagramSocketSendMsg2ResultResponse = 1 // 0x00000001
	DatagramSocketSendMsg2ResultErr      = 2 // 0x00000002
)

type DatagramSocketSendMsg2Result struct {
	I_datagramSocketSendMsg2ResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8"`
	Response                          DatagramSocketSendMsg2Response `fidl_ordinal:"1"`
	Err                               int32                          `fidl_ordinal:"2"`
}

func (_m *DatagramSocketSendMsg2Result) Which() I_datagramSocketSendMsg2ResultTag {
	return _m.I_datagramSocketSendMsg2ResultTag
}

func (_m *DatagramSocketSendMsg2Result) Ordinal() uint64 {
	return uint64(_m.I_datagramSocketSendMsg2ResultTag)
}

func (_m *DatagramSocketSendMsg2Result) SetResponse(response DatagramSocketSendMsg2Response) {
	_m.I_datagramSocketSendMsg2ResultTag = DatagramSocketSendMsg2ResultResponse
	_m.Response = response
}

func DatagramSocketSendMsg2ResultWithResponse(response DatagramSocketSendMsg2Response) DatagramSocketSendMsg2Result {
	var _u DatagramSocketSendMsg2Result
	_u.SetResponse(response)
	return _u
}

func (_m *DatagramSocketSendMsg2Result) SetErr(err int32) {
	_m.I_datagramSocketSendMsg2ResultTag = DatagramSocketSendMsg2ResultErr
	_m.Err = err
}

func DatagramSocketSendMsg2ResultWithErr(err int32) DatagramSocketSendMsg2Result {
	var _u DatagramSocketSendMsg2Result
	_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"`
	Response                      StreamSocketListenResponse `fidl_ordinal:"1"`
	Err                           int32                      `fidl_ordinal:"2"`
}

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.I_streamSocketListenResultTag = StreamSocketListenResultResponse
	_m.Response = response
}

func StreamSocketListenResultWithResponse(response StreamSocketListenResponse) StreamSocketListenResult {
	var _u StreamSocketListenResult
	_u.SetResponse(response)
	return _u
}

func (_m *StreamSocketListenResult) SetErr(err int32) {
	_m.I_streamSocketListenResultTag = StreamSocketListenResultErr
	_m.Err = err
}

func StreamSocketListenResultWithErr(err int32) 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"`
	Response                      StreamSocketAcceptResponse `fidl_ordinal:"1"`
	Err                           int32                      `fidl_ordinal:"2"`
}

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.I_streamSocketAcceptResultTag = StreamSocketAcceptResultResponse
	_m.Response = response
}

func StreamSocketAcceptResultWithResponse(response StreamSocketAcceptResponse) StreamSocketAcceptResult {
	var _u StreamSocketAcceptResult
	_u.SetResponse(response)
	return _u
}

func (_m *StreamSocketAcceptResult) SetErr(err int32) {
	_m.I_streamSocketAcceptResultTag = StreamSocketAcceptResultErr
	_m.Err = err
}

func StreamSocketAcceptResultWithErr(err int32) StreamSocketAcceptResult {
	var _u StreamSocketAcceptResult
	_u.SetErr(err)
	return _u
}

type I_providerSocket2ResultTag uint64

const (
	ProviderSocket2ResultResponse = 1 // 0x00000001
	ProviderSocket2ResultErr      = 2 // 0x00000002
)

type ProviderSocket2Result struct {
	I_providerSocket2ResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8"`
	Response                   ProviderSocket2Response `fidl_ordinal:"1"`
	Err                        int32                   `fidl_ordinal:"2"`
}

func (_m *ProviderSocket2Result) Which() I_providerSocket2ResultTag {
	return _m.I_providerSocket2ResultTag
}

func (_m *ProviderSocket2Result) Ordinal() uint64 {
	return uint64(_m.I_providerSocket2ResultTag)
}

func (_m *ProviderSocket2Result) SetResponse(response ProviderSocket2Response) {
	_m.I_providerSocket2ResultTag = ProviderSocket2ResultResponse
	_m.Response = response
}

func ProviderSocket2ResultWithResponse(response ProviderSocket2Response) ProviderSocket2Result {
	var _u ProviderSocket2Result
	_u.SetResponse(response)
	return _u
}

func (_m *ProviderSocket2Result) SetErr(err int32) {
	_m.I_providerSocket2ResultTag = ProviderSocket2ResultErr
	_m.Err = err
}

func ProviderSocket2ResultWithErr(err int32) ProviderSocket2Result {
	var _u ProviderSocket2Result
	_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"`
	Response                                ProviderInterfaceIndexToNameResponse `fidl_ordinal:"1"`
	Err                                     int32                                `fidl_ordinal:"2"`
}

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.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.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"`
	Response                                ProviderInterfaceNameToIndexResponse `fidl_ordinal:"1"`
	Err                                     int32                                `fidl_ordinal:"2"`
}

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.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.I_providerInterfaceNameToIndexResultTag = ProviderInterfaceNameToIndexResultErr
	_m.Err = err
}

func ProviderInterfaceNameToIndexResultWithErr(err int32) ProviderInterfaceNameToIndexResult {
	var _u ProviderInterfaceNameToIndexResult
	_u.SetErr(err)
	return _u
}

const (
	BaseSocketCloneOrdinal           uint64 = 0x17fe6a4c00000000
	BaseSocketCloneGenOrdinal        uint64 = 0x5a61678f293ce16f
	BaseSocketCloseOrdinal           uint64 = 0x52b9568700000000
	BaseSocketCloseGenOrdinal        uint64 = 0x5309c5bd1c33dc44
	BaseSocketDescribeOrdinal        uint64 = 0x1f62df5e00000000
	BaseSocketDescribeGenOrdinal     uint64 = 0xffcec215078dea0
	BaseSocketOnOpenOrdinal          uint64 = 0x4700a7bd00000000
	BaseSocketOnOpenGenOrdinal       uint64 = 0x7fc7bbb1dbfd1972
	BaseSocketSyncOrdinal            uint64 = 0x62423faa00000000
	BaseSocketSyncGenOrdinal         uint64 = 0x189d88326c18b519
	BaseSocketGetAttrOrdinal         uint64 = 0x4585e7c800000000
	BaseSocketGetAttrGenOrdinal      uint64 = 0x78985e216314dafd
	BaseSocketSetAttrOrdinal         uint64 = 0xbd5559a00000000
	BaseSocketSetAttrGenOrdinal      uint64 = 0x4186c0f40d938f46
	BaseSocketNodeGetFlagsOrdinal    uint64 = 0x3c24c22300000000
	BaseSocketNodeGetFlagsGenOrdinal uint64 = 0x5b88fffb8eda3aa1
	BaseSocketNodeSetFlagsOrdinal    uint64 = 0x46940c1600000000
	BaseSocketNodeSetFlagsGenOrdinal uint64 = 0x5295b76c71fde733
	BaseSocketBindOrdinal            uint64 = 0x11ebbc3c00000000
	BaseSocketBindGenOrdinal         uint64 = 0xf8457e6b05e15bc
	BaseSocketConnectOrdinal         uint64 = 0x62cb94300000000
	BaseSocketConnectGenOrdinal      uint64 = 0x17abeee0b9843bb1
	BaseSocketGetSockNameOrdinal     uint64 = 0x7c14255c00000000
	BaseSocketGetSockNameGenOrdinal  uint64 = 0x41a618ef19a91f9d
	BaseSocketGetPeerNameOrdinal     uint64 = 0x4beee9b000000000
	BaseSocketGetPeerNameGenOrdinal  uint64 = 0x4009d08a4beb5e95
	BaseSocketSetSockOptOrdinal      uint64 = 0x497c444100000000
	BaseSocketSetSockOptGenOrdinal   uint64 = 0x93c6f802203e6f1
	BaseSocketGetSockOptOrdinal      uint64 = 0x3b2b8b3d00000000
	BaseSocketGetSockOptGenOrdinal   uint64 = 0x6dfaf70f0ed40544
)

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.
// 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(BaseSocketCloneGenOrdinal, 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(BaseSocketCloseGenOrdinal, req_, resp_, BaseSocketCloseOrdinal, BaseSocketCloseGenOrdinal)
	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(BaseSocketDescribeGenOrdinal, req_, resp_, BaseSocketDescribeOrdinal, BaseSocketDescribeGenOrdinal)
	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_, BaseSocketOnOpenGenOrdinal)
	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(BaseSocketSyncGenOrdinal, req_, resp_, BaseSocketSyncOrdinal, BaseSocketSyncGenOrdinal)
	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(BaseSocketGetAttrGenOrdinal, req_, resp_, BaseSocketGetAttrOrdinal, BaseSocketGetAttrGenOrdinal)
	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`.
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(BaseSocketSetAttrGenOrdinal, req_, resp_, BaseSocketSetAttrOrdinal, BaseSocketSetAttrGenOrdinal)
	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(BaseSocketNodeGetFlagsGenOrdinal, req_, resp_, BaseSocketNodeGetFlagsOrdinal, BaseSocketNodeGetFlagsGenOrdinal)
	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(BaseSocketNodeSetFlagsGenOrdinal, req_, resp_, BaseSocketNodeSetFlagsOrdinal, BaseSocketNodeSetFlagsGenOrdinal)
	return resp_.S, err_
}

// Sets the local address used for the socket.
func (p *BaseSocketWithCtxInterface) Bind(ctx_ _bindings.Context, addr []uint8) (BaseSocketBindResult, error) {
	req_ := &baseSocketWithCtxBindRequest{
		Addr: addr,
	}
	resp_ := &baseSocketWithCtxBindResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketBindGenOrdinal, req_, resp_, BaseSocketBindOrdinal, BaseSocketBindGenOrdinal)
	return resp_.Result, err_
}

// Initiates a connection to a remote address.
func (p *BaseSocketWithCtxInterface) Connect(ctx_ _bindings.Context, addr []uint8) (BaseSocketConnectResult, error) {
	req_ := &baseSocketWithCtxConnectRequest{
		Addr: addr,
	}
	resp_ := &baseSocketWithCtxConnectResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketConnectGenOrdinal, req_, resp_, BaseSocketConnectOrdinal, BaseSocketConnectGenOrdinal)
	return resp_.Result, err_
}

// Retrieves the local socket address.
func (p *BaseSocketWithCtxInterface) GetSockName(ctx_ _bindings.Context) (BaseSocketGetSockNameResult, error) {
	var req_ _bindings.Message
	resp_ := &baseSocketWithCtxGetSockNameResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketGetSockNameGenOrdinal, req_, resp_, BaseSocketGetSockNameOrdinal, BaseSocketGetSockNameGenOrdinal)
	return resp_.Result, err_
}

// Retrieves the remote socket address.
func (p *BaseSocketWithCtxInterface) GetPeerName(ctx_ _bindings.Context) (BaseSocketGetPeerNameResult, error) {
	var req_ _bindings.Message
	resp_ := &baseSocketWithCtxGetPeerNameResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketGetPeerNameGenOrdinal, req_, resp_, BaseSocketGetPeerNameOrdinal, BaseSocketGetPeerNameGenOrdinal)
	return resp_.Result, err_
}

// Sets the value of a socket option.
func (p *BaseSocketWithCtxInterface) SetSockOpt(ctx_ _bindings.Context, level int16, optname int16, optval []uint8) (BaseSocketSetSockOptResult, error) {
	req_ := &baseSocketWithCtxSetSockOptRequest{
		Level:   level,
		Optname: optname,
		Optval:  optval,
	}
	resp_ := &baseSocketWithCtxSetSockOptResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketSetSockOptGenOrdinal, req_, resp_, BaseSocketSetSockOptOrdinal, BaseSocketSetSockOptGenOrdinal)
	return resp_.Result, err_
}

// Retrieves the value of a socket option.
func (p *BaseSocketWithCtxInterface) GetSockOpt(ctx_ _bindings.Context, level int16, optname int16) (BaseSocketGetSockOptResult, error) {
	req_ := &baseSocketWithCtxGetSockOptRequest{
		Level:   level,
		Optname: optname,
	}
	resp_ := &baseSocketWithCtxGetSockOptResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketGetSockOptGenOrdinal, req_, resp_, BaseSocketGetSockOptOrdinal, BaseSocketGetSockOptGenOrdinal)
	return resp_.Result, err_
}

// A network socket.
//
// Once a socket has been retrieved from a `Provider`, this interface is then used to further
// configure and use the socket. This interface is essentially POSIX. Its implementation must
// support Linux-specific arguments to {Get,Set}SockOpt.
//
// All methods on this type are nonblocking; their exact behaviors match their Linux counterparts.
//
// *Warning:* This protocol is not yet ready for direct use by clients. Instead, clients should
// use the BSD sockets API to interact with sockets. We plan to change this protocol substantially
// and clients that couple directly to this protocol will make those changes more difficult.
type BaseSocketWithCtx interface {
	// Create another connection to the same remote object.
	//
	// `flags` may be any of:
	//
	// - `OPEN_RIGHT_*`
	// - `OPEN_FLAG_APPEND`
	// - `OPEN_FLAG_NO_REMOTE`
	// - `OPEN_FLAG_DESCRIBE`
	// - `CLONE_FLAG_SAME_RIGHTS`
	//
	// All other flags are ignored.
	//
	// The `OPEN_RIGHT_*` bits in `flags` request corresponding rights over the resulting
	// cloned object.
	// The cloned object must have rights less than or equal to the original object.
	// 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`.
	SetAttr(ctx_ _bindings.Context, flags uint32, attributes fuchsiaio.NodeAttributes) (int32, error)
	// Acquires the `Directory.Open` rights and flags used to access this file.
	//
	// This method does not require any rights.
	// This method has the same functionality as GetFlags for File and is
	// meant as an in-progress replacement.
	NodeGetFlags(ctx_ _bindings.Context) (int32, uint32, error)
	// Changes the `Directory.Open` flags used to access the file.
	// Supported flags which can be turned on / off:
	// - `OPEN_FLAG_APPEND`
	//
	// This method does not require any rights.
	// This method has the same functionality as SetFlags for File and is
	// meant as an in-progress replacement.
	NodeSetFlags(ctx_ _bindings.Context, flags uint32) (int32, error)
	// Sets the local address used for the socket.
	Bind(ctx_ _bindings.Context, addr []uint8) (BaseSocketBindResult, error)
	// Initiates a connection to a remote address.
	Connect(ctx_ _bindings.Context, addr []uint8) (BaseSocketConnectResult, error)
	// Retrieves the local socket address.
	GetSockName(ctx_ _bindings.Context) (BaseSocketGetSockNameResult, error)
	// Retrieves the remote socket address.
	GetPeerName(ctx_ _bindings.Context) (BaseSocketGetPeerNameResult, error)
	// Sets the value of a socket option.
	SetSockOpt(ctx_ _bindings.Context, level int16, optname int16, optval []uint8) (BaseSocketSetSockOptResult, error)
	// Retrieves the value of a socket option.
	GetSockOpt(ctx_ _bindings.Context, level int16, optname int16) (BaseSocketGetSockOptResult, 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:
		fallthrough
	case BaseSocketCloneGenOrdinal:
		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:
		fallthrough
	case BaseSocketCloseGenOrdinal:
		s, err_ := s_.Impl.Close(args_.Ctx)
		out_ := baseSocketWithCtxCloseResponse{}
		out_.S = s
		return &out_, true, err_
	case BaseSocketDescribeOrdinal:
		fallthrough
	case BaseSocketDescribeGenOrdinal:
		info, err_ := s_.Impl.Describe(args_.Ctx)
		out_ := baseSocketWithCtxDescribeResponse{}
		out_.Info = info
		return &out_, true, err_
	case BaseSocketSyncOrdinal:
		fallthrough
	case BaseSocketSyncGenOrdinal:
		s, err_ := s_.Impl.Sync(args_.Ctx)
		out_ := baseSocketWithCtxSyncResponse{}
		out_.S = s
		return &out_, true, err_
	case BaseSocketGetAttrOrdinal:
		fallthrough
	case BaseSocketGetAttrGenOrdinal:
		s, attributes, err_ := s_.Impl.GetAttr(args_.Ctx)
		out_ := baseSocketWithCtxGetAttrResponse{}
		out_.S = s
		out_.Attributes = attributes
		return &out_, true, err_
	case BaseSocketSetAttrOrdinal:
		fallthrough
	case BaseSocketSetAttrGenOrdinal:
		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:
		fallthrough
	case BaseSocketNodeGetFlagsGenOrdinal:
		s, flags, err_ := s_.Impl.NodeGetFlags(args_.Ctx)
		out_ := baseSocketWithCtxNodeGetFlagsResponse{}
		out_.S = s
		out_.Flags = flags
		return &out_, true, err_
	case BaseSocketNodeSetFlagsOrdinal:
		fallthrough
	case BaseSocketNodeSetFlagsGenOrdinal:
		in_ := baseSocketWithCtxNodeSetFlagsRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		s, err_ := s_.Impl.NodeSetFlags(args_.Ctx, in_.Flags)
		out_ := baseSocketWithCtxNodeSetFlagsResponse{}
		out_.S = s
		return &out_, true, err_
	case BaseSocketBindOrdinal:
		fallthrough
	case BaseSocketBindGenOrdinal:
		in_ := baseSocketWithCtxBindRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.Bind(args_.Ctx, in_.Addr)
		out_ := baseSocketWithCtxBindResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseSocketConnectOrdinal:
		fallthrough
	case BaseSocketConnectGenOrdinal:
		in_ := baseSocketWithCtxConnectRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.Connect(args_.Ctx, in_.Addr)
		out_ := baseSocketWithCtxConnectResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseSocketGetSockNameOrdinal:
		fallthrough
	case BaseSocketGetSockNameGenOrdinal:
		result, err_ := s_.Impl.GetSockName(args_.Ctx)
		out_ := baseSocketWithCtxGetSockNameResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseSocketGetPeerNameOrdinal:
		fallthrough
	case BaseSocketGetPeerNameGenOrdinal:
		result, err_ := s_.Impl.GetPeerName(args_.Ctx)
		out_ := baseSocketWithCtxGetPeerNameResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseSocketSetSockOptOrdinal:
		fallthrough
	case BaseSocketSetSockOptGenOrdinal:
		in_ := baseSocketWithCtxSetSockOptRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.SetSockOpt(args_.Ctx, in_.Level, in_.Optname, in_.Optval)
		out_ := baseSocketWithCtxSetSockOptResponse{}
		out_.Result = result
		return &out_, true, err_
	case BaseSocketGetSockOptOrdinal:
		fallthrough
	case BaseSocketGetSockOptGenOrdinal:
		in_ := baseSocketWithCtxGetSockOptRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.GetSockOpt(args_.Ctx, in_.Level, in_.Optname)
		out_ := baseSocketWithCtxGetSockOptResponse{}
		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(BaseSocketOnOpenGenOrdinal, event_)
}

const (
	DatagramSocketCloneOrdinal           uint64 = 0x17fe6a4c00000000
	DatagramSocketCloneGenOrdinal        uint64 = 0x5a61678f293ce16f
	DatagramSocketCloseOrdinal           uint64 = 0x52b9568700000000
	DatagramSocketCloseGenOrdinal        uint64 = 0x5309c5bd1c33dc44
	DatagramSocketDescribeOrdinal        uint64 = 0x1f62df5e00000000
	DatagramSocketDescribeGenOrdinal     uint64 = 0xffcec215078dea0
	DatagramSocketOnOpenOrdinal          uint64 = 0x4700a7bd00000000
	DatagramSocketOnOpenGenOrdinal       uint64 = 0x7fc7bbb1dbfd1972
	DatagramSocketSyncOrdinal            uint64 = 0x62423faa00000000
	DatagramSocketSyncGenOrdinal         uint64 = 0x189d88326c18b519
	DatagramSocketGetAttrOrdinal         uint64 = 0x4585e7c800000000
	DatagramSocketGetAttrGenOrdinal      uint64 = 0x78985e216314dafd
	DatagramSocketSetAttrOrdinal         uint64 = 0xbd5559a00000000
	DatagramSocketSetAttrGenOrdinal      uint64 = 0x4186c0f40d938f46
	DatagramSocketNodeGetFlagsOrdinal    uint64 = 0x3c24c22300000000
	DatagramSocketNodeGetFlagsGenOrdinal uint64 = 0x5b88fffb8eda3aa1
	DatagramSocketNodeSetFlagsOrdinal    uint64 = 0x46940c1600000000
	DatagramSocketNodeSetFlagsGenOrdinal uint64 = 0x5295b76c71fde733
	DatagramSocketBindOrdinal            uint64 = 0x11ebbc3c00000000
	DatagramSocketBindGenOrdinal         uint64 = 0xf8457e6b05e15bc
	DatagramSocketConnectOrdinal         uint64 = 0x62cb94300000000
	DatagramSocketConnectGenOrdinal      uint64 = 0x17abeee0b9843bb1
	DatagramSocketGetSockNameOrdinal     uint64 = 0x7c14255c00000000
	DatagramSocketGetSockNameGenOrdinal  uint64 = 0x41a618ef19a91f9d
	DatagramSocketGetPeerNameOrdinal     uint64 = 0x4beee9b000000000
	DatagramSocketGetPeerNameGenOrdinal  uint64 = 0x4009d08a4beb5e95
	DatagramSocketSetSockOptOrdinal      uint64 = 0x497c444100000000
	DatagramSocketSetSockOptGenOrdinal   uint64 = 0x93c6f802203e6f1
	DatagramSocketGetSockOptOrdinal      uint64 = 0x3b2b8b3d00000000
	DatagramSocketGetSockOptGenOrdinal   uint64 = 0x6dfaf70f0ed40544
	DatagramSocketShutdownOrdinal        uint64 = 0x6d3a731c00000000
	DatagramSocketShutdownGenOrdinal     uint64 = 0x3c6058976bced940
	DatagramSocketRecvMsgOrdinal         uint64 = 0x50d7e5d00000000
	DatagramSocketRecvMsgGenOrdinal      uint64 = 0x715341bb02f02b7a
	DatagramSocketSendMsgOrdinal         uint64 = 0x3e2187f300000000
	DatagramSocketSendMsgGenOrdinal      uint64 = 0x359b626d62a7f17b
	DatagramSocketSendMsg2Ordinal        uint64 = 0x50f95f3d00000000
	DatagramSocketSendMsg2GenOrdinal     uint64 = 0x61692c8939cf74dd
)

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.
// 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(DatagramSocketCloneGenOrdinal, 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(DatagramSocketCloseGenOrdinal, req_, resp_, DatagramSocketCloseOrdinal, DatagramSocketCloseGenOrdinal)
	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(DatagramSocketDescribeGenOrdinal, req_, resp_, DatagramSocketDescribeOrdinal, DatagramSocketDescribeGenOrdinal)
	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_, DatagramSocketOnOpenGenOrdinal)
	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(DatagramSocketSyncGenOrdinal, req_, resp_, DatagramSocketSyncOrdinal, DatagramSocketSyncGenOrdinal)
	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(DatagramSocketGetAttrGenOrdinal, req_, resp_, DatagramSocketGetAttrOrdinal, DatagramSocketGetAttrGenOrdinal)
	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`.
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(DatagramSocketSetAttrGenOrdinal, req_, resp_, DatagramSocketSetAttrOrdinal, DatagramSocketSetAttrGenOrdinal)
	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(DatagramSocketNodeGetFlagsGenOrdinal, req_, resp_, DatagramSocketNodeGetFlagsOrdinal, DatagramSocketNodeGetFlagsGenOrdinal)
	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(DatagramSocketNodeSetFlagsGenOrdinal, req_, resp_, DatagramSocketNodeSetFlagsOrdinal, DatagramSocketNodeSetFlagsGenOrdinal)
	return resp_.S, err_
}

// Sets the local address used for the socket.
func (p *DatagramSocketWithCtxInterface) Bind(ctx_ _bindings.Context, addr []uint8) (BaseSocketBindResult, error) {
	req_ := &datagramSocketWithCtxBindRequest{
		Addr: addr,
	}
	resp_ := &datagramSocketWithCtxBindResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketBindGenOrdinal, req_, resp_, DatagramSocketBindOrdinal, DatagramSocketBindGenOrdinal)
	return resp_.Result, err_
}

// Initiates a connection to a remote address.
func (p *DatagramSocketWithCtxInterface) Connect(ctx_ _bindings.Context, addr []uint8) (BaseSocketConnectResult, error) {
	req_ := &datagramSocketWithCtxConnectRequest{
		Addr: addr,
	}
	resp_ := &datagramSocketWithCtxConnectResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketConnectGenOrdinal, req_, resp_, DatagramSocketConnectOrdinal, DatagramSocketConnectGenOrdinal)
	return resp_.Result, err_
}

// Retrieves the local socket address.
func (p *DatagramSocketWithCtxInterface) GetSockName(ctx_ _bindings.Context) (BaseSocketGetSockNameResult, error) {
	var req_ _bindings.Message
	resp_ := &datagramSocketWithCtxGetSockNameResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketGetSockNameGenOrdinal, req_, resp_, DatagramSocketGetSockNameOrdinal, DatagramSocketGetSockNameGenOrdinal)
	return resp_.Result, err_
}

// Retrieves the remote socket address.
func (p *DatagramSocketWithCtxInterface) GetPeerName(ctx_ _bindings.Context) (BaseSocketGetPeerNameResult, error) {
	var req_ _bindings.Message
	resp_ := &datagramSocketWithCtxGetPeerNameResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketGetPeerNameGenOrdinal, req_, resp_, DatagramSocketGetPeerNameOrdinal, DatagramSocketGetPeerNameGenOrdinal)
	return resp_.Result, err_
}

// Sets the value of a socket option.
func (p *DatagramSocketWithCtxInterface) SetSockOpt(ctx_ _bindings.Context, level int16, optname int16, optval []uint8) (BaseSocketSetSockOptResult, error) {
	req_ := &datagramSocketWithCtxSetSockOptRequest{
		Level:   level,
		Optname: optname,
		Optval:  optval,
	}
	resp_ := &datagramSocketWithCtxSetSockOptResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketSetSockOptGenOrdinal, req_, resp_, DatagramSocketSetSockOptOrdinal, DatagramSocketSetSockOptGenOrdinal)
	return resp_.Result, err_
}

// Retrieves the value of a socket option.
func (p *DatagramSocketWithCtxInterface) GetSockOpt(ctx_ _bindings.Context, level int16, optname int16) (BaseSocketGetSockOptResult, error) {
	req_ := &datagramSocketWithCtxGetSockOptRequest{
		Level:   level,
		Optname: optname,
	}
	resp_ := &datagramSocketWithCtxGetSockOptResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketGetSockOptGenOrdinal, req_, resp_, DatagramSocketGetSockOptOrdinal, DatagramSocketGetSockOptGenOrdinal)
	return resp_.Result, err_
}

// Shuts down part of the socket.
func (p *DatagramSocketWithCtxInterface) Shutdown(ctx_ _bindings.Context, how int16) (DatagramSocketShutdownResult, error) {
	req_ := &datagramSocketWithCtxShutdownRequest{
		How: how,
	}
	resp_ := &datagramSocketWithCtxShutdownResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketShutdownGenOrdinal, req_, resp_, DatagramSocketShutdownOrdinal, DatagramSocketShutdownGenOrdinal)
	return resp_.Result, err_
}

// Receives a message from the socket.
func (p *DatagramSocketWithCtxInterface) RecvMsg(ctx_ _bindings.Context, addrLen uint32, dataLen uint32, controlLen uint32, flags int16) (DatagramSocketRecvMsgResult, error) {
	req_ := &datagramSocketWithCtxRecvMsgRequest{
		AddrLen:    addrLen,
		DataLen:    dataLen,
		ControlLen: controlLen,
		Flags:      flags,
	}
	resp_ := &datagramSocketWithCtxRecvMsgResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketRecvMsgGenOrdinal, req_, resp_, DatagramSocketRecvMsgOrdinal, DatagramSocketRecvMsgGenOrdinal)
	return resp_.Result, err_
}

// Sends a message on the socket.
func (p *DatagramSocketWithCtxInterface) SendMsg(ctx_ _bindings.Context, addr []uint8, data [][]uint8, control []uint8, flags int16) (DatagramSocketSendMsgResult, error) {
	req_ := &datagramSocketWithCtxSendMsgRequest{
		Addr:    addr,
		Data:    data,
		Control: control,
		Flags:   flags,
	}
	resp_ := &datagramSocketWithCtxSendMsgResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketSendMsgGenOrdinal, req_, resp_, DatagramSocketSendMsgOrdinal, DatagramSocketSendMsgGenOrdinal)
	return resp_.Result, err_
}

// Sends a message on the socket.
func (p *DatagramSocketWithCtxInterface) SendMsg2(ctx_ _bindings.Context, addr []uint8, data []uint8, control []uint8, flags int16) (DatagramSocketSendMsg2Result, error) {
	req_ := &datagramSocketWithCtxSendMsg2Request{
		Addr:    addr,
		Data:    data,
		Control: control,
		Flags:   flags,
	}
	resp_ := &datagramSocketWithCtxSendMsg2Response{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketSendMsg2GenOrdinal, req_, resp_, DatagramSocketSendMsg2Ordinal, DatagramSocketSendMsg2GenOrdinal)
	return resp_.Result, err_
}

// A datagram socket.
//
// This type's [`fuchsia.io.Node/Describe`] method returns an eventpair which is used to signal
// additional information about the state of the socket such as readiness or shutdown-ness.
//
// All methods on this type are nonblocking; their exact behaviors match their Linux counterparts.
type DatagramSocketWithCtx interface {
	// Create another connection to the same remote object.
	//
	// `flags` may be any of:
	//
	// - `OPEN_RIGHT_*`
	// - `OPEN_FLAG_APPEND`
	// - `OPEN_FLAG_NO_REMOTE`
	// - `OPEN_FLAG_DESCRIBE`
	// - `CLONE_FLAG_SAME_RIGHTS`
	//
	// All other flags are ignored.
	//
	// The `OPEN_RIGHT_*` bits in `flags` request corresponding rights over the resulting
	// cloned object.
	// The cloned object must have rights less than or equal to the original object.
	// 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`.
	SetAttr(ctx_ _bindings.Context, flags uint32, attributes fuchsiaio.NodeAttributes) (int32, error)
	// Acquires the `Directory.Open` rights and flags used to access this file.
	//
	// This method does not require any rights.
	// This method has the same functionality as GetFlags for File and is
	// meant as an in-progress replacement.
	NodeGetFlags(ctx_ _bindings.Context) (int32, uint32, error)
	// Changes the `Directory.Open` flags used to access the file.
	// Supported flags which can be turned on / off:
	// - `OPEN_FLAG_APPEND`
	//
	// This method does not require any rights.
	// This method has the same functionality as SetFlags for File and is
	// meant as an in-progress replacement.
	NodeSetFlags(ctx_ _bindings.Context, flags uint32) (int32, error)
	// Sets the local address used for the socket.
	Bind(ctx_ _bindings.Context, addr []uint8) (BaseSocketBindResult, error)
	// Initiates a connection to a remote address.
	Connect(ctx_ _bindings.Context, addr []uint8) (BaseSocketConnectResult, error)
	// Retrieves the local socket address.
	GetSockName(ctx_ _bindings.Context) (BaseSocketGetSockNameResult, error)
	// Retrieves the remote socket address.
	GetPeerName(ctx_ _bindings.Context) (BaseSocketGetPeerNameResult, error)
	// Sets the value of a socket option.
	SetSockOpt(ctx_ _bindings.Context, level int16, optname int16, optval []uint8) (BaseSocketSetSockOptResult, error)
	// Retrieves the value of a socket option.
	GetSockOpt(ctx_ _bindings.Context, level int16, optname int16) (BaseSocketGetSockOptResult, error)
	// Shuts down part of the socket.
	Shutdown(ctx_ _bindings.Context, how int16) (DatagramSocketShutdownResult, error)
	// Receives a message from the socket.
	RecvMsg(ctx_ _bindings.Context, addrLen uint32, dataLen uint32, controlLen uint32, flags int16) (DatagramSocketRecvMsgResult, error)
	// Sends a message on the socket.
	SendMsg(ctx_ _bindings.Context, addr []uint8, data [][]uint8, control []uint8, flags int16) (DatagramSocketSendMsgResult, error)
	// Sends a message on the socket.
	SendMsg2(ctx_ _bindings.Context, addr []uint8, data []uint8, control []uint8, flags int16) (DatagramSocketSendMsg2Result, 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:
		fallthrough
	case DatagramSocketCloneGenOrdinal:
		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:
		fallthrough
	case DatagramSocketCloseGenOrdinal:
		s, err_ := s_.Impl.Close(args_.Ctx)
		out_ := datagramSocketWithCtxCloseResponse{}
		out_.S = s
		return &out_, true, err_
	case DatagramSocketDescribeOrdinal:
		fallthrough
	case DatagramSocketDescribeGenOrdinal:
		info, err_ := s_.Impl.Describe(args_.Ctx)
		out_ := datagramSocketWithCtxDescribeResponse{}
		out_.Info = info
		return &out_, true, err_
	case DatagramSocketSyncOrdinal:
		fallthrough
	case DatagramSocketSyncGenOrdinal:
		s, err_ := s_.Impl.Sync(args_.Ctx)
		out_ := datagramSocketWithCtxSyncResponse{}
		out_.S = s
		return &out_, true, err_
	case DatagramSocketGetAttrOrdinal:
		fallthrough
	case DatagramSocketGetAttrGenOrdinal:
		s, attributes, err_ := s_.Impl.GetAttr(args_.Ctx)
		out_ := datagramSocketWithCtxGetAttrResponse{}
		out_.S = s
		out_.Attributes = attributes
		return &out_, true, err_
	case DatagramSocketSetAttrOrdinal:
		fallthrough
	case DatagramSocketSetAttrGenOrdinal:
		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:
		fallthrough
	case DatagramSocketNodeGetFlagsGenOrdinal:
		s, flags, err_ := s_.Impl.NodeGetFlags(args_.Ctx)
		out_ := datagramSocketWithCtxNodeGetFlagsResponse{}
		out_.S = s
		out_.Flags = flags
		return &out_, true, err_
	case DatagramSocketNodeSetFlagsOrdinal:
		fallthrough
	case DatagramSocketNodeSetFlagsGenOrdinal:
		in_ := datagramSocketWithCtxNodeSetFlagsRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		s, err_ := s_.Impl.NodeSetFlags(args_.Ctx, in_.Flags)
		out_ := datagramSocketWithCtxNodeSetFlagsResponse{}
		out_.S = s
		return &out_, true, err_
	case DatagramSocketBindOrdinal:
		fallthrough
	case DatagramSocketBindGenOrdinal:
		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:
		fallthrough
	case DatagramSocketConnectGenOrdinal:
		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 DatagramSocketGetSockNameOrdinal:
		fallthrough
	case DatagramSocketGetSockNameGenOrdinal:
		result, err_ := s_.Impl.GetSockName(args_.Ctx)
		out_ := datagramSocketWithCtxGetSockNameResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketGetPeerNameOrdinal:
		fallthrough
	case DatagramSocketGetPeerNameGenOrdinal:
		result, err_ := s_.Impl.GetPeerName(args_.Ctx)
		out_ := datagramSocketWithCtxGetPeerNameResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketSetSockOptOrdinal:
		fallthrough
	case DatagramSocketSetSockOptGenOrdinal:
		in_ := datagramSocketWithCtxSetSockOptRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.SetSockOpt(args_.Ctx, in_.Level, in_.Optname, in_.Optval)
		out_ := datagramSocketWithCtxSetSockOptResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketGetSockOptOrdinal:
		fallthrough
	case DatagramSocketGetSockOptGenOrdinal:
		in_ := datagramSocketWithCtxGetSockOptRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.GetSockOpt(args_.Ctx, in_.Level, in_.Optname)
		out_ := datagramSocketWithCtxGetSockOptResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketShutdownOrdinal:
		fallthrough
	case DatagramSocketShutdownGenOrdinal:
		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_.How)
		out_ := datagramSocketWithCtxShutdownResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketRecvMsgOrdinal:
		fallthrough
	case DatagramSocketRecvMsgGenOrdinal:
		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_.AddrLen, in_.DataLen, in_.ControlLen, in_.Flags)
		out_ := datagramSocketWithCtxRecvMsgResponse{}
		out_.Result = result
		return &out_, true, err_
	case DatagramSocketSendMsgOrdinal:
		fallthrough
	case DatagramSocketSendMsgGenOrdinal:
		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 DatagramSocketSendMsg2Ordinal:
		fallthrough
	case DatagramSocketSendMsg2GenOrdinal:
		in_ := datagramSocketWithCtxSendMsg2Request{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.SendMsg2(args_.Ctx, in_.Addr, in_.Data, in_.Control, in_.Flags)
		out_ := datagramSocketWithCtxSendMsg2Response{}
		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(DatagramSocketOnOpenGenOrdinal, event_)
}

const (
	StreamSocketCloneOrdinal           uint64 = 0x17fe6a4c00000000
	StreamSocketCloneGenOrdinal        uint64 = 0x5a61678f293ce16f
	StreamSocketCloseOrdinal           uint64 = 0x52b9568700000000
	StreamSocketCloseGenOrdinal        uint64 = 0x5309c5bd1c33dc44
	StreamSocketDescribeOrdinal        uint64 = 0x1f62df5e00000000
	StreamSocketDescribeGenOrdinal     uint64 = 0xffcec215078dea0
	StreamSocketOnOpenOrdinal          uint64 = 0x4700a7bd00000000
	StreamSocketOnOpenGenOrdinal       uint64 = 0x7fc7bbb1dbfd1972
	StreamSocketSyncOrdinal            uint64 = 0x62423faa00000000
	StreamSocketSyncGenOrdinal         uint64 = 0x189d88326c18b519
	StreamSocketGetAttrOrdinal         uint64 = 0x4585e7c800000000
	StreamSocketGetAttrGenOrdinal      uint64 = 0x78985e216314dafd
	StreamSocketSetAttrOrdinal         uint64 = 0xbd5559a00000000
	StreamSocketSetAttrGenOrdinal      uint64 = 0x4186c0f40d938f46
	StreamSocketNodeGetFlagsOrdinal    uint64 = 0x3c24c22300000000
	StreamSocketNodeGetFlagsGenOrdinal uint64 = 0x5b88fffb8eda3aa1
	StreamSocketNodeSetFlagsOrdinal    uint64 = 0x46940c1600000000
	StreamSocketNodeSetFlagsGenOrdinal uint64 = 0x5295b76c71fde733
	StreamSocketBindOrdinal            uint64 = 0x11ebbc3c00000000
	StreamSocketBindGenOrdinal         uint64 = 0xf8457e6b05e15bc
	StreamSocketConnectOrdinal         uint64 = 0x62cb94300000000
	StreamSocketConnectGenOrdinal      uint64 = 0x17abeee0b9843bb1
	StreamSocketGetSockNameOrdinal     uint64 = 0x7c14255c00000000
	StreamSocketGetSockNameGenOrdinal  uint64 = 0x41a618ef19a91f9d
	StreamSocketGetPeerNameOrdinal     uint64 = 0x4beee9b000000000
	StreamSocketGetPeerNameGenOrdinal  uint64 = 0x4009d08a4beb5e95
	StreamSocketSetSockOptOrdinal      uint64 = 0x497c444100000000
	StreamSocketSetSockOptGenOrdinal   uint64 = 0x93c6f802203e6f1
	StreamSocketGetSockOptOrdinal      uint64 = 0x3b2b8b3d00000000
	StreamSocketGetSockOptGenOrdinal   uint64 = 0x6dfaf70f0ed40544
	StreamSocketListenOrdinal          uint64 = 0x29346af600000000
	StreamSocketListenGenOrdinal       uint64 = 0x3d0a65ced3d10108
	StreamSocketAcceptOrdinal          uint64 = 0x4c59510900000000
	StreamSocketAcceptGenOrdinal       uint64 = 0x5ab7ad620424c163
)

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.
// 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(StreamSocketCloneGenOrdinal, 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(StreamSocketCloseGenOrdinal, req_, resp_, StreamSocketCloseOrdinal, StreamSocketCloseGenOrdinal)
	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(StreamSocketDescribeGenOrdinal, req_, resp_, StreamSocketDescribeOrdinal, StreamSocketDescribeGenOrdinal)
	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_, StreamSocketOnOpenGenOrdinal)
	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(StreamSocketSyncGenOrdinal, req_, resp_, StreamSocketSyncOrdinal, StreamSocketSyncGenOrdinal)
	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(StreamSocketGetAttrGenOrdinal, req_, resp_, StreamSocketGetAttrOrdinal, StreamSocketGetAttrGenOrdinal)
	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`.
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(StreamSocketSetAttrGenOrdinal, req_, resp_, StreamSocketSetAttrOrdinal, StreamSocketSetAttrGenOrdinal)
	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(StreamSocketNodeGetFlagsGenOrdinal, req_, resp_, StreamSocketNodeGetFlagsOrdinal, StreamSocketNodeGetFlagsGenOrdinal)
	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(StreamSocketNodeSetFlagsGenOrdinal, req_, resp_, StreamSocketNodeSetFlagsOrdinal, StreamSocketNodeSetFlagsGenOrdinal)
	return resp_.S, err_
}

// Sets the local address used for the socket.
func (p *StreamSocketWithCtxInterface) Bind(ctx_ _bindings.Context, addr []uint8) (BaseSocketBindResult, error) {
	req_ := &streamSocketWithCtxBindRequest{
		Addr: addr,
	}
	resp_ := &streamSocketWithCtxBindResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketBindGenOrdinal, req_, resp_, StreamSocketBindOrdinal, StreamSocketBindGenOrdinal)
	return resp_.Result, err_
}

// Initiates a connection to a remote address.
func (p *StreamSocketWithCtxInterface) Connect(ctx_ _bindings.Context, addr []uint8) (BaseSocketConnectResult, error) {
	req_ := &streamSocketWithCtxConnectRequest{
		Addr: addr,
	}
	resp_ := &streamSocketWithCtxConnectResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketConnectGenOrdinal, req_, resp_, StreamSocketConnectOrdinal, StreamSocketConnectGenOrdinal)
	return resp_.Result, err_
}

// Retrieves the local socket address.
func (p *StreamSocketWithCtxInterface) GetSockName(ctx_ _bindings.Context) (BaseSocketGetSockNameResult, error) {
	var req_ _bindings.Message
	resp_ := &streamSocketWithCtxGetSockNameResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetSockNameGenOrdinal, req_, resp_, StreamSocketGetSockNameOrdinal, StreamSocketGetSockNameGenOrdinal)
	return resp_.Result, err_
}

// Retrieves the remote socket address.
func (p *StreamSocketWithCtxInterface) GetPeerName(ctx_ _bindings.Context) (BaseSocketGetPeerNameResult, error) {
	var req_ _bindings.Message
	resp_ := &streamSocketWithCtxGetPeerNameResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetPeerNameGenOrdinal, req_, resp_, StreamSocketGetPeerNameOrdinal, StreamSocketGetPeerNameGenOrdinal)
	return resp_.Result, err_
}

// Sets the value of a socket option.
func (p *StreamSocketWithCtxInterface) SetSockOpt(ctx_ _bindings.Context, level int16, optname int16, optval []uint8) (BaseSocketSetSockOptResult, error) {
	req_ := &streamSocketWithCtxSetSockOptRequest{
		Level:   level,
		Optname: optname,
		Optval:  optval,
	}
	resp_ := &streamSocketWithCtxSetSockOptResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketSetSockOptGenOrdinal, req_, resp_, StreamSocketSetSockOptOrdinal, StreamSocketSetSockOptGenOrdinal)
	return resp_.Result, err_
}

// Retrieves the value of a socket option.
func (p *StreamSocketWithCtxInterface) GetSockOpt(ctx_ _bindings.Context, level int16, optname int16) (BaseSocketGetSockOptResult, error) {
	req_ := &streamSocketWithCtxGetSockOptRequest{
		Level:   level,
		Optname: optname,
	}
	resp_ := &streamSocketWithCtxGetSockOptResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetSockOptGenOrdinal, req_, resp_, StreamSocketGetSockOptOrdinal, StreamSocketGetSockOptGenOrdinal)
	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(StreamSocketListenGenOrdinal, req_, resp_, StreamSocketListenOrdinal, StreamSocketListenGenOrdinal)
	return resp_.Result, err_
}

// Accepts a buffered incoming connection.
func (p *StreamSocketWithCtxInterface) Accept(ctx_ _bindings.Context, flags int16) (StreamSocketAcceptResult, error) {
	req_ := &streamSocketWithCtxAcceptRequest{
		Flags: flags,
	}
	resp_ := &streamSocketWithCtxAcceptResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketAcceptGenOrdinal, req_, resp_, StreamSocketAcceptOrdinal, StreamSocketAcceptGenOrdinal)
	return resp_.Result, err_
}

// A stream socket.
//
// This type's [`fuchsia.io.Node/Describe`] method returns a socket which is used to transfer data
// to and from the caller. Signals are used to communicate additional information about the state
// of the socket such as connectedness and the presence of incoming connections in the case of a
// listening socket.
//
// All methods on this type are nonblocking; their exact behaviors match their Linux counterparts.
type StreamSocketWithCtx interface {
	// Create another connection to the same remote object.
	//
	// `flags` may be any of:
	//
	// - `OPEN_RIGHT_*`
	// - `OPEN_FLAG_APPEND`
	// - `OPEN_FLAG_NO_REMOTE`
	// - `OPEN_FLAG_DESCRIBE`
	// - `CLONE_FLAG_SAME_RIGHTS`
	//
	// All other flags are ignored.
	//
	// The `OPEN_RIGHT_*` bits in `flags` request corresponding rights over the resulting
	// cloned object.
	// The cloned object must have rights less than or equal to the original object.
	// 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`.
	SetAttr(ctx_ _bindings.Context, flags uint32, attributes fuchsiaio.NodeAttributes) (int32, error)
	// Acquires the `Directory.Open` rights and flags used to access this file.
	//
	// This method does not require any rights.
	// This method has the same functionality as GetFlags for File and is
	// meant as an in-progress replacement.
	NodeGetFlags(ctx_ _bindings.Context) (int32, uint32, error)
	// Changes the `Directory.Open` flags used to access the file.
	// Supported flags which can be turned on / off:
	// - `OPEN_FLAG_APPEND`
	//
	// This method does not require any rights.
	// This method has the same functionality as SetFlags for File and is
	// meant as an in-progress replacement.
	NodeSetFlags(ctx_ _bindings.Context, flags uint32) (int32, error)
	// Sets the local address used for the socket.
	Bind(ctx_ _bindings.Context, addr []uint8) (BaseSocketBindResult, error)
	// Initiates a connection to a remote address.
	Connect(ctx_ _bindings.Context, addr []uint8) (BaseSocketConnectResult, error)
	// Retrieves the local socket address.
	GetSockName(ctx_ _bindings.Context) (BaseSocketGetSockNameResult, error)
	// Retrieves the remote socket address.
	GetPeerName(ctx_ _bindings.Context) (BaseSocketGetPeerNameResult, error)
	// Sets the value of a socket option.
	SetSockOpt(ctx_ _bindings.Context, level int16, optname int16, optval []uint8) (BaseSocketSetSockOptResult, error)
	// Retrieves the value of a socket option.
	GetSockOpt(ctx_ _bindings.Context, level int16, optname int16) (BaseSocketGetSockOptResult, 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, flags int16) (StreamSocketAcceptResult, 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:
		fallthrough
	case StreamSocketCloneGenOrdinal:
		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:
		fallthrough
	case StreamSocketCloseGenOrdinal:
		s, err_ := s_.Impl.Close(args_.Ctx)
		out_ := streamSocketWithCtxCloseResponse{}
		out_.S = s
		return &out_, true, err_
	case StreamSocketDescribeOrdinal:
		fallthrough
	case StreamSocketDescribeGenOrdinal:
		info, err_ := s_.Impl.Describe(args_.Ctx)
		out_ := streamSocketWithCtxDescribeResponse{}
		out_.Info = info
		return &out_, true, err_
	case StreamSocketSyncOrdinal:
		fallthrough
	case StreamSocketSyncGenOrdinal:
		s, err_ := s_.Impl.Sync(args_.Ctx)
		out_ := streamSocketWithCtxSyncResponse{}
		out_.S = s
		return &out_, true, err_
	case StreamSocketGetAttrOrdinal:
		fallthrough
	case StreamSocketGetAttrGenOrdinal:
		s, attributes, err_ := s_.Impl.GetAttr(args_.Ctx)
		out_ := streamSocketWithCtxGetAttrResponse{}
		out_.S = s
		out_.Attributes = attributes
		return &out_, true, err_
	case StreamSocketSetAttrOrdinal:
		fallthrough
	case StreamSocketSetAttrGenOrdinal:
		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:
		fallthrough
	case StreamSocketNodeGetFlagsGenOrdinal:
		s, flags, err_ := s_.Impl.NodeGetFlags(args_.Ctx)
		out_ := streamSocketWithCtxNodeGetFlagsResponse{}
		out_.S = s
		out_.Flags = flags
		return &out_, true, err_
	case StreamSocketNodeSetFlagsOrdinal:
		fallthrough
	case StreamSocketNodeSetFlagsGenOrdinal:
		in_ := streamSocketWithCtxNodeSetFlagsRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		s, err_ := s_.Impl.NodeSetFlags(args_.Ctx, in_.Flags)
		out_ := streamSocketWithCtxNodeSetFlagsResponse{}
		out_.S = s
		return &out_, true, err_
	case StreamSocketBindOrdinal:
		fallthrough
	case StreamSocketBindGenOrdinal:
		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:
		fallthrough
	case StreamSocketConnectGenOrdinal:
		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 StreamSocketGetSockNameOrdinal:
		fallthrough
	case StreamSocketGetSockNameGenOrdinal:
		result, err_ := s_.Impl.GetSockName(args_.Ctx)
		out_ := streamSocketWithCtxGetSockNameResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketGetPeerNameOrdinal:
		fallthrough
	case StreamSocketGetPeerNameGenOrdinal:
		result, err_ := s_.Impl.GetPeerName(args_.Ctx)
		out_ := streamSocketWithCtxGetPeerNameResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketSetSockOptOrdinal:
		fallthrough
	case StreamSocketSetSockOptGenOrdinal:
		in_ := streamSocketWithCtxSetSockOptRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.SetSockOpt(args_.Ctx, in_.Level, in_.Optname, in_.Optval)
		out_ := streamSocketWithCtxSetSockOptResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketGetSockOptOrdinal:
		fallthrough
	case StreamSocketGetSockOptGenOrdinal:
		in_ := streamSocketWithCtxGetSockOptRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.GetSockOpt(args_.Ctx, in_.Level, in_.Optname)
		out_ := streamSocketWithCtxGetSockOptResponse{}
		out_.Result = result
		return &out_, true, err_
	case StreamSocketListenOrdinal:
		fallthrough
	case StreamSocketListenGenOrdinal:
		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:
		fallthrough
	case StreamSocketAcceptGenOrdinal:
		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_.Flags)
		out_ := streamSocketWithCtxAcceptResponse{}
		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(StreamSocketOnOpenGenOrdinal, event_)
}

const (
	ProviderSocket2Ordinal                 uint64 = 0x4d4cbf6100000000
	ProviderSocket2GenOrdinal              uint64 = 0xafeae763c4a354
	ProviderInterfaceIndexToNameOrdinal    uint64 = 0x1b0a111d00000000
	ProviderInterfaceIndexToNameGenOrdinal uint64 = 0x4d59a64fce98272f
	ProviderInterfaceNameToIndexOrdinal    uint64 = 0x367bcf9d00000000
	ProviderInterfaceNameToIndexGenOrdinal uint64 = 0x690cd8d2f2d650f8
)

type ProviderWithCtxInterface _bindings.ChannelProxy

// Requests a socket with the specified parameters. Error values are defined in errno.h.
func (p *ProviderWithCtxInterface) Socket2(ctx_ _bindings.Context, domain int16, type_ int16, protocol int16) (ProviderSocket2Result, error) {
	req_ := &providerWithCtxSocket2Request{
		Domain:   domain,
		Type:     type_,
		Protocol: protocol,
	}
	resp_ := &providerWithCtxSocket2Response{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(ProviderSocket2GenOrdinal, req_, resp_, ProviderSocket2Ordinal, ProviderSocket2GenOrdinal)
	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(ProviderInterfaceIndexToNameGenOrdinal, req_, resp_, ProviderInterfaceIndexToNameOrdinal, ProviderInterfaceIndexToNameGenOrdinal)
	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(ProviderInterfaceNameToIndexGenOrdinal, req_, resp_, ProviderInterfaceNameToIndexOrdinal, ProviderInterfaceNameToIndexGenOrdinal)
	return resp_.Result, err_
}

// Provider implements the POSIX sockets API.
type ProviderWithCtx interface {
	// Requests a socket with the specified parameters. Error values are defined in errno.h.
	Socket2(ctx_ _bindings.Context, domain int16, type_ int16, protocol int16) (ProviderSocket2Result, 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)
}

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 ProviderSocket2Ordinal:
		fallthrough
	case ProviderSocket2GenOrdinal:
		in_ := providerWithCtxSocket2Request{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.Socket2(args_.Ctx, in_.Domain, in_.Type, in_.Protocol)
		out_ := providerWithCtxSocket2Response{}
		out_.Result = result
		return &out_, true, err_
	case ProviderInterfaceIndexToNameOrdinal:
		fallthrough
	case ProviderInterfaceIndexToNameGenOrdinal:
		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:
		fallthrough
	case ProviderInterfaceNameToIndexGenOrdinal:
		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_
	}
	return nil, false, _bindings.ErrUnknownOrdinal
}

type ProviderEventProxy _bindings.ChannelProxy