// 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.
//
// GENERATED FILE: Do not edit!
//
// To rebuild this file, invoke third_party/go/regen-fidl.

// +build fuchsia

package net

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

const (
	MaxAddr   uint64 = 128
	MaxBuffer uint64 = 900
)

type AddrInfoStatus uint32

const (
	AddrInfoStatusOk             AddrInfoStatus = 0
	AddrInfoStatusBadFlags       AddrInfoStatus = 1
	AddrInfoStatusNoName         AddrInfoStatus = 2
	AddrInfoStatusAgain          AddrInfoStatus = 3
	AddrInfoStatusFail           AddrInfoStatus = 4
	AddrInfoStatusNoData         AddrInfoStatus = 5
	AddrInfoStatusBufferOverflow AddrInfoStatus = 6
	AddrInfoStatusSystemError    AddrInfoStatus = 7
)

func (x AddrInfoStatus) String() string {
	switch x {
	case 0:
		return "Ok"
	case 1:
		return "BadFlags"
	case 2:
		return "NoName"
	case 3:
		return "Again"
	case 4:
		return "Fail"
	case 5:
		return "NoData"
	case 6:
		return "BufferOverflow"
	case 7:
		return "SystemError"
	}
	return "Unknown"
}

type IPv4Address struct {
	_    struct{} `fidl2:"s,4,1"`
	Addr [4]uint8
}

var _mIPv4Address = _bindings.CreateLazyMarshaler(IPv4Address{})

func (msg *IPv4Address) Marshaler() _bindings.Marshaler {
	return _mIPv4Address
}

// Implements Payload.
func (_ *IPv4Address) InlineAlignment() int {
	return 1
}

// Implements Payload.
func (_ *IPv4Address) InlineSize() int {
	return 4
}

type IPv6Address struct {
	_    struct{} `fidl2:"s,16,1"`
	Addr [16]uint8
}

var _mIPv6Address = _bindings.CreateLazyMarshaler(IPv6Address{})

func (msg *IPv6Address) Marshaler() _bindings.Marshaler {
	return _mIPv6Address
}

// Implements Payload.
func (_ *IPv6Address) InlineAlignment() int {
	return 1
}

// Implements Payload.
func (_ *IPv6Address) InlineSize() int {
	return 16
}

type Subnet struct {
	_         struct{} `fidl2:"s,24,4"`
	Addr      IpAddress
	PrefixLen uint8
}

var _mSubnet = _bindings.CreateLazyMarshaler(Subnet{})

func (msg *Subnet) Marshaler() _bindings.Marshaler {
	return _mSubnet
}

// Implements Payload.
func (_ *Subnet) InlineAlignment() int {
	return 4
}

// Implements Payload.
func (_ *Subnet) InlineSize() int {
	return 24
}

type MacAddress struct {
	_      struct{} `fidl2:"s,6,1"`
	Octets [6]uint8
}

var _mMacAddress = _bindings.CreateLazyMarshaler(MacAddress{})

func (msg *MacAddress) Marshaler() _bindings.Marshaler {
	return _mMacAddress
}

// Implements Payload.
func (_ *MacAddress) InlineAlignment() int {
	return 1
}

// Implements Payload.
func (_ *MacAddress) InlineSize() int {
	return 6
}

type AddrInfoHints struct {
	_        struct{} `fidl2:"s,16,4"`
	Flags    int32
	Family   int32
	SockType int32
	Protocol int32
}

var _mAddrInfoHints = _bindings.CreateLazyMarshaler(AddrInfoHints{})

func (msg *AddrInfoHints) Marshaler() _bindings.Marshaler {
	return _mAddrInfoHints
}

// Implements Payload.
func (_ *AddrInfoHints) InlineAlignment() int {
	return 4
}

// Implements Payload.
func (_ *AddrInfoHints) InlineSize() int {
	return 16
}

type AddrStorage struct {
	_   struct{} `fidl2:"s,20,4"`
	Val [16]uint8
	Len uint32
}

var _mAddrStorage = _bindings.CreateLazyMarshaler(AddrStorage{})

func (msg *AddrStorage) Marshaler() _bindings.Marshaler {
	return _mAddrStorage
}

// Implements Payload.
func (_ *AddrStorage) InlineAlignment() int {
	return 4
}

// Implements Payload.
func (_ *AddrStorage) InlineSize() int {
	return 20
}

type AddrInfo struct {
	_        struct{} `fidl2:"s,40,4"`
	Flags    int32
	Family   int32
	SockType int32
	Protocol int32
	Addr     AddrStorage
	Port     uint16
}

var _mAddrInfo = _bindings.CreateLazyMarshaler(AddrInfo{})

func (msg *AddrInfo) Marshaler() _bindings.Marshaler {
	return _mAddrInfo
}

// Implements Payload.
func (_ *AddrInfo) InlineAlignment() int {
	return 4
}

// Implements Payload.
func (_ *AddrInfo) InlineSize() int {
	return 40
}

type IpAddressTag uint32

const (
	_ IpAddressTag = iota
	IpAddressIpv4
	IpAddressIpv6
)

type IpAddress struct {
	IpAddressTag `fidl:"tag" fidl2:"u,20,4"`
	Ipv4         IPv4Address
	Ipv6         IPv6Address
}

// Implements Payload.
func (_ *IpAddress) InlineAlignment() int {
	return 4
}

// Implements Payload.
func (_ *IpAddress) InlineSize() int {
	return 20
}

func (u *IpAddress) Which() IpAddressTag {
	return u.IpAddressTag
}

func (u *IpAddress) SetIpv4(ipv4 IPv4Address) {
	u.IpAddressTag = IpAddressIpv4
	u.Ipv4 = ipv4
}

func (u *IpAddress) SetIpv6(ipv6 IPv6Address) {
	u.IpAddressTag = IpAddressIpv6
	u.Ipv6 = ipv6
}

const (
	ConnectivityOnNetworkReachableOrdinal    uint32 = 1703348424
	ConnectivityOnNetworkReachableGenOrdinal uint32 = 1703348424
)

type ConnectivityOnNetworkReachableResponse struct {
	_         struct{} `fidl2:"s,8,0"`
	Reachable bool
}

var _mConnectivityOnNetworkReachableResponse = _bindings.CreateLazyMarshaler(ConnectivityOnNetworkReachableResponse{})

func (msg *ConnectivityOnNetworkReachableResponse) Marshaler() _bindings.Marshaler {
	return _mConnectivityOnNetworkReachableResponse
}

// Implements Payload.
func (_ *ConnectivityOnNetworkReachableResponse) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *ConnectivityOnNetworkReachableResponse) InlineSize() int {
	return 8
}

type ConnectivityInterface _bindings.ChannelProxy

func (p *ConnectivityInterface) ExpectOnNetworkReachable() (bool, error) {
	resp_ := &ConnectivityOnNetworkReachableResponse{}
	err := ((*_bindings.ChannelProxy)(p)).Recv(ConnectivityOnNetworkReachableOrdinal, resp_)
	return resp_.Reachable, err
}

type Connectivity interface {
}

type ConnectivityTransitionalBase struct{}

type ConnectivityInterfaceRequest _bindings.InterfaceRequest

func NewConnectivityInterfaceRequest() (ConnectivityInterfaceRequest, *ConnectivityInterface, error) {
	req, cli, err := _bindings.NewInterfaceRequest()
	return ConnectivityInterfaceRequest(req), (*ConnectivityInterface)(cli), err
}

// Implements ServiceRequest.
func (_ ConnectivityInterfaceRequest) Name() string {
	return "fuchsia.net.Connectivity"
}
func (c ConnectivityInterfaceRequest) ToChannel() _zx.Channel {
	return c.Channel
}

const ConnectivityName = "fuchsia.net.Connectivity"

type ConnectivityStub struct {
	Impl Connectivity
}

func (s *ConnectivityStub) Dispatch(ord uint32, b_ []byte, h_ []_zx.Handle) (_bindings.Payload, error) {
	switch ord {
	}
	return nil, _bindings.ErrUnknownOrdinal
}

type ConnectivityService struct {
	_bindings.BindingSet
}

func (s *ConnectivityService) Add(impl Connectivity, c _zx.Channel, onError func(error)) (_bindings.BindingKey, error) {
	return s.BindingSet.Add(&ConnectivityStub{Impl: impl}, c, onError)
}

func (s *ConnectivityService) EventProxyFor(key _bindings.BindingKey) (*ConnectivityEventProxy, bool) {
	pxy, err := s.BindingSet.ProxyFor(key)
	return (*ConnectivityEventProxy)(pxy), err
}

type ConnectivityEventProxy _bindings.ChannelProxy

func (p *ConnectivityEventProxy) OnNetworkReachable(reachable bool) error {
	event_ := &ConnectivityOnNetworkReachableResponse{
		Reachable: reachable,
	}
	return ((*_bindings.ChannelProxy)(p)).Send(ConnectivityOnNetworkReachableOrdinal, event_)
}

const (
	SocketProviderSocketOrdinal         uint32 = 316444173
	SocketProviderSocketGenOrdinal      uint32 = 316444173
	SocketProviderGetAddrInfoOrdinal    uint32 = 498796293
	SocketProviderGetAddrInfoGenOrdinal uint32 = 498796293
)

type SocketProviderSocketRequest struct {
	_        struct{} `fidl2:"s,8,0"`
	Domain   int16
	Type     int16
	Protocol int16
}

var _mSocketProviderSocketRequest = _bindings.CreateLazyMarshaler(SocketProviderSocketRequest{})

func (msg *SocketProviderSocketRequest) Marshaler() _bindings.Marshaler {
	return _mSocketProviderSocketRequest
}

// Implements Payload.
func (_ *SocketProviderSocketRequest) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *SocketProviderSocketRequest) InlineSize() int {
	return 8
}

type SocketProviderSocketResponse struct {
	_    struct{} `fidl2:"s,8,0"`
	Code int16
	S    _zx.Socket `fidl:"*" fidl2:"1"`
}

var _mSocketProviderSocketResponse = _bindings.CreateLazyMarshaler(SocketProviderSocketResponse{})

func (msg *SocketProviderSocketResponse) Marshaler() _bindings.Marshaler {
	return _mSocketProviderSocketResponse
}

// Implements Payload.
func (_ *SocketProviderSocketResponse) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *SocketProviderSocketResponse) InlineSize() int {
	return 8
}

type SocketProviderGetAddrInfoRequest struct {
	_       struct{} `fidl2:"s,40,0"`
	Node    *string  `fidl:"256" fidl2:"256"`
	Service *string  `fidl:"256" fidl2:"256"`
	Hints   *AddrInfoHints
}

var _mSocketProviderGetAddrInfoRequest = _bindings.CreateLazyMarshaler(SocketProviderGetAddrInfoRequest{})

func (msg *SocketProviderGetAddrInfoRequest) Marshaler() _bindings.Marshaler {
	return _mSocketProviderGetAddrInfoRequest
}

// Implements Payload.
func (_ *SocketProviderGetAddrInfoRequest) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *SocketProviderGetAddrInfoRequest) InlineSize() int {
	return 40
}

type SocketProviderGetAddrInfoResponse struct {
	_      struct{} `fidl2:"s,168,0"`
	Status AddrInfoStatus
	Nres   uint32
	Res    [4]AddrInfo
}

var _mSocketProviderGetAddrInfoResponse = _bindings.CreateLazyMarshaler(SocketProviderGetAddrInfoResponse{})

func (msg *SocketProviderGetAddrInfoResponse) Marshaler() _bindings.Marshaler {
	return _mSocketProviderGetAddrInfoResponse
}

// Implements Payload.
func (_ *SocketProviderGetAddrInfoResponse) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *SocketProviderGetAddrInfoResponse) InlineSize() int {
	return 168
}

type SocketProviderInterface _bindings.ChannelProxy

func (p *SocketProviderInterface) Socket(domain int16, type_ int16, protocol int16) (int16, _zx.Socket, error) {
	req_ := &SocketProviderSocketRequest{
		Domain:   domain,
		Type:     type_,
		Protocol: protocol,
	}
	resp_ := &SocketProviderSocketResponse{}
	err := ((*_bindings.ChannelProxy)(p)).Call(SocketProviderSocketOrdinal, req_, resp_)
	return resp_.Code, resp_.S, err
}

func (p *SocketProviderInterface) GetAddrInfo(node *string, service *string, hints *AddrInfoHints) (AddrInfoStatus, uint32, [4]AddrInfo, error) {
	req_ := &SocketProviderGetAddrInfoRequest{
		Node:    node,
		Service: service,
		Hints:   hints,
	}
	resp_ := &SocketProviderGetAddrInfoResponse{}
	err := ((*_bindings.ChannelProxy)(p)).Call(SocketProviderGetAddrInfoOrdinal, req_, resp_)
	return resp_.Status, resp_.Nres, resp_.Res, err
}

// POSIX, as much as possible. |code| values are defined in errno.h.
type SocketProvider interface {
	Socket(domain int16, type_ int16, protocol int16) (int16, _zx.Socket, error)
	GetAddrInfo(node *string, service *string, hints *AddrInfoHints) (AddrInfoStatus, uint32, [4]AddrInfo, error)
}

type SocketProviderTransitionalBase struct{}

type SocketProviderInterfaceRequest _bindings.InterfaceRequest

func NewSocketProviderInterfaceRequest() (SocketProviderInterfaceRequest, *SocketProviderInterface, error) {
	req, cli, err := _bindings.NewInterfaceRequest()
	return SocketProviderInterfaceRequest(req), (*SocketProviderInterface)(cli), err
}

// Implements ServiceRequest.
func (_ SocketProviderInterfaceRequest) Name() string {
	return "fuchsia.net.SocketProvider"
}
func (c SocketProviderInterfaceRequest) ToChannel() _zx.Channel {
	return c.Channel
}

const SocketProviderName = "fuchsia.net.SocketProvider"

type SocketProviderStub struct {
	Impl SocketProvider
}

func (s *SocketProviderStub) Dispatch(ord uint32, b_ []byte, h_ []_zx.Handle) (_bindings.Payload, error) {
	switch ord {
	case SocketProviderSocketOrdinal:
		in_ := SocketProviderSocketRequest{}
		if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
			return nil, err_
		}
		code, s, err_ := s.Impl.Socket(in_.Domain, in_.Type, in_.Protocol)
		out_ := SocketProviderSocketResponse{}
		out_.Code = code
		out_.S = s
		return &out_, err_
	case SocketProviderGetAddrInfoOrdinal:
		in_ := SocketProviderGetAddrInfoRequest{}
		if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
			return nil, err_
		}
		status, nres, res, err_ := s.Impl.GetAddrInfo(in_.Node, in_.Service, in_.Hints)
		out_ := SocketProviderGetAddrInfoResponse{}
		out_.Status = status
		out_.Nres = nres
		out_.Res = res
		return &out_, err_
	}
	return nil, _bindings.ErrUnknownOrdinal
}

type SocketProviderService struct {
	_bindings.BindingSet
}

func (s *SocketProviderService) Add(impl SocketProvider, c _zx.Channel, onError func(error)) (_bindings.BindingKey, error) {
	return s.BindingSet.Add(&SocketProviderStub{Impl: impl}, c, onError)
}

func (s *SocketProviderService) EventProxyFor(key _bindings.BindingKey) (*SocketProviderEventProxy, bool) {
	pxy, err := s.BindingSet.ProxyFor(key)
	return (*SocketProviderEventProxy)(pxy), err
}

type SocketProviderEventProxy _bindings.ChannelProxy

const (
	SocketControlCloseOrdinal          uint32 = 506040350
	SocketControlCloseGenOrdinal       uint32 = 506040350
	SocketControlIoctlOrdinal          uint32 = 1157859964
	SocketControlIoctlGenOrdinal       uint32 = 1157859964
	SocketControlConnectOrdinal        uint32 = 345505709
	SocketControlConnectGenOrdinal     uint32 = 345505709
	SocketControlAcceptOrdinal         uint32 = 796734679
	SocketControlAcceptGenOrdinal      uint32 = 796734679
	SocketControlBindOrdinal           uint32 = 2092731140
	SocketControlBindGenOrdinal        uint32 = 2092731140
	SocketControlListenOrdinal         uint32 = 1117818704
	SocketControlListenGenOrdinal      uint32 = 1117818704
	SocketControlGetSockNameOrdinal    uint32 = 764939941
	SocketControlGetSockNameGenOrdinal uint32 = 764939941
	SocketControlGetPeerNameOrdinal    uint32 = 472396488
	SocketControlGetPeerNameGenOrdinal uint32 = 472396488
	SocketControlSetSockOptOrdinal     uint32 = 1365685084
	SocketControlSetSockOptGenOrdinal  uint32 = 1365685084
	SocketControlGetSockOptOrdinal     uint32 = 2132650507
	SocketControlGetSockOptGenOrdinal  uint32 = 2132650507
)

type SocketControlCloseResponse struct {
	_    struct{} `fidl2:"s,8,0"`
	Code int16
}

var _mSocketControlCloseResponse = _bindings.CreateLazyMarshaler(SocketControlCloseResponse{})

func (msg *SocketControlCloseResponse) Marshaler() _bindings.Marshaler {
	return _mSocketControlCloseResponse
}

// Implements Payload.
func (_ *SocketControlCloseResponse) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *SocketControlCloseResponse) InlineSize() int {
	return 8
}

type SocketControlIoctlRequest struct {
	_   struct{} `fidl2:"s,24,0"`
	Req int16
	In  []uint8 `fidl:"900" fidl2:"900"`
}

var _mSocketControlIoctlRequest = _bindings.CreateLazyMarshaler(SocketControlIoctlRequest{})

func (msg *SocketControlIoctlRequest) Marshaler() _bindings.Marshaler {
	return _mSocketControlIoctlRequest
}

// Implements Payload.
func (_ *SocketControlIoctlRequest) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *SocketControlIoctlRequest) InlineSize() int {
	return 24
}

type SocketControlIoctlResponse struct {
	_    struct{} `fidl2:"s,24,0"`
	Code int16
	Out  []uint8 `fidl:"900" fidl2:"900"`
}

var _mSocketControlIoctlResponse = _bindings.CreateLazyMarshaler(SocketControlIoctlResponse{})

func (msg *SocketControlIoctlResponse) Marshaler() _bindings.Marshaler {
	return _mSocketControlIoctlResponse
}

// Implements Payload.
func (_ *SocketControlIoctlResponse) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *SocketControlIoctlResponse) InlineSize() int {
	return 24
}

type SocketControlConnectRequest struct {
	_    struct{} `fidl2:"s,16,0"`
	Addr []uint8  `fidl:"128" fidl2:"128"`
}

var _mSocketControlConnectRequest = _bindings.CreateLazyMarshaler(SocketControlConnectRequest{})

func (msg *SocketControlConnectRequest) Marshaler() _bindings.Marshaler {
	return _mSocketControlConnectRequest
}

// Implements Payload.
func (_ *SocketControlConnectRequest) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *SocketControlConnectRequest) InlineSize() int {
	return 16
}

type SocketControlConnectResponse struct {
	_    struct{} `fidl2:"s,8,0"`
	Code int16
}

var _mSocketControlConnectResponse = _bindings.CreateLazyMarshaler(SocketControlConnectResponse{})

func (msg *SocketControlConnectResponse) Marshaler() _bindings.Marshaler {
	return _mSocketControlConnectResponse
}

// Implements Payload.
func (_ *SocketControlConnectResponse) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *SocketControlConnectResponse) InlineSize() int {
	return 8
}

type SocketControlAcceptRequest struct {
	_     struct{} `fidl2:"s,8,0"`
	Flags int16
}

var _mSocketControlAcceptRequest = _bindings.CreateLazyMarshaler(SocketControlAcceptRequest{})

func (msg *SocketControlAcceptRequest) Marshaler() _bindings.Marshaler {
	return _mSocketControlAcceptRequest
}

// Implements Payload.
func (_ *SocketControlAcceptRequest) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *SocketControlAcceptRequest) InlineSize() int {
	return 8
}

type SocketControlAcceptResponse struct {
	_    struct{} `fidl2:"s,8,0"`
	Code int16
}

var _mSocketControlAcceptResponse = _bindings.CreateLazyMarshaler(SocketControlAcceptResponse{})

func (msg *SocketControlAcceptResponse) Marshaler() _bindings.Marshaler {
	return _mSocketControlAcceptResponse
}

// Implements Payload.
func (_ *SocketControlAcceptResponse) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *SocketControlAcceptResponse) InlineSize() int {
	return 8
}

type SocketControlBindRequest struct {
	_    struct{} `fidl2:"s,16,0"`
	Addr []uint8  `fidl:"128" fidl2:"128"`
}

var _mSocketControlBindRequest = _bindings.CreateLazyMarshaler(SocketControlBindRequest{})

func (msg *SocketControlBindRequest) Marshaler() _bindings.Marshaler {
	return _mSocketControlBindRequest
}

// Implements Payload.
func (_ *SocketControlBindRequest) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *SocketControlBindRequest) InlineSize() int {
	return 16
}

type SocketControlBindResponse struct {
	_    struct{} `fidl2:"s,8,0"`
	Code int16
}

var _mSocketControlBindResponse = _bindings.CreateLazyMarshaler(SocketControlBindResponse{})

func (msg *SocketControlBindResponse) Marshaler() _bindings.Marshaler {
	return _mSocketControlBindResponse
}

// Implements Payload.
func (_ *SocketControlBindResponse) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *SocketControlBindResponse) InlineSize() int {
	return 8
}

type SocketControlListenRequest struct {
	_       struct{} `fidl2:"s,8,0"`
	Backlog int16
}

var _mSocketControlListenRequest = _bindings.CreateLazyMarshaler(SocketControlListenRequest{})

func (msg *SocketControlListenRequest) Marshaler() _bindings.Marshaler {
	return _mSocketControlListenRequest
}

// Implements Payload.
func (_ *SocketControlListenRequest) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *SocketControlListenRequest) InlineSize() int {
	return 8
}

type SocketControlListenResponse struct {
	_    struct{} `fidl2:"s,8,0"`
	Code int16
}

var _mSocketControlListenResponse = _bindings.CreateLazyMarshaler(SocketControlListenResponse{})

func (msg *SocketControlListenResponse) Marshaler() _bindings.Marshaler {
	return _mSocketControlListenResponse
}

// Implements Payload.
func (_ *SocketControlListenResponse) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *SocketControlListenResponse) InlineSize() int {
	return 8
}

type SocketControlGetSockNameResponse struct {
	_    struct{} `fidl2:"s,24,0"`
	Code int16
	Addr []uint8 `fidl:"128" fidl2:"128"`
}

var _mSocketControlGetSockNameResponse = _bindings.CreateLazyMarshaler(SocketControlGetSockNameResponse{})

func (msg *SocketControlGetSockNameResponse) Marshaler() _bindings.Marshaler {
	return _mSocketControlGetSockNameResponse
}

// Implements Payload.
func (_ *SocketControlGetSockNameResponse) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *SocketControlGetSockNameResponse) InlineSize() int {
	return 24
}

type SocketControlGetPeerNameResponse struct {
	_    struct{} `fidl2:"s,24,0"`
	Code int16
	Addr []uint8 `fidl:"128" fidl2:"128"`
}

var _mSocketControlGetPeerNameResponse = _bindings.CreateLazyMarshaler(SocketControlGetPeerNameResponse{})

func (msg *SocketControlGetPeerNameResponse) Marshaler() _bindings.Marshaler {
	return _mSocketControlGetPeerNameResponse
}

// Implements Payload.
func (_ *SocketControlGetPeerNameResponse) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *SocketControlGetPeerNameResponse) InlineSize() int {
	return 24
}

type SocketControlSetSockOptRequest struct {
	_       struct{} `fidl2:"s,24,0"`
	Level   int16
	Optname int16
	Optval  []uint8 `fidl:"900" fidl2:"900"`
}

var _mSocketControlSetSockOptRequest = _bindings.CreateLazyMarshaler(SocketControlSetSockOptRequest{})

func (msg *SocketControlSetSockOptRequest) Marshaler() _bindings.Marshaler {
	return _mSocketControlSetSockOptRequest
}

// Implements Payload.
func (_ *SocketControlSetSockOptRequest) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *SocketControlSetSockOptRequest) InlineSize() int {
	return 24
}

type SocketControlSetSockOptResponse struct {
	_    struct{} `fidl2:"s,8,0"`
	Code int16
}

var _mSocketControlSetSockOptResponse = _bindings.CreateLazyMarshaler(SocketControlSetSockOptResponse{})

func (msg *SocketControlSetSockOptResponse) Marshaler() _bindings.Marshaler {
	return _mSocketControlSetSockOptResponse
}

// Implements Payload.
func (_ *SocketControlSetSockOptResponse) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *SocketControlSetSockOptResponse) InlineSize() int {
	return 8
}

type SocketControlGetSockOptRequest struct {
	_       struct{} `fidl2:"s,8,0"`
	Level   int16
	Optname int16
}

var _mSocketControlGetSockOptRequest = _bindings.CreateLazyMarshaler(SocketControlGetSockOptRequest{})

func (msg *SocketControlGetSockOptRequest) Marshaler() _bindings.Marshaler {
	return _mSocketControlGetSockOptRequest
}

// Implements Payload.
func (_ *SocketControlGetSockOptRequest) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *SocketControlGetSockOptRequest) InlineSize() int {
	return 8
}

type SocketControlGetSockOptResponse struct {
	_      struct{} `fidl2:"s,24,0"`
	Code   int16
	Optval []uint8 `fidl:"900" fidl2:"900"`
}

var _mSocketControlGetSockOptResponse = _bindings.CreateLazyMarshaler(SocketControlGetSockOptResponse{})

func (msg *SocketControlGetSockOptResponse) Marshaler() _bindings.Marshaler {
	return _mSocketControlGetSockOptResponse
}

// Implements Payload.
func (_ *SocketControlGetSockOptResponse) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *SocketControlGetSockOptResponse) InlineSize() int {
	return 24
}

type SocketControlInterface _bindings.SocketControlProxy

func (p *SocketControlInterface) Close() (int16, error) {
	var req_ _bindings.Payload
	resp_ := &SocketControlCloseResponse{}
	err := ((*_bindings.SocketControlProxy)(p)).Call(SocketControlCloseOrdinal, req_, resp_)
	return resp_.Code, err
}

func (p *SocketControlInterface) Ioctl(req int16, in []uint8) (int16, []uint8, error) {
	req_ := &SocketControlIoctlRequest{
		Req: req,
		In:  in,
	}
	resp_ := &SocketControlIoctlResponse{}
	err := ((*_bindings.SocketControlProxy)(p)).Call(SocketControlIoctlOrdinal, req_, resp_)
	return resp_.Code, resp_.Out, err
}

func (p *SocketControlInterface) Connect(addr []uint8) (int16, error) {
	req_ := &SocketControlConnectRequest{
		Addr: addr,
	}
	resp_ := &SocketControlConnectResponse{}
	err := ((*_bindings.SocketControlProxy)(p)).Call(SocketControlConnectOrdinal, req_, resp_)
	return resp_.Code, err
}

func (p *SocketControlInterface) Accept(flags int16) (int16, error) {
	req_ := &SocketControlAcceptRequest{
		Flags: flags,
	}
	resp_ := &SocketControlAcceptResponse{}
	err := ((*_bindings.SocketControlProxy)(p)).Call(SocketControlAcceptOrdinal, req_, resp_)
	return resp_.Code, err
}

func (p *SocketControlInterface) Bind(addr []uint8) (int16, error) {
	req_ := &SocketControlBindRequest{
		Addr: addr,
	}
	resp_ := &SocketControlBindResponse{}
	err := ((*_bindings.SocketControlProxy)(p)).Call(SocketControlBindOrdinal, req_, resp_)
	return resp_.Code, err
}

func (p *SocketControlInterface) Listen(backlog int16) (int16, error) {
	req_ := &SocketControlListenRequest{
		Backlog: backlog,
	}
	resp_ := &SocketControlListenResponse{}
	err := ((*_bindings.SocketControlProxy)(p)).Call(SocketControlListenOrdinal, req_, resp_)
	return resp_.Code, err
}

func (p *SocketControlInterface) GetSockName() (int16, []uint8, error) {
	var req_ _bindings.Payload
	resp_ := &SocketControlGetSockNameResponse{}
	err := ((*_bindings.SocketControlProxy)(p)).Call(SocketControlGetSockNameOrdinal, req_, resp_)
	return resp_.Code, resp_.Addr, err
}

func (p *SocketControlInterface) GetPeerName() (int16, []uint8, error) {
	var req_ _bindings.Payload
	resp_ := &SocketControlGetPeerNameResponse{}
	err := ((*_bindings.SocketControlProxy)(p)).Call(SocketControlGetPeerNameOrdinal, req_, resp_)
	return resp_.Code, resp_.Addr, err
}

func (p *SocketControlInterface) SetSockOpt(level int16, optname int16, optval []uint8) (int16, error) {
	req_ := &SocketControlSetSockOptRequest{
		Level:   level,
		Optname: optname,
		Optval:  optval,
	}
	resp_ := &SocketControlSetSockOptResponse{}
	err := ((*_bindings.SocketControlProxy)(p)).Call(SocketControlSetSockOptOrdinal, req_, resp_)
	return resp_.Code, err
}

func (p *SocketControlInterface) GetSockOpt(level int16, optname int16) (int16, []uint8, error) {
	req_ := &SocketControlGetSockOptRequest{
		Level:   level,
		Optname: optname,
	}
	resp_ := &SocketControlGetSockOptResponse{}
	err := ((*_bindings.SocketControlProxy)(p)).Call(SocketControlGetSockOptOrdinal, req_, resp_)
	return resp_.Code, resp_.Optval, err
}

type SocketControl interface {
	Close() (int16, error)
	Ioctl(req int16, in []uint8) (int16, []uint8, error)
	Connect(addr []uint8) (int16, error)
	Accept(flags int16) (int16, error)
	Bind(addr []uint8) (int16, error)
	Listen(backlog int16) (int16, error)
	GetSockName() (int16, []uint8, error)
	GetPeerName() (int16, []uint8, error)
	SetSockOpt(level int16, optname int16, optval []uint8) (int16, error)
	GetSockOpt(level int16, optname int16) (int16, []uint8, error)
}

type SocketControlTransitionalBase struct{}

type SocketControlStub struct {
	Impl SocketControl
}

func (s *SocketControlStub) Dispatch(ord uint32, b_ []byte, h_ []_zx.Handle) (_bindings.Payload, error) {
	switch ord {
	case SocketControlCloseOrdinal:
		code, err_ := s.Impl.Close()
		out_ := SocketControlCloseResponse{}
		out_.Code = code
		return &out_, err_
	case SocketControlIoctlOrdinal:
		in_ := SocketControlIoctlRequest{}
		if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
			return nil, err_
		}
		code, out, err_ := s.Impl.Ioctl(in_.Req, in_.In)
		out_ := SocketControlIoctlResponse{}
		out_.Code = code
		out_.Out = out
		return &out_, err_
	case SocketControlConnectOrdinal:
		in_ := SocketControlConnectRequest{}
		if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
			return nil, err_
		}
		code, err_ := s.Impl.Connect(in_.Addr)
		out_ := SocketControlConnectResponse{}
		out_.Code = code
		return &out_, err_
	case SocketControlAcceptOrdinal:
		in_ := SocketControlAcceptRequest{}
		if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
			return nil, err_
		}
		code, err_ := s.Impl.Accept(in_.Flags)
		out_ := SocketControlAcceptResponse{}
		out_.Code = code
		return &out_, err_
	case SocketControlBindOrdinal:
		in_ := SocketControlBindRequest{}
		if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
			return nil, err_
		}
		code, err_ := s.Impl.Bind(in_.Addr)
		out_ := SocketControlBindResponse{}
		out_.Code = code
		return &out_, err_
	case SocketControlListenOrdinal:
		in_ := SocketControlListenRequest{}
		if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
			return nil, err_
		}
		code, err_ := s.Impl.Listen(in_.Backlog)
		out_ := SocketControlListenResponse{}
		out_.Code = code
		return &out_, err_
	case SocketControlGetSockNameOrdinal:
		code, addr, err_ := s.Impl.GetSockName()
		out_ := SocketControlGetSockNameResponse{}
		out_.Code = code
		out_.Addr = addr
		return &out_, err_
	case SocketControlGetPeerNameOrdinal:
		code, addr, err_ := s.Impl.GetPeerName()
		out_ := SocketControlGetPeerNameResponse{}
		out_.Code = code
		out_.Addr = addr
		return &out_, err_
	case SocketControlSetSockOptOrdinal:
		in_ := SocketControlSetSockOptRequest{}
		if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
			return nil, err_
		}
		code, err_ := s.Impl.SetSockOpt(in_.Level, in_.Optname, in_.Optval)
		out_ := SocketControlSetSockOptResponse{}
		out_.Code = code
		return &out_, err_
	case SocketControlGetSockOptOrdinal:
		in_ := SocketControlGetSockOptRequest{}
		if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
			return nil, err_
		}
		code, optval, err_ := s.Impl.GetSockOpt(in_.Level, in_.Optname)
		out_ := SocketControlGetSockOptResponse{}
		out_.Code = code
		out_.Optval = optval
		return &out_, err_
	}
	return nil, _bindings.ErrUnknownOrdinal
}

type SocketControlEventProxy _bindings.SocketControlProxy