// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: github.com/Microsoft/hcsshim/pkg/ncproxy/ncproxygrpc/v1/networkconfigproxy.proto

package v1

import (
	context "context"
	fmt "fmt"
	proto "github.com/gogo/protobuf/proto"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	io "io"
	math "math"
	math_bits "math/bits"
	reflect "reflect"
	strings "strings"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package

type HostComputeNetworkSettings_NetworkMode int32

const (
	HostComputeNetworkSettings_Transparent HostComputeNetworkSettings_NetworkMode = 0
	HostComputeNetworkSettings_NAT         HostComputeNetworkSettings_NetworkMode = 1
)

var HostComputeNetworkSettings_NetworkMode_name = map[int32]string{
	0: "Transparent",
	1: "NAT",
}

var HostComputeNetworkSettings_NetworkMode_value = map[string]int32{
	"Transparent": 0,
	"NAT":         1,
}

func (x HostComputeNetworkSettings_NetworkMode) String() string {
	return proto.EnumName(HostComputeNetworkSettings_NetworkMode_name, int32(x))
}

func (HostComputeNetworkSettings_NetworkMode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_f8f0dd742f8ac3db, []int{9, 0}
}

type HostComputeNetworkSettings_IpamType int32

const (
	HostComputeNetworkSettings_Static HostComputeNetworkSettings_IpamType = 0
	HostComputeNetworkSettings_DHCP   HostComputeNetworkSettings_IpamType = 1
)

var HostComputeNetworkSettings_IpamType_name = map[int32]string{
	0: "Static",
	1: "DHCP",
}

var HostComputeNetworkSettings_IpamType_value = map[string]int32{
	"Static": 0,
	"DHCP":   1,
}

func (x HostComputeNetworkSettings_IpamType) String() string {
	return proto.EnumName(HostComputeNetworkSettings_IpamType_name, int32(x))
}

func (HostComputeNetworkSettings_IpamType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_f8f0dd742f8ac3db, []int{9, 1}
}

type AddNICRequest struct {
	ContainerID          string            `protobuf:"bytes,1,opt,name=container_id,json=containerId,proto3" json:"container_id,omitempty"`
	NicID                string            `protobuf:"bytes,2,opt,name=nic_id,json=nicId,proto3" json:"nic_id,omitempty"`
	EndpointName         string            `protobuf:"bytes,3,opt,name=endpoint_name,json=endpointName,proto3" json:"endpoint_name,omitempty"`
	EndpointSettings     *EndpointSettings `protobuf:"bytes,4,opt,name=endpoint_settings,json=endpointSettings,proto3" json:"endpoint_settings,omitempty"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

func (m *AddNICRequest) Reset()      { *m = AddNICRequest{} }
func (*AddNICRequest) ProtoMessage() {}
func (*AddNICRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_f8f0dd742f8ac3db, []int{0}
}
func (m *AddNICRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AddNICRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AddNICRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *AddNICRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AddNICRequest.Merge(m, src)
}
func (m *AddNICRequest) XXX_Size() int {
	return m.Size()
}
func (m *AddNICRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_AddNICRequest.DiscardUnknown(m)
}

var xxx_messageInfo_AddNICRequest proto.InternalMessageInfo

type AddNICResponse struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *AddNICResponse) Reset()      { *m = AddNICResponse{} }
func (*AddNICResponse) ProtoMessage() {}
func (*AddNICResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_f8f0dd742f8ac3db, []int{1}
}
func (m *AddNICResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AddNICResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AddNICResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *AddNICResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AddNICResponse.Merge(m, src)
}
func (m *AddNICResponse) XXX_Size() int {
	return m.Size()
}
func (m *AddNICResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_AddNICResponse.DiscardUnknown(m)
}

var xxx_messageInfo_AddNICResponse proto.InternalMessageInfo

type ModifyNICRequest struct {
	ContainerID          string            `protobuf:"bytes,1,opt,name=container_id,json=containerId,proto3" json:"container_id,omitempty"`
	NicID                string            `protobuf:"bytes,2,opt,name=nic_id,json=nicId,proto3" json:"nic_id,omitempty"`
	EndpointName         string            `protobuf:"bytes,3,opt,name=endpoint_name,json=endpointName,proto3" json:"endpoint_name,omitempty"`
	EndpointSettings     *EndpointSettings `protobuf:"bytes,4,opt,name=endpoint_settings,json=endpointSettings,proto3" json:"endpoint_settings,omitempty"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

func (m *ModifyNICRequest) Reset()      { *m = ModifyNICRequest{} }
func (*ModifyNICRequest) ProtoMessage() {}
func (*ModifyNICRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_f8f0dd742f8ac3db, []int{2}
}
func (m *ModifyNICRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ModifyNICRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ModifyNICRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ModifyNICRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ModifyNICRequest.Merge(m, src)
}
func (m *ModifyNICRequest) XXX_Size() int {
	return m.Size()
}
func (m *ModifyNICRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_ModifyNICRequest.DiscardUnknown(m)
}

var xxx_messageInfo_ModifyNICRequest proto.InternalMessageInfo

type ModifyNICResponse struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ModifyNICResponse) Reset()      { *m = ModifyNICResponse{} }
func (*ModifyNICResponse) ProtoMessage() {}
func (*ModifyNICResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_f8f0dd742f8ac3db, []int{3}
}
func (m *ModifyNICResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ModifyNICResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ModifyNICResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ModifyNICResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ModifyNICResponse.Merge(m, src)
}
func (m *ModifyNICResponse) XXX_Size() int {
	return m.Size()
}
func (m *ModifyNICResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_ModifyNICResponse.DiscardUnknown(m)
}

var xxx_messageInfo_ModifyNICResponse proto.InternalMessageInfo

type DeleteNICRequest struct {
	ContainerID          string   `protobuf:"bytes,1,opt,name=container_id,json=containerId,proto3" json:"container_id,omitempty"`
	NicID                string   `protobuf:"bytes,2,opt,name=nic_id,json=nicId,proto3" json:"nic_id,omitempty"`
	EndpointName         string   `protobuf:"bytes,3,opt,name=endpoint_name,json=endpointName,proto3" json:"endpoint_name,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *DeleteNICRequest) Reset()      { *m = DeleteNICRequest{} }
func (*DeleteNICRequest) ProtoMessage() {}
func (*DeleteNICRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_f8f0dd742f8ac3db, []int{4}
}
func (m *DeleteNICRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DeleteNICRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DeleteNICRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *DeleteNICRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DeleteNICRequest.Merge(m, src)
}
func (m *DeleteNICRequest) XXX_Size() int {
	return m.Size()
}
func (m *DeleteNICRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_DeleteNICRequest.DiscardUnknown(m)
}

var xxx_messageInfo_DeleteNICRequest proto.InternalMessageInfo

type DeleteNICResponse struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *DeleteNICResponse) Reset()      { *m = DeleteNICResponse{} }
func (*DeleteNICResponse) ProtoMessage() {}
func (*DeleteNICResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_f8f0dd742f8ac3db, []int{5}
}
func (m *DeleteNICResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DeleteNICResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DeleteNICResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *DeleteNICResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DeleteNICResponse.Merge(m, src)
}
func (m *DeleteNICResponse) XXX_Size() int {
	return m.Size()
}
func (m *DeleteNICResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_DeleteNICResponse.DiscardUnknown(m)
}

var xxx_messageInfo_DeleteNICResponse proto.InternalMessageInfo

type CreateNetworkRequest struct {
	Network              *Network `protobuf:"bytes,1,opt,name=network,proto3" json:"network,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *CreateNetworkRequest) Reset()      { *m = CreateNetworkRequest{} }
func (*CreateNetworkRequest) ProtoMessage() {}
func (*CreateNetworkRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_f8f0dd742f8ac3db, []int{6}
}
func (m *CreateNetworkRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CreateNetworkRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CreateNetworkRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *CreateNetworkRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CreateNetworkRequest.Merge(m, src)
}
func (m *CreateNetworkRequest) XXX_Size() int {
	return m.Size()
}
func (m *CreateNetworkRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_CreateNetworkRequest.DiscardUnknown(m)
}

var xxx_messageInfo_CreateNetworkRequest proto.InternalMessageInfo

type Network struct {
	// Types that are valid to be assigned to Settings:
	//
	//	*Network_HcnNetwork
	//	*Network_NcproxyNetwork
	Settings             isNetwork_Settings `protobuf_oneof:"settings"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
	XXX_unrecognized     []byte             `json:"-"`
	XXX_sizecache        int32              `json:"-"`
}

func (m *Network) Reset()      { *m = Network{} }
func (*Network) ProtoMessage() {}
func (*Network) Descriptor() ([]byte, []int) {
	return fileDescriptor_f8f0dd742f8ac3db, []int{7}
}
func (m *Network) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Network) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Network.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Network) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Network.Merge(m, src)
}
func (m *Network) XXX_Size() int {
	return m.Size()
}
func (m *Network) XXX_DiscardUnknown() {
	xxx_messageInfo_Network.DiscardUnknown(m)
}

var xxx_messageInfo_Network proto.InternalMessageInfo

type isNetwork_Settings interface {
	isNetwork_Settings()
	MarshalTo([]byte) (int, error)
	Size() int
}

type Network_HcnNetwork struct {
	HcnNetwork *HostComputeNetworkSettings `protobuf:"bytes,1,opt,name=hcn_network,json=hcnNetwork,proto3,oneof" json:"hcn_network,omitempty"`
}
type Network_NcproxyNetwork struct {
	NcproxyNetwork *NCProxyNetworkSettings `protobuf:"bytes,2,opt,name=ncproxy_network,json=ncproxyNetwork,proto3,oneof" json:"ncproxy_network,omitempty"`
}

func (*Network_HcnNetwork) isNetwork_Settings()     {}
func (*Network_NcproxyNetwork) isNetwork_Settings() {}

func (m *Network) GetSettings() isNetwork_Settings {
	if m != nil {
		return m.Settings
	}
	return nil
}

func (m *Network) GetHcnNetwork() *HostComputeNetworkSettings {
	if x, ok := m.GetSettings().(*Network_HcnNetwork); ok {
		return x.HcnNetwork
	}
	return nil
}

func (m *Network) GetNcproxyNetwork() *NCProxyNetworkSettings {
	if x, ok := m.GetSettings().(*Network_NcproxyNetwork); ok {
		return x.NcproxyNetwork
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*Network) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*Network_HcnNetwork)(nil),
		(*Network_NcproxyNetwork)(nil),
	}
}

type NCProxyNetworkSettings struct {
	Name                 string   `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *NCProxyNetworkSettings) Reset()      { *m = NCProxyNetworkSettings{} }
func (*NCProxyNetworkSettings) ProtoMessage() {}
func (*NCProxyNetworkSettings) Descriptor() ([]byte, []int) {
	return fileDescriptor_f8f0dd742f8ac3db, []int{8}
}
func (m *NCProxyNetworkSettings) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *NCProxyNetworkSettings) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_NCProxyNetworkSettings.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *NCProxyNetworkSettings) XXX_Merge(src proto.Message) {
	xxx_messageInfo_NCProxyNetworkSettings.Merge(m, src)
}
func (m *NCProxyNetworkSettings) XXX_Size() int {
	return m.Size()
}
func (m *NCProxyNetworkSettings) XXX_DiscardUnknown() {
	xxx_messageInfo_NCProxyNetworkSettings.DiscardUnknown(m)
}

var xxx_messageInfo_NCProxyNetworkSettings proto.InternalMessageInfo

type HostComputeNetworkSettings struct {
	Name                      string                                 `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Mode                      HostComputeNetworkSettings_NetworkMode `protobuf:"varint,2,opt,name=mode,proto3,enum=ncproxygrpc.v1.HostComputeNetworkSettings_NetworkMode" json:"mode,omitempty"`
	SwitchName                string                                 `protobuf:"bytes,3,opt,name=switch_name,json=switchName,proto3" json:"switch_name,omitempty"`
	IpamType                  HostComputeNetworkSettings_IpamType    `protobuf:"varint,4,opt,name=ipam_type,json=ipamType,proto3,enum=ncproxygrpc.v1.HostComputeNetworkSettings_IpamType" json:"ipam_type,omitempty"`
	SubnetIpaddressPrefix     []string                               `protobuf:"bytes,5,rep,name=subnet_ipaddress_prefix,json=subnetIpaddressPrefix,proto3" json:"subnet_ipaddress_prefix,omitempty"`
	DefaultGateway            string                                 `protobuf:"bytes,6,opt,name=default_gateway,json=defaultGateway,proto3" json:"default_gateway,omitempty"`
	SubnetIpaddressPrefixIpv6 []string                               `protobuf:"bytes,7,rep,name=subnet_ipaddress_prefix_ipv6,json=subnetIpaddressPrefixIpv6,proto3" json:"subnet_ipaddress_prefix_ipv6,omitempty"`
	DefaultGatewayIpv6        string                                 `protobuf:"bytes,8,opt,name=default_gateway_ipv6,json=defaultGatewayIpv6,proto3" json:"default_gateway_ipv6,omitempty"`
	XXX_NoUnkeyedLiteral      struct{}                               `json:"-"`
	XXX_unrecognized          []byte                                 `json:"-"`
	XXX_sizecache             int32                                  `json:"-"`
}

func (m *HostComputeNetworkSettings) Reset()      { *m = HostComputeNetworkSettings{} }
func (*HostComputeNetworkSettings) ProtoMessage() {}
func (*HostComputeNetworkSettings) Descriptor() ([]byte, []int) {
	return fileDescriptor_f8f0dd742f8ac3db, []int{9}
}
func (m *HostComputeNetworkSettings) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *HostComputeNetworkSettings) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_HostComputeNetworkSettings.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *HostComputeNetworkSettings) XXX_Merge(src proto.Message) {
	xxx_messageInfo_HostComputeNetworkSettings.Merge(m, src)
}
func (m *HostComputeNetworkSettings) XXX_Size() int {
	return m.Size()
}
func (m *HostComputeNetworkSettings) XXX_DiscardUnknown() {
	xxx_messageInfo_HostComputeNetworkSettings.DiscardUnknown(m)
}

var xxx_messageInfo_HostComputeNetworkSettings proto.InternalMessageInfo

type CreateNetworkResponse struct {
	ID                   string   `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *CreateNetworkResponse) Reset()      { *m = CreateNetworkResponse{} }
func (*CreateNetworkResponse) ProtoMessage() {}
func (*CreateNetworkResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_f8f0dd742f8ac3db, []int{10}
}
func (m *CreateNetworkResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CreateNetworkResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CreateNetworkResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *CreateNetworkResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CreateNetworkResponse.Merge(m, src)
}
func (m *CreateNetworkResponse) XXX_Size() int {
	return m.Size()
}
func (m *CreateNetworkResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_CreateNetworkResponse.DiscardUnknown(m)
}

var xxx_messageInfo_CreateNetworkResponse proto.InternalMessageInfo

type PortNameEndpointPolicySetting struct {
	PortName             string   `protobuf:"bytes,1,opt,name=port_name,json=portName,proto3" json:"port_name,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *PortNameEndpointPolicySetting) Reset()      { *m = PortNameEndpointPolicySetting{} }
func (*PortNameEndpointPolicySetting) ProtoMessage() {}
func (*PortNameEndpointPolicySetting) Descriptor() ([]byte, []int) {
	return fileDescriptor_f8f0dd742f8ac3db, []int{11}
}
func (m *PortNameEndpointPolicySetting) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *PortNameEndpointPolicySetting) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_PortNameEndpointPolicySetting.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *PortNameEndpointPolicySetting) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PortNameEndpointPolicySetting.Merge(m, src)
}
func (m *PortNameEndpointPolicySetting) XXX_Size() int {
	return m.Size()
}
func (m *PortNameEndpointPolicySetting) XXX_DiscardUnknown() {
	xxx_messageInfo_PortNameEndpointPolicySetting.DiscardUnknown(m)
}

var xxx_messageInfo_PortNameEndpointPolicySetting proto.InternalMessageInfo

type IovEndpointPolicySetting struct {
	IovOffloadWeight     uint32   `protobuf:"varint,1,opt,name=iov_offload_weight,json=iovOffloadWeight,proto3" json:"iov_offload_weight,omitempty"`
	QueuePairsRequested  uint32   `protobuf:"varint,2,opt,name=queue_pairs_requested,json=queuePairsRequested,proto3" json:"queue_pairs_requested,omitempty"`
	InterruptModeration  uint32   `protobuf:"varint,3,opt,name=interrupt_moderation,json=interruptModeration,proto3" json:"interrupt_moderation,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *IovEndpointPolicySetting) Reset()      { *m = IovEndpointPolicySetting{} }
func (*IovEndpointPolicySetting) ProtoMessage() {}
func (*IovEndpointPolicySetting) Descriptor() ([]byte, []int) {
	return fileDescriptor_f8f0dd742f8ac3db, []int{12}
}
func (m *IovEndpointPolicySetting) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *IovEndpointPolicySetting) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_IovEndpointPolicySetting.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *IovEndpointPolicySetting) XXX_Merge(src proto.Message) {
	xxx_messageInfo_IovEndpointPolicySetting.Merge(m, src)
}
func (m *IovEndpointPolicySetting) XXX_Size() int {
	return m.Size()
}
func (m *IovEndpointPolicySetting) XXX_DiscardUnknown() {
	xxx_messageInfo_IovEndpointPolicySetting.DiscardUnknown(m)
}

var xxx_messageInfo_IovEndpointPolicySetting proto.InternalMessageInfo

type DnsSetting struct {
	ServerIpAddrs        []string `protobuf:"bytes,1,rep,name=server_ip_addrs,json=serverIpAddrs,proto3" json:"server_ip_addrs,omitempty"`
	Domain               string   `protobuf:"bytes,2,opt,name=domain,proto3" json:"domain,omitempty"`
	Search               []string `protobuf:"bytes,3,rep,name=search,proto3" json:"search,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *DnsSetting) Reset()      { *m = DnsSetting{} }
func (*DnsSetting) ProtoMessage() {}
func (*DnsSetting) Descriptor() ([]byte, []int) {
	return fileDescriptor_f8f0dd742f8ac3db, []int{13}
}
func (m *DnsSetting) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DnsSetting) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DnsSetting.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *DnsSetting) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DnsSetting.Merge(m, src)
}
func (m *DnsSetting) XXX_Size() int {
	return m.Size()
}
func (m *DnsSetting) XXX_DiscardUnknown() {
	xxx_messageInfo_DnsSetting.DiscardUnknown(m)
}

var xxx_messageInfo_DnsSetting proto.InternalMessageInfo

type CreateEndpointRequest struct {
	EndpointSettings     *EndpointSettings `protobuf:"bytes,1,opt,name=endpoint_settings,json=endpointSettings,proto3" json:"endpoint_settings,omitempty"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

func (m *CreateEndpointRequest) Reset()      { *m = CreateEndpointRequest{} }
func (*CreateEndpointRequest) ProtoMessage() {}
func (*CreateEndpointRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_f8f0dd742f8ac3db, []int{14}
}
func (m *CreateEndpointRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CreateEndpointRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CreateEndpointRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *CreateEndpointRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CreateEndpointRequest.Merge(m, src)
}
func (m *CreateEndpointRequest) XXX_Size() int {
	return m.Size()
}
func (m *CreateEndpointRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_CreateEndpointRequest.DiscardUnknown(m)
}

var xxx_messageInfo_CreateEndpointRequest proto.InternalMessageInfo

type EndpointSettings struct {
	// Types that are valid to be assigned to Settings:
	//
	//	*EndpointSettings_HcnEndpoint
	//	*EndpointSettings_NcproxyEndpoint
	Settings             isEndpointSettings_Settings `protobuf_oneof:"settings"`
	XXX_NoUnkeyedLiteral struct{}                    `json:"-"`
	XXX_unrecognized     []byte                      `json:"-"`
	XXX_sizecache        int32                       `json:"-"`
}

func (m *EndpointSettings) Reset()      { *m = EndpointSettings{} }
func (*EndpointSettings) ProtoMessage() {}
func (*EndpointSettings) Descriptor() ([]byte, []int) {
	return fileDescriptor_f8f0dd742f8ac3db, []int{15}
}
func (m *EndpointSettings) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *EndpointSettings) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_EndpointSettings.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *EndpointSettings) XXX_Merge(src proto.Message) {
	xxx_messageInfo_EndpointSettings.Merge(m, src)
}
func (m *EndpointSettings) XXX_Size() int {
	return m.Size()
}
func (m *EndpointSettings) XXX_DiscardUnknown() {
	xxx_messageInfo_EndpointSettings.DiscardUnknown(m)
}

var xxx_messageInfo_EndpointSettings proto.InternalMessageInfo

type isEndpointSettings_Settings interface {
	isEndpointSettings_Settings()
	MarshalTo([]byte) (int, error)
	Size() int
}

type EndpointSettings_HcnEndpoint struct {
	HcnEndpoint *HcnEndpointSettings `protobuf:"bytes,1,opt,name=hcn_endpoint,json=hcnEndpoint,proto3,oneof" json:"hcn_endpoint,omitempty"`
}
type EndpointSettings_NcproxyEndpoint struct {
	NcproxyEndpoint *NCProxyEndpointSettings `protobuf:"bytes,2,opt,name=ncproxy_endpoint,json=ncproxyEndpoint,proto3,oneof" json:"ncproxy_endpoint,omitempty"`
}

func (*EndpointSettings_HcnEndpoint) isEndpointSettings_Settings()     {}
func (*EndpointSettings_NcproxyEndpoint) isEndpointSettings_Settings() {}

func (m *EndpointSettings) GetSettings() isEndpointSettings_Settings {
	if m != nil {
		return m.Settings
	}
	return nil
}

func (m *EndpointSettings) GetHcnEndpoint() *HcnEndpointSettings {
	if x, ok := m.GetSettings().(*EndpointSettings_HcnEndpoint); ok {
		return x.HcnEndpoint
	}
	return nil
}

func (m *EndpointSettings) GetNcproxyEndpoint() *NCProxyEndpointSettings {
	if x, ok := m.GetSettings().(*EndpointSettings_NcproxyEndpoint); ok {
		return x.NcproxyEndpoint
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*EndpointSettings) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*EndpointSettings_HcnEndpoint)(nil),
		(*EndpointSettings_NcproxyEndpoint)(nil),
	}
}

type HcnEndpointResponse struct {
	Namespace            string               `protobuf:"bytes,1,opt,name=namespace,proto3" json:"namespace,omitempty"`
	ID                   string               `protobuf:"bytes,2,opt,name=id,proto3" json:"id,omitempty"`
	Settings             *HcnEndpointSettings `protobuf:"bytes,3,opt,name=settings,proto3" json:"settings,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

func (m *HcnEndpointResponse) Reset()      { *m = HcnEndpointResponse{} }
func (*HcnEndpointResponse) ProtoMessage() {}
func (*HcnEndpointResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_f8f0dd742f8ac3db, []int{16}
}
func (m *HcnEndpointResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *HcnEndpointResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_HcnEndpointResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *HcnEndpointResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_HcnEndpointResponse.Merge(m, src)
}
func (m *HcnEndpointResponse) XXX_Size() int {
	return m.Size()
}
func (m *HcnEndpointResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_HcnEndpointResponse.DiscardUnknown(m)
}

var xxx_messageInfo_HcnEndpointResponse proto.InternalMessageInfo

type HcnEndpointSettings struct {
	Name                    string               `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Macaddress              string               `protobuf:"bytes,2,opt,name=macaddress,proto3" json:"macaddress,omitempty"`
	Ipaddress               string               `protobuf:"bytes,3,opt,name=ipaddress,proto3" json:"ipaddress,omitempty"`
	IpaddressPrefixlength   uint32               `protobuf:"varint,4,opt,name=ipaddress_prefixlength,json=ipaddressPrefixlength,proto3" json:"ipaddress_prefixlength,omitempty"`
	NetworkName             string               `protobuf:"bytes,5,opt,name=network_name,json=networkName,proto3" json:"network_name,omitempty"`
	Policies                *HcnEndpointPolicies `protobuf:"bytes,6,opt,name=policies,proto3" json:"policies,omitempty"`
	DnsSetting              *DnsSetting          `protobuf:"bytes,7,opt,name=dns_setting,json=dnsSetting,proto3" json:"dns_setting,omitempty"`
	Ipv6Address             string               `protobuf:"bytes,8,opt,name=ipv6address,proto3" json:"ipv6address,omitempty"`
	Ipv6AddressPrefixlength uint32               `protobuf:"varint,9,opt,name=ipv6address_prefixlength,json=ipv6addressPrefixlength,proto3" json:"ipv6address_prefixlength,omitempty"`
	XXX_NoUnkeyedLiteral    struct{}             `json:"-"`
	XXX_unrecognized        []byte               `json:"-"`
	XXX_sizecache           int32                `json:"-"`
}

func (m *HcnEndpointSettings) Reset()      { *m = HcnEndpointSettings{} }
func (*HcnEndpointSettings) ProtoMessage() {}
func (*HcnEndpointSettings) Descriptor() ([]byte, []int) {
	return fileDescriptor_f8f0dd742f8ac3db, []int{17}
}
func (m *HcnEndpointSettings) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *HcnEndpointSettings) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_HcnEndpointSettings.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *HcnEndpointSettings) XXX_Merge(src proto.Message) {
	xxx_messageInfo_HcnEndpointSettings.Merge(m, src)
}
func (m *HcnEndpointSettings) XXX_Size() int {
	return m.Size()
}
func (m *HcnEndpointSettings) XXX_DiscardUnknown() {
	xxx_messageInfo_HcnEndpointSettings.DiscardUnknown(m)
}

var xxx_messageInfo_HcnEndpointSettings proto.InternalMessageInfo

type HcnEndpointPolicies struct {
	PortnamePolicySetting *PortNameEndpointPolicySetting `protobuf:"bytes,1,opt,name=portname_policy_setting,json=portnamePolicySetting,proto3" json:"portname_policy_setting,omitempty"`
	IovPolicySettings     *IovEndpointPolicySetting      `protobuf:"bytes,2,opt,name=iov_policy_settings,json=iovPolicySettings,proto3" json:"iov_policy_settings,omitempty"`
	XXX_NoUnkeyedLiteral  struct{}                       `json:"-"`
	XXX_unrecognized      []byte                         `json:"-"`
	XXX_sizecache         int32                          `json:"-"`
}

func (m *HcnEndpointPolicies) Reset()      { *m = HcnEndpointPolicies{} }
func (*HcnEndpointPolicies) ProtoMessage() {}
func (*HcnEndpointPolicies) Descriptor() ([]byte, []int) {
	return fileDescriptor_f8f0dd742f8ac3db, []int{18}
}
func (m *HcnEndpointPolicies) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *HcnEndpointPolicies) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_HcnEndpointPolicies.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *HcnEndpointPolicies) XXX_Merge(src proto.Message) {
	xxx_messageInfo_HcnEndpointPolicies.Merge(m, src)
}
func (m *HcnEndpointPolicies) XXX_Size() int {
	return m.Size()
}
func (m *HcnEndpointPolicies) XXX_DiscardUnknown() {
	xxx_messageInfo_HcnEndpointPolicies.DiscardUnknown(m)
}

var xxx_messageInfo_HcnEndpointPolicies proto.InternalMessageInfo

type NCProxyEndpointSettings struct {
	Name                  string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Macaddress            string `protobuf:"bytes,2,opt,name=macaddress,proto3" json:"macaddress,omitempty"`
	Ipaddress             string `protobuf:"bytes,3,opt,name=ipaddress,proto3" json:"ipaddress,omitempty"`
	IpaddressPrefixlength uint32 `protobuf:"varint,4,opt,name=ipaddress_prefixlength,json=ipaddressPrefixlength,proto3" json:"ipaddress_prefixlength,omitempty"`
	NetworkName           string `protobuf:"bytes,5,opt,name=network_name,json=networkName,proto3" json:"network_name,omitempty"`
	DefaultGateway        string `protobuf:"bytes,6,opt,name=default_gateway,json=defaultGateway,proto3" json:"default_gateway,omitempty"`
	// Types that are valid to be assigned to DeviceDetails:
	//
	//	*NCProxyEndpointSettings_PciDeviceDetails
	DeviceDetails           isNCProxyEndpointSettings_DeviceDetails `protobuf_oneof:"device_details"`
	Ipv6Address             string                                  `protobuf:"bytes,8,opt,name=ipv6address,proto3" json:"ipv6address,omitempty"`
	Ipv6AddressPrefixlength string                                  `protobuf:"bytes,9,opt,name=ipv6address_prefixlength,json=ipv6addressPrefixlength,proto3" json:"ipv6address_prefixlength,omitempty"`
	XXX_NoUnkeyedLiteral    struct{}                                `json:"-"`
	XXX_unrecognized        []byte                                  `json:"-"`
	XXX_sizecache           int32                                   `json:"-"`
}

func (m *NCProxyEndpointSettings) Reset()      { *m = NCProxyEndpointSettings{} }
func (*NCProxyEndpointSettings) ProtoMessage() {}
func (*NCProxyEndpointSettings) Descriptor() ([]byte, []int) {
	return fileDescriptor_f8f0dd742f8ac3db, []int{19}
}
func (m *NCProxyEndpointSettings) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *NCProxyEndpointSettings) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_NCProxyEndpointSettings.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *NCProxyEndpointSettings) XXX_Merge(src proto.Message) {
	xxx_messageInfo_NCProxyEndpointSettings.Merge(m, src)
}
func (m *NCProxyEndpointSettings) XXX_Size() int {
	return m.Size()
}
func (m *NCProxyEndpointSettings) XXX_DiscardUnknown() {
	xxx_messageInfo_NCProxyEndpointSettings.DiscardUnknown(m)
}

var xxx_messageInfo_NCProxyEndpointSettings proto.InternalMessageInfo

type isNCProxyEndpointSettings_DeviceDetails interface {
	isNCProxyEndpointSettings_DeviceDetails()
	MarshalTo([]byte) (int, error)
	Size() int
}

type NCProxyEndpointSettings_PciDeviceDetails struct {
	PciDeviceDetails *PCIDeviceDetails `protobuf:"bytes,7,opt,name=pci_device_details,json=pciDeviceDetails,proto3,oneof" json:"pci_device_details,omitempty"`
}

func (*NCProxyEndpointSettings_PciDeviceDetails) isNCProxyEndpointSettings_DeviceDetails() {}

func (m *NCProxyEndpointSettings) GetDeviceDetails() isNCProxyEndpointSettings_DeviceDetails {
	if m != nil {
		return m.DeviceDetails
	}
	return nil
}

func (m *NCProxyEndpointSettings) GetPciDeviceDetails() *PCIDeviceDetails {
	if x, ok := m.GetDeviceDetails().(*NCProxyEndpointSettings_PciDeviceDetails); ok {
		return x.PciDeviceDetails
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*NCProxyEndpointSettings) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*NCProxyEndpointSettings_PciDeviceDetails)(nil),
	}
}

type PCIDeviceDetails struct {
	DeviceID             string   `protobuf:"bytes,1,opt,name=device_id,json=deviceId,proto3" json:"device_id,omitempty"`
	VirtualFunctionIndex uint32   `protobuf:"varint,2,opt,name=virtual_function_index,json=virtualFunctionIndex,proto3" json:"virtual_function_index,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *PCIDeviceDetails) Reset()      { *m = PCIDeviceDetails{} }
func (*PCIDeviceDetails) ProtoMessage() {}
func (*PCIDeviceDetails) Descriptor() ([]byte, []int) {
	return fileDescriptor_f8f0dd742f8ac3db, []int{20}
}
func (m *PCIDeviceDetails) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *PCIDeviceDetails) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_PCIDeviceDetails.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *PCIDeviceDetails) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PCIDeviceDetails.Merge(m, src)
}
func (m *PCIDeviceDetails) XXX_Size() int {
	return m.Size()
}
func (m *PCIDeviceDetails) XXX_DiscardUnknown() {
	xxx_messageInfo_PCIDeviceDetails.DiscardUnknown(m)
}

var xxx_messageInfo_PCIDeviceDetails proto.InternalMessageInfo

type CreateEndpointResponse struct {
	ID                   string   `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *CreateEndpointResponse) Reset()      { *m = CreateEndpointResponse{} }
func (*CreateEndpointResponse) ProtoMessage() {}
func (*CreateEndpointResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_f8f0dd742f8ac3db, []int{21}
}
func (m *CreateEndpointResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CreateEndpointResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CreateEndpointResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *CreateEndpointResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CreateEndpointResponse.Merge(m, src)
}
func (m *CreateEndpointResponse) XXX_Size() int {
	return m.Size()
}
func (m *CreateEndpointResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_CreateEndpointResponse.DiscardUnknown(m)
}

var xxx_messageInfo_CreateEndpointResponse proto.InternalMessageInfo

type AddEndpointRequest struct {
	Name                 string   `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	NamespaceID          string   `protobuf:"bytes,2,opt,name=namespace_id,json=namespaceId,proto3" json:"namespace_id,omitempty"`
	AttachToHost         bool     `protobuf:"varint,3,opt,name=attach_to_host,json=attachToHost,proto3" json:"attach_to_host,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *AddEndpointRequest) Reset()      { *m = AddEndpointRequest{} }
func (*AddEndpointRequest) ProtoMessage() {}
func (*AddEndpointRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_f8f0dd742f8ac3db, []int{22}
}
func (m *AddEndpointRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AddEndpointRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AddEndpointRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *AddEndpointRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AddEndpointRequest.Merge(m, src)
}
func (m *AddEndpointRequest) XXX_Size() int {
	return m.Size()
}
func (m *AddEndpointRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_AddEndpointRequest.DiscardUnknown(m)
}

var xxx_messageInfo_AddEndpointRequest proto.InternalMessageInfo

type AddEndpointResponse struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *AddEndpointResponse) Reset()      { *m = AddEndpointResponse{} }
func (*AddEndpointResponse) ProtoMessage() {}
func (*AddEndpointResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_f8f0dd742f8ac3db, []int{23}
}
func (m *AddEndpointResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AddEndpointResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AddEndpointResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *AddEndpointResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AddEndpointResponse.Merge(m, src)
}
func (m *AddEndpointResponse) XXX_Size() int {
	return m.Size()
}
func (m *AddEndpointResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_AddEndpointResponse.DiscardUnknown(m)
}

var xxx_messageInfo_AddEndpointResponse proto.InternalMessageInfo

type DeleteEndpointRequest struct {
	Name                 string   `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *DeleteEndpointRequest) Reset()      { *m = DeleteEndpointRequest{} }
func (*DeleteEndpointRequest) ProtoMessage() {}
func (*DeleteEndpointRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_f8f0dd742f8ac3db, []int{24}
}
func (m *DeleteEndpointRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DeleteEndpointRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DeleteEndpointRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *DeleteEndpointRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DeleteEndpointRequest.Merge(m, src)
}
func (m *DeleteEndpointRequest) XXX_Size() int {
	return m.Size()
}
func (m *DeleteEndpointRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_DeleteEndpointRequest.DiscardUnknown(m)
}

var xxx_messageInfo_DeleteEndpointRequest proto.InternalMessageInfo

type DeleteEndpointResponse struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *DeleteEndpointResponse) Reset()      { *m = DeleteEndpointResponse{} }
func (*DeleteEndpointResponse) ProtoMessage() {}
func (*DeleteEndpointResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_f8f0dd742f8ac3db, []int{25}
}
func (m *DeleteEndpointResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DeleteEndpointResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DeleteEndpointResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *DeleteEndpointResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DeleteEndpointResponse.Merge(m, src)
}
func (m *DeleteEndpointResponse) XXX_Size() int {
	return m.Size()
}
func (m *DeleteEndpointResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_DeleteEndpointResponse.DiscardUnknown(m)
}

var xxx_messageInfo_DeleteEndpointResponse proto.InternalMessageInfo

type DeleteNetworkRequest struct {
	Name                 string   `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *DeleteNetworkRequest) Reset()      { *m = DeleteNetworkRequest{} }
func (*DeleteNetworkRequest) ProtoMessage() {}
func (*DeleteNetworkRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_f8f0dd742f8ac3db, []int{26}
}
func (m *DeleteNetworkRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DeleteNetworkRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DeleteNetworkRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *DeleteNetworkRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DeleteNetworkRequest.Merge(m, src)
}
func (m *DeleteNetworkRequest) XXX_Size() int {
	return m.Size()
}
func (m *DeleteNetworkRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_DeleteNetworkRequest.DiscardUnknown(m)
}

var xxx_messageInfo_DeleteNetworkRequest proto.InternalMessageInfo

type DeleteNetworkResponse struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *DeleteNetworkResponse) Reset()      { *m = DeleteNetworkResponse{} }
func (*DeleteNetworkResponse) ProtoMessage() {}
func (*DeleteNetworkResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_f8f0dd742f8ac3db, []int{27}
}
func (m *DeleteNetworkResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DeleteNetworkResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DeleteNetworkResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *DeleteNetworkResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DeleteNetworkResponse.Merge(m, src)
}
func (m *DeleteNetworkResponse) XXX_Size() int {
	return m.Size()
}
func (m *DeleteNetworkResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_DeleteNetworkResponse.DiscardUnknown(m)
}

var xxx_messageInfo_DeleteNetworkResponse proto.InternalMessageInfo

type GetEndpointRequest struct {
	Name                 string   `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *GetEndpointRequest) Reset()      { *m = GetEndpointRequest{} }
func (*GetEndpointRequest) ProtoMessage() {}
func (*GetEndpointRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_f8f0dd742f8ac3db, []int{28}
}
func (m *GetEndpointRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GetEndpointRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetEndpointRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *GetEndpointRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetEndpointRequest.Merge(m, src)
}
func (m *GetEndpointRequest) XXX_Size() int {
	return m.Size()
}
func (m *GetEndpointRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_GetEndpointRequest.DiscardUnknown(m)
}

var xxx_messageInfo_GetEndpointRequest proto.InternalMessageInfo

type GetEndpointResponse struct {
	Namespace            string            `protobuf:"bytes,1,opt,name=namespace,proto3" json:"namespace,omitempty"`
	ID                   string            `protobuf:"bytes,2,opt,name=id,proto3" json:"id,omitempty"`
	Endpoint             *EndpointSettings `protobuf:"bytes,3,opt,name=endpoint,proto3" json:"endpoint,omitempty"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

func (m *GetEndpointResponse) Reset()      { *m = GetEndpointResponse{} }
func (*GetEndpointResponse) ProtoMessage() {}
func (*GetEndpointResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_f8f0dd742f8ac3db, []int{29}
}
func (m *GetEndpointResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GetEndpointResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetEndpointResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *GetEndpointResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetEndpointResponse.Merge(m, src)
}
func (m *GetEndpointResponse) XXX_Size() int {
	return m.Size()
}
func (m *GetEndpointResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_GetEndpointResponse.DiscardUnknown(m)
}

var xxx_messageInfo_GetEndpointResponse proto.InternalMessageInfo

type GetNetworkRequest struct {
	Name                 string   `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *GetNetworkRequest) Reset()      { *m = GetNetworkRequest{} }
func (*GetNetworkRequest) ProtoMessage() {}
func (*GetNetworkRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_f8f0dd742f8ac3db, []int{30}
}
func (m *GetNetworkRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GetNetworkRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetNetworkRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *GetNetworkRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetNetworkRequest.Merge(m, src)
}
func (m *GetNetworkRequest) XXX_Size() int {
	return m.Size()
}
func (m *GetNetworkRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_GetNetworkRequest.DiscardUnknown(m)
}

var xxx_messageInfo_GetNetworkRequest proto.InternalMessageInfo

type GetNetworkResponse struct {
	ID                   string    `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Network              *Network  `protobuf:"bytes,2,opt,name=network,proto3" json:"network,omitempty"`
	MacRange             *MacRange `protobuf:"bytes,3,opt,name=macRange,proto3" json:"macRange,omitempty"`
	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
	XXX_unrecognized     []byte    `json:"-"`
	XXX_sizecache        int32     `json:"-"`
}

func (m *GetNetworkResponse) Reset()      { *m = GetNetworkResponse{} }
func (*GetNetworkResponse) ProtoMessage() {}
func (*GetNetworkResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_f8f0dd742f8ac3db, []int{31}
}
func (m *GetNetworkResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GetNetworkResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetNetworkResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *GetNetworkResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetNetworkResponse.Merge(m, src)
}
func (m *GetNetworkResponse) XXX_Size() int {
	return m.Size()
}
func (m *GetNetworkResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_GetNetworkResponse.DiscardUnknown(m)
}

var xxx_messageInfo_GetNetworkResponse proto.InternalMessageInfo

type MacRange struct {
	StartMacAddress      string   `protobuf:"bytes,1,opt,name=startMacAddress,proto3" json:"startMacAddress,omitempty"`
	EndMacAddress        string   `protobuf:"bytes,2,opt,name=endMacAddress,proto3" json:"endMacAddress,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *MacRange) Reset()      { *m = MacRange{} }
func (*MacRange) ProtoMessage() {}
func (*MacRange) Descriptor() ([]byte, []int) {
	return fileDescriptor_f8f0dd742f8ac3db, []int{32}
}
func (m *MacRange) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MacRange) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MacRange.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *MacRange) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MacRange.Merge(m, src)
}
func (m *MacRange) XXX_Size() int {
	return m.Size()
}
func (m *MacRange) XXX_DiscardUnknown() {
	xxx_messageInfo_MacRange.DiscardUnknown(m)
}

var xxx_messageInfo_MacRange proto.InternalMessageInfo

type GetEndpointsRequest struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *GetEndpointsRequest) Reset()      { *m = GetEndpointsRequest{} }
func (*GetEndpointsRequest) ProtoMessage() {}
func (*GetEndpointsRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_f8f0dd742f8ac3db, []int{33}
}
func (m *GetEndpointsRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GetEndpointsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetEndpointsRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *GetEndpointsRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetEndpointsRequest.Merge(m, src)
}
func (m *GetEndpointsRequest) XXX_Size() int {
	return m.Size()
}
func (m *GetEndpointsRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_GetEndpointsRequest.DiscardUnknown(m)
}

var xxx_messageInfo_GetEndpointsRequest proto.InternalMessageInfo

type GetEndpointsResponse struct {
	Endpoints            []*GetEndpointResponse `protobuf:"bytes,1,rep,name=endpoints,proto3" json:"endpoints,omitempty"`
	XXX_NoUnkeyedLiteral struct{}               `json:"-"`
	XXX_unrecognized     []byte                 `json:"-"`
	XXX_sizecache        int32                  `json:"-"`
}

func (m *GetEndpointsResponse) Reset()      { *m = GetEndpointsResponse{} }
func (*GetEndpointsResponse) ProtoMessage() {}
func (*GetEndpointsResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_f8f0dd742f8ac3db, []int{34}
}
func (m *GetEndpointsResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GetEndpointsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetEndpointsResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *GetEndpointsResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetEndpointsResponse.Merge(m, src)
}
func (m *GetEndpointsResponse) XXX_Size() int {
	return m.Size()
}
func (m *GetEndpointsResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_GetEndpointsResponse.DiscardUnknown(m)
}

var xxx_messageInfo_GetEndpointsResponse proto.InternalMessageInfo

type GetNetworksRequest struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *GetNetworksRequest) Reset()      { *m = GetNetworksRequest{} }
func (*GetNetworksRequest) ProtoMessage() {}
func (*GetNetworksRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_f8f0dd742f8ac3db, []int{35}
}
func (m *GetNetworksRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GetNetworksRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetNetworksRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *GetNetworksRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetNetworksRequest.Merge(m, src)
}
func (m *GetNetworksRequest) XXX_Size() int {
	return m.Size()
}
func (m *GetNetworksRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_GetNetworksRequest.DiscardUnknown(m)
}

var xxx_messageInfo_GetNetworksRequest proto.InternalMessageInfo

type GetNetworksResponse struct {
	Networks             []*GetNetworkResponse `protobuf:"bytes,1,rep,name=networks,proto3" json:"networks,omitempty"`
	XXX_NoUnkeyedLiteral struct{}              `json:"-"`
	XXX_unrecognized     []byte                `json:"-"`
	XXX_sizecache        int32                 `json:"-"`
}

func (m *GetNetworksResponse) Reset()      { *m = GetNetworksResponse{} }
func (*GetNetworksResponse) ProtoMessage() {}
func (*GetNetworksResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_f8f0dd742f8ac3db, []int{36}
}
func (m *GetNetworksResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GetNetworksResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetNetworksResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *GetNetworksResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetNetworksResponse.Merge(m, src)
}
func (m *GetNetworksResponse) XXX_Size() int {
	return m.Size()
}
func (m *GetNetworksResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_GetNetworksResponse.DiscardUnknown(m)
}

var xxx_messageInfo_GetNetworksResponse proto.InternalMessageInfo

func init() {
	proto.RegisterEnum("ncproxygrpc.v1.HostComputeNetworkSettings_NetworkMode", HostComputeNetworkSettings_NetworkMode_name, HostComputeNetworkSettings_NetworkMode_value)
	proto.RegisterEnum("ncproxygrpc.v1.HostComputeNetworkSettings_IpamType", HostComputeNetworkSettings_IpamType_name, HostComputeNetworkSettings_IpamType_value)
	proto.RegisterType((*AddNICRequest)(nil), "ncproxygrpc.v1.AddNICRequest")
	proto.RegisterType((*AddNICResponse)(nil), "ncproxygrpc.v1.AddNICResponse")
	proto.RegisterType((*ModifyNICRequest)(nil), "ncproxygrpc.v1.ModifyNICRequest")
	proto.RegisterType((*ModifyNICResponse)(nil), "ncproxygrpc.v1.ModifyNICResponse")
	proto.RegisterType((*DeleteNICRequest)(nil), "ncproxygrpc.v1.DeleteNICRequest")
	proto.RegisterType((*DeleteNICResponse)(nil), "ncproxygrpc.v1.DeleteNICResponse")
	proto.RegisterType((*CreateNetworkRequest)(nil), "ncproxygrpc.v1.CreateNetworkRequest")
	proto.RegisterType((*Network)(nil), "ncproxygrpc.v1.Network")
	proto.RegisterType((*NCProxyNetworkSettings)(nil), "ncproxygrpc.v1.NCProxyNetworkSettings")
	proto.RegisterType((*HostComputeNetworkSettings)(nil), "ncproxygrpc.v1.HostComputeNetworkSettings")
	proto.RegisterType((*CreateNetworkResponse)(nil), "ncproxygrpc.v1.CreateNetworkResponse")
	proto.RegisterType((*PortNameEndpointPolicySetting)(nil), "ncproxygrpc.v1.PortNameEndpointPolicySetting")
	proto.RegisterType((*IovEndpointPolicySetting)(nil), "ncproxygrpc.v1.IovEndpointPolicySetting")
	proto.RegisterType((*DnsSetting)(nil), "ncproxygrpc.v1.DnsSetting")
	proto.RegisterType((*CreateEndpointRequest)(nil), "ncproxygrpc.v1.CreateEndpointRequest")
	proto.RegisterType((*EndpointSettings)(nil), "ncproxygrpc.v1.EndpointSettings")
	proto.RegisterType((*HcnEndpointResponse)(nil), "ncproxygrpc.v1.HcnEndpointResponse")
	proto.RegisterType((*HcnEndpointSettings)(nil), "ncproxygrpc.v1.HcnEndpointSettings")
	proto.RegisterType((*HcnEndpointPolicies)(nil), "ncproxygrpc.v1.HcnEndpointPolicies")
	proto.RegisterType((*NCProxyEndpointSettings)(nil), "ncproxygrpc.v1.NCProxyEndpointSettings")
	proto.RegisterType((*PCIDeviceDetails)(nil), "ncproxygrpc.v1.PCIDeviceDetails")
	proto.RegisterType((*CreateEndpointResponse)(nil), "ncproxygrpc.v1.CreateEndpointResponse")
	proto.RegisterType((*AddEndpointRequest)(nil), "ncproxygrpc.v1.AddEndpointRequest")
	proto.RegisterType((*AddEndpointResponse)(nil), "ncproxygrpc.v1.AddEndpointResponse")
	proto.RegisterType((*DeleteEndpointRequest)(nil), "ncproxygrpc.v1.DeleteEndpointRequest")
	proto.RegisterType((*DeleteEndpointResponse)(nil), "ncproxygrpc.v1.DeleteEndpointResponse")
	proto.RegisterType((*DeleteNetworkRequest)(nil), "ncproxygrpc.v1.DeleteNetworkRequest")
	proto.RegisterType((*DeleteNetworkResponse)(nil), "ncproxygrpc.v1.DeleteNetworkResponse")
	proto.RegisterType((*GetEndpointRequest)(nil), "ncproxygrpc.v1.GetEndpointRequest")
	proto.RegisterType((*GetEndpointResponse)(nil), "ncproxygrpc.v1.GetEndpointResponse")
	proto.RegisterType((*GetNetworkRequest)(nil), "ncproxygrpc.v1.GetNetworkRequest")
	proto.RegisterType((*GetNetworkResponse)(nil), "ncproxygrpc.v1.GetNetworkResponse")
	proto.RegisterType((*MacRange)(nil), "ncproxygrpc.v1.MacRange")
	proto.RegisterType((*GetEndpointsRequest)(nil), "ncproxygrpc.v1.GetEndpointsRequest")
	proto.RegisterType((*GetEndpointsResponse)(nil), "ncproxygrpc.v1.GetEndpointsResponse")
	proto.RegisterType((*GetNetworksRequest)(nil), "ncproxygrpc.v1.GetNetworksRequest")
	proto.RegisterType((*GetNetworksResponse)(nil), "ncproxygrpc.v1.GetNetworksResponse")
}

func init() {
	proto.RegisterFile("github.com/Microsoft/hcsshim/pkg/ncproxy/ncproxygrpc/v1/networkconfigproxy.proto", fileDescriptor_f8f0dd742f8ac3db)
}

var fileDescriptor_f8f0dd742f8ac3db = []byte{
	// 1760 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xdc, 0x58, 0xdd, 0x73, 0xe3, 0x56,
	0x15, 0xb7, 0xe2, 0x6c, 0x22, 0x1f, 0x7f, 0xc4, 0x7b, 0x9d, 0x0f, 0x63, 0x5a, 0x27, 0xab, 0xdd,
	0xee, 0x86, 0x52, 0x92, 0xc6, 0x2d, 0x61, 0x18, 0x3a, 0xec, 0x24, 0x36, 0x6c, 0xd4, 0x19, 0x07,
	0x57, 0x4d, 0x87, 0x52, 0x66, 0xd0, 0x68, 0xa5, 0x6b, 0xfb, 0x4e, 0x63, 0x49, 0x95, 0xae, 0x9d,
	0xcd, 0x1b, 0xc3, 0x1b, 0x33, 0xc0, 0x1b, 0x6f, 0xfc, 0x0f, 0x7d, 0xe4, 0x8d, 0xe7, 0xbe, 0xc1,
	0x23, 0xcc, 0x30, 0x19, 0xea, 0xbf, 0x84, 0xd1, 0xd5, 0xbd, 0xb2, 0x24, 0xcb, 0x8e, 0x59, 0x78,
	0x00, 0x9e, 0x6c, 0x9d, 0xef, 0x73, 0xee, 0x39, 0xbf, 0xfb, 0x01, 0xbd, 0x01, 0xa1, 0xc3, 0xf1,
	0xcb, 0x23, 0xd3, 0x19, 0x1d, 0x77, 0x89, 0xe9, 0x39, 0xbe, 0xd3, 0xa7, 0xc7, 0x43, 0xd3, 0xf7,
	0x87, 0x64, 0x74, 0xec, 0x7e, 0x3e, 0x38, 0xb6, 0x4d, 0xd7, 0x73, 0x5e, 0xdd, 0x8a, 0xdf, 0x81,
	0xe7, 0x9a, 0xc7, 0x93, 0x93, 0x63, 0x1b, 0xd3, 0x1b, 0xc7, 0xfb, 0xdc, 0x74, 0xec, 0x3e, 0x19,
	0x30, 0xce, 0x91, 0xeb, 0x39, 0xd4, 0x41, 0x95, 0x98, 0xe0, 0xd1, 0xe4, 0x44, 0xf9, 0x9b, 0x04,
	0xe5, 0x33, 0xcb, 0xba, 0x54, 0xdb, 0x1a, 0xfe, 0x62, 0x8c, 0x7d, 0x8a, 0x5a, 0x50, 0x32, 0x1d,
	0x9b, 0x1a, 0xc4, 0xc6, 0x9e, 0x4e, 0xac, 0xba, 0x74, 0x20, 0x1d, 0x16, 0xce, 0xb7, 0xa6, 0x77,
	0xfb, 0xc5, 0xb6, 0xa0, 0xab, 0x1d, 0xad, 0x18, 0x09, 0xa9, 0x16, 0x3a, 0x80, 0x0d, 0x9b, 0x98,
	0x81, 0xf4, 0x1a, 0x93, 0x2e, 0x4c, 0xef, 0xf6, 0x1f, 0x5c, 0x12, 0x53, 0xed, 0x68, 0x0f, 0x6c,
	0x62, 0xaa, 0x16, 0x7a, 0x0c, 0x65, 0x6c, 0x5b, 0xae, 0x43, 0x6c, 0xaa, 0xdb, 0xc6, 0x08, 0xd7,
	0xf3, 0x81, 0xa0, 0x56, 0x12, 0xc4, 0x4b, 0x63, 0x84, 0x51, 0x17, 0x1e, 0x46, 0x42, 0x3e, 0xa6,
	0x94, 0xd8, 0x03, 0xbf, 0xbe, 0x7e, 0x20, 0x1d, 0x16, 0x5b, 0x07, 0x47, 0xc9, 0xc0, 0x8f, 0x7e,
	0xc4, 0x05, 0x3f, 0xe6, 0x72, 0x5a, 0x15, 0xa7, 0x28, 0x4a, 0x15, 0x2a, 0x22, 0x35, 0xdf, 0x75,
	0x6c, 0x1f, 0x2b, 0x7f, 0x97, 0xa0, 0xda, 0x75, 0x2c, 0xd2, 0xbf, 0xfd, 0xbf, 0x4c, 0xb8, 0x06,
	0x0f, 0x63, 0xd9, 0xf1, 0x9c, 0x7f, 0x2b, 0x41, 0xb5, 0x83, 0xaf, 0x31, 0xc5, 0xff, 0x15, 0x39,
	0x07, 0x41, 0xc6, 0xc2, 0xe1, 0x41, 0xaa, 0xb0, 0xdd, 0xf6, 0xb0, 0x41, 0xf1, 0x65, 0xd8, 0xb8,
	0x22, 0xce, 0x13, 0xd8, 0xe4, 0xad, 0xcc, 0x42, 0x2c, 0xb6, 0xf6, 0xd2, 0x65, 0x11, 0x0a, 0x42,
	0x4e, 0xf9, 0xa3, 0x04, 0x9b, 0x9c, 0x88, 0xba, 0x50, 0x1c, 0x9a, 0xb6, 0x9e, 0x34, 0xf1, 0x76,
	0xda, 0xc4, 0x85, 0xe3, 0xd3, 0xb6, 0x33, 0x72, 0xc7, 0x91, 0x7b, 0x51, 0xd1, 0x8b, 0x9c, 0x06,
	0x43, 0xd3, 0x16, 0xe6, 0x3e, 0x82, 0x2d, 0xae, 0x1a, 0x99, 0x5c, 0x63, 0x26, 0x9f, 0xce, 0x45,
	0xd5, 0xee, 0x05, 0x9f, 0xf3, 0xe6, 0xc4, 0xfc, 0x71, 0xce, 0x39, 0x80, 0x2c, 0x16, 0x5e, 0x79,
	0x07, 0x76, 0xb3, 0xf5, 0x10, 0x82, 0x75, 0x56, 0x4f, 0xb6, 0x4c, 0x1a, 0xfb, 0xaf, 0xfc, 0x6e,
	0x1d, 0x1a, 0x8b, 0x23, 0xcf, 0x52, 0x41, 0x1f, 0xc2, 0xfa, 0xc8, 0xb1, 0x30, 0x0b, 0xba, 0xd2,
	0x3a, 0x5d, 0xbd, 0x0e, 0xa2, 0xca, 0x5d, 0xc7, 0xc2, 0x1a, 0xb3, 0x81, 0xf6, 0xa1, 0xe8, 0xdf,
	0x10, 0x6a, 0x0e, 0xe3, 0x2b, 0x0d, 0x21, 0x89, 0xf5, 0x76, 0x0f, 0x0a, 0xc4, 0x35, 0x46, 0x3a,
	0xbd, 0x75, 0x31, 0xeb, 0xe9, 0x4a, 0xeb, 0xbd, 0x7f, 0xc1, 0xa3, 0xea, 0x1a, 0xa3, 0xab, 0x5b,
	0x17, 0x6b, 0x32, 0xe1, 0xff, 0xd0, 0x29, 0xec, 0xf9, 0xe3, 0x97, 0x36, 0xa6, 0x3a, 0x71, 0x0d,
	0xcb, 0xf2, 0xb0, 0xef, 0xeb, 0xae, 0x87, 0xfb, 0xe4, 0x55, 0xfd, 0xc1, 0x41, 0xfe, 0xb0, 0xa0,
	0xed, 0x84, 0x6c, 0x55, 0x70, 0x7b, 0x8c, 0x89, 0x9e, 0xc1, 0x96, 0x85, 0xfb, 0xc6, 0xf8, 0x9a,
	0xea, 0x03, 0x83, 0xe2, 0x1b, 0xe3, 0xb6, 0xbe, 0xc1, 0xc2, 0xad, 0x70, 0xf2, 0x8b, 0x90, 0x8a,
	0x9e, 0xc3, 0x1b, 0x0b, 0x1c, 0xe8, 0xc4, 0x9d, 0x9c, 0xd6, 0x37, 0x99, 0x97, 0x6f, 0x64, 0x7a,
	0x51, 0xdd, 0xc9, 0x29, 0x7a, 0x17, 0xb6, 0x53, 0x9e, 0x42, 0x45, 0x99, 0xb9, 0x43, 0x49, 0x77,
	0x81, 0x86, 0xf2, 0x0c, 0x8a, 0xb1, 0xda, 0xa2, 0x2d, 0x28, 0x5e, 0x79, 0x86, 0xed, 0xbb, 0x86,
	0x87, 0x6d, 0x5a, 0xcd, 0xa1, 0x4d, 0xc8, 0x5f, 0x9e, 0x5d, 0x55, 0x25, 0xe5, 0x00, 0x64, 0x51,
	0x12, 0x04, 0xb0, 0xf1, 0x31, 0x35, 0x28, 0x31, 0xab, 0x39, 0x24, 0xc3, 0x7a, 0xe7, 0xa2, 0xdd,
	0xab, 0x4a, 0xca, 0x31, 0xec, 0xa4, 0x66, 0x28, 0x1c, 0x2e, 0xb4, 0x0b, 0x6b, 0xd1, 0x88, 0x6f,
	0x4c, 0xef, 0xf6, 0xd7, 0xd4, 0x8e, 0xb6, 0x46, 0x2c, 0xe5, 0x03, 0x78, 0xb3, 0xe7, 0x78, 0x6c,
	0x2a, 0x05, 0xb8, 0xf4, 0x9c, 0x6b, 0x62, 0xde, 0xf2, 0x45, 0x40, 0xdf, 0x84, 0x82, 0xeb, 0x78,
	0x7c, 0x96, 0xc3, 0x46, 0x92, 0x5d, 0xae, 0xa1, 0x7c, 0x29, 0x41, 0x5d, 0x75, 0x26, 0xd9, 0x9a,
	0xef, 0x00, 0x22, 0xce, 0x44, 0x77, 0xfa, 0xfd, 0x6b, 0xc7, 0xb0, 0xf4, 0x1b, 0x4c, 0x06, 0x43,
	0xca, 0x4c, 0x94, 0xb5, 0x2a, 0x71, 0x26, 0x3f, 0x09, 0x19, 0x3f, 0x65, 0x74, 0xd4, 0x82, 0x9d,
	0x2f, 0xc6, 0x78, 0x8c, 0x75, 0xd7, 0x20, 0x9e, 0xaf, 0x7b, 0xe1, 0xf0, 0xe3, 0x10, 0x68, 0xca,
	0x5a, 0x8d, 0x31, 0x7b, 0x01, 0x4f, 0x13, 0x2c, 0x74, 0x02, 0xdb, 0xc4, 0xa6, 0xd8, 0xf3, 0xc6,
	0x2e, 0xd5, 0x83, 0x8e, 0xf4, 0x0c, 0x4a, 0x1c, 0x9b, 0x35, 0x62, 0x59, 0xab, 0x45, 0xbc, 0x6e,
	0xc4, 0x52, 0x2c, 0x80, 0x8e, 0xed, 0x8b, 0x10, 0x9f, 0xc2, 0x96, 0x8f, 0xbd, 0x49, 0x80, 0x7f,
	0xae, 0x1e, 0x2c, 0xa5, 0x5f, 0x97, 0xd8, 0xfa, 0x96, 0x43, 0xb2, 0xea, 0x9e, 0x05, 0x44, 0xb4,
	0x0b, 0x1b, 0x96, 0x33, 0x32, 0x88, 0x1d, 0xc2, 0x9e, 0xc6, 0xbf, 0x02, 0xba, 0x8f, 0x0d, 0xcf,
	0x1c, 0xd6, 0xf3, 0x4c, 0x8d, 0x7f, 0x29, 0x7d, 0xb1, 0x0c, 0xa2, 0x32, 0x02, 0xcb, 0x32, 0xc1,
	0x5e, 0x7a, 0x6d, 0xb0, 0xff, 0x93, 0x04, 0xd5, 0xb4, 0x18, 0xba, 0x80, 0x52, 0x00, 0x78, 0x42,
	0x98, 0x9b, 0x7f, 0x3c, 0x37, 0x77, 0xa6, 0x9d, 0x56, 0xbd, 0xc8, 0x69, 0x01, 0x56, 0x0a, 0x32,
	0xba, 0x82, 0xaa, 0xc0, 0xba, 0xc8, 0x5a, 0x08, 0x76, 0xcf, 0x16, 0x80, 0x5d, 0x86, 0x45, 0x01,
	0x97, 0x82, 0x95, 0x80, 0xbb, 0xdf, 0x48, 0x50, 0x8b, 0x05, 0x12, 0xb5, 0xeb, 0x1b, 0x50, 0x08,
	0x1a, 0xce, 0x77, 0x0d, 0x53, 0x74, 0xdd, 0x8c, 0xc0, 0x9b, 0x79, 0x2d, 0xdd, 0xcc, 0xe8, 0xf9,
	0xcc, 0x32, 0xeb, 0x81, 0xd5, 0xb2, 0xd6, 0x66, 0xe1, 0xfc, 0x21, 0x9f, 0x08, 0x67, 0x29, 0x90,
	0x36, 0x01, 0x46, 0x86, 0xc9, 0xe7, 0x9f, 0xf7, 0x45, 0x8c, 0x12, 0xa4, 0x10, 0x21, 0x08, 0x87,
	0xc6, 0x19, 0x01, 0x7d, 0x17, 0x76, 0xd3, 0xf8, 0x72, 0x8d, 0xed, 0x01, 0x1d, 0x32, 0x98, 0x2c,
	0x6b, 0x3b, 0x24, 0x09, 0x2d, 0x21, 0x13, 0x3d, 0x82, 0x12, 0xdf, 0x75, 0xc2, 0x81, 0x7c, 0xc0,
	0xec, 0x16, 0x39, 0x8d, 0x61, 0xee, 0x73, 0x90, 0xdd, 0x60, 0x0e, 0x09, 0xf6, 0x19, 0xc4, 0x2d,
	0x2f, 0x42, 0x8f, 0x8b, 0x6a, 0x91, 0x12, 0xfa, 0x01, 0x14, 0x2d, 0xdb, 0x17, 0xed, 0x59, 0xdf,
	0x64, 0x36, 0x1a, 0x69, 0x1b, 0xb3, 0x29, 0xd2, 0xc0, 0x9a, 0x4d, 0xd4, 0x01, 0x14, 0x03, 0xb4,
	0x13, 0x79, 0x87, 0xa0, 0x17, 0x27, 0xa1, 0xef, 0x43, 0x3d, 0xf6, 0x99, 0xcc, 0xbd, 0xc0, 0x72,
	0xdf, 0x8b, 0xf1, 0xe3, 0xd9, 0x07, 0x47, 0xb7, 0x5a, 0x46, 0xec, 0x08, 0xc3, 0x5e, 0x00, 0x49,
	0x41, 0x45, 0x74, 0x96, 0xc6, 0x6d, 0x14, 0x7d, 0xd8, 0xfc, 0xdf, 0x49, 0x47, 0xbf, 0x14, 0xf3,
	0xb4, 0x1d, 0x61, 0x2d, 0x09, 0x68, 0x9f, 0x42, 0x2d, 0x00, 0xb4, 0xa4, 0x07, 0x9f, 0x4f, 0xc4,
	0x61, 0xda, 0xc5, 0x22, 0x5c, 0xd4, 0x1e, 0x12, 0x67, 0x92, 0xa0, 0xf8, 0x1f, 0xae, 0xcb, 0xf9,
	0xaa, 0xac, 0x7c, 0x99, 0x87, 0xbd, 0x05, 0x73, 0xf4, 0x3f, 0xd5, 0x81, 0x2b, 0xef, 0xb5, 0x3d,
	0x40, 0xae, 0x49, 0x74, 0x0b, 0x4f, 0x88, 0x89, 0x75, 0x0b, 0x53, 0x83, 0x5c, 0xfb, 0xbc, 0xe1,
	0xe6, 0xe0, 0xb0, 0xd7, 0x56, 0x3b, 0x4c, 0xb0, 0x13, 0xca, 0x5d, 0xe4, 0xb4, 0xaa, 0x6b, 0x92,
	0x04, 0xed, 0x3f, 0xd0, 0x7e, 0x85, 0x85, 0xed, 0x77, 0x5e, 0x85, 0x4a, 0x32, 0x54, 0xc5, 0x87,
	0x6a, 0x3a, 0x2c, 0xf4, 0x2d, 0x28, 0x70, 0xa9, 0x68, 0xc3, 0x2d, 0x4d, 0xef, 0xf6, 0xe5, 0x50,
	0x4a, 0xed, 0x68, 0x72, 0xc8, 0x56, 0x2d, 0xf4, 0x3e, 0xec, 0x4e, 0x88, 0x47, 0xc7, 0xc6, 0xb5,
	0xde, 0x1f, 0xdb, 0x66, 0xb0, 0x41, 0xe9, 0xc4, 0xb6, 0xf0, 0x2b, 0xbe, 0xe9, 0x6d, 0x73, 0xee,
	0x8f, 0x39, 0x53, 0x0d, 0x78, 0xca, 0xbb, 0xb0, 0x9b, 0xde, 0x5c, 0xee, 0xd9, 0xe4, 0x7f, 0x25,
	0x01, 0x3a, 0xb3, 0xac, 0xf4, 0x66, 0x94, 0xd5, 0x53, 0x2d, 0x28, 0x45, 0x38, 0x3b, 0x3b, 0xe6,
	0xb3, 0x4b, 0xc1, 0xa5, 0xa0, 0x07, 0x97, 0x82, 0x48, 0x48, 0xb5, 0xd0, 0x13, 0xa8, 0x18, 0x94,
	0x1a, 0xe6, 0x50, 0xa7, 0x8e, 0x3e, 0x74, 0x7c, 0xca, 0x9a, 0x4d, 0xd6, 0x4a, 0x21, 0xf5, 0xca,
	0x09, 0x8e, 0x78, 0xca, 0x0e, 0xd4, 0x12, 0x31, 0xf0, 0x53, 0xff, 0xb7, 0x61, 0x27, 0xbc, 0x0a,
	0xac, 0x10, 0x9d, 0x52, 0x87, 0xdd, 0xb4, 0x30, 0x37, 0xf3, 0x36, 0x6c, 0xf3, 0x1b, 0x45, 0xf2,
	0xf2, 0x90, 0x65, 0x65, 0x4f, 0xb8, 0x4c, 0x1d, 0x92, 0x94, 0x43, 0x40, 0x2f, 0x30, 0x5d, 0x25,
	0x90, 0x5f, 0x4b, 0x50, 0x4b, 0x88, 0xfe, 0x5b, 0xfb, 0xd6, 0x07, 0x20, 0x47, 0xfb, 0x6b, 0x7e,
	0xc5, 0xc3, 0x40, 0xa4, 0xa1, 0x3c, 0x83, 0x87, 0x2f, 0x30, 0x5d, 0x21, 0xef, 0xdf, 0x4b, 0x2c,
	0xbf, 0x15, 0x8f, 0x86, 0xf1, 0x7b, 0xd7, 0xda, 0x6a, 0xf7, 0x2e, 0xf4, 0x3e, 0xc8, 0x23, 0xc3,
	0xd4, 0x0c, 0x7b, 0x80, 0x79, 0x22, 0xf5, 0xb4, 0x4e, 0x97, 0xf3, 0xb5, 0x48, 0x52, 0xf9, 0x0c,
	0x64, 0x41, 0x45, 0x87, 0xb0, 0xe5, 0x53, 0xc3, 0xa3, 0x5d, 0xc3, 0x3c, 0xe3, 0x43, 0x1c, 0xa6,
	0x90, 0x26, 0xa3, 0x27, 0xec, 0xa2, 0x19, 0x93, 0x0b, 0x01, 0x30, 0x49, 0x0c, 0xba, 0x2e, 0xb6,
	0x4e, 0xe2, 0xec, 0xa8, 0xfc, 0x0c, 0xb6, 0x93, 0x64, 0x5e, 0x8b, 0x33, 0x28, 0x88, 0xba, 0x86,
	0x47, 0xc1, 0x8c, 0xdd, 0x33, 0x63, 0xdd, 0xb5, 0x99, 0x96, 0xb2, 0x1d, 0x2f, 0x72, 0xe4, 0xf0,
	0x13, 0x16, 0xc7, 0x8c, 0xca, 0xfd, 0xfd, 0x10, 0x64, 0x5e, 0x3b, 0xe1, 0x4e, 0xc9, 0x70, 0x97,
	0x5a, 0x31, 0x2d, 0xd2, 0x69, 0xfd, 0x59, 0x06, 0xc4, 0xb9, 0x6d, 0xf6, 0xce, 0xc3, 0x76, 0x0f,
	0xa4, 0xc2, 0x46, 0xf8, 0xea, 0x81, 0xde, 0x4c, 0x9b, 0x4b, 0x3c, 0xf4, 0x34, 0x9a, 0x8b, 0xd8,
	0x7c, 0x22, 0x72, 0x48, 0x83, 0x42, 0xf4, 0x9e, 0x80, 0xe6, 0xda, 0x32, 0xfd, 0x90, 0xd2, 0x78,
	0xb4, 0x44, 0x22, 0x6e, 0x33, 0xba, 0xfe, 0xcf, 0xdb, 0x4c, 0x3f, 0x54, 0xcc, 0xdb, 0x9c, 0x7f,
	0x3b, 0xc8, 0xa1, 0x5f, 0x40, 0x39, 0x71, 0xf3, 0x41, 0x4f, 0xd2, 0x5a, 0x59, 0x8f, 0x0b, 0x8d,
	0xb7, 0xee, 0x91, 0x8a, 0xec, 0x1b, 0x50, 0x49, 0xa2, 0x2e, 0x5a, 0xa0, 0x9a, 0x82, 0x8f, 0xc6,
	0xd3, 0xfb, 0xc4, 0x22, 0x17, 0x9f, 0x42, 0x31, 0x86, 0x90, 0x48, 0xc9, 0x58, 0x9b, 0xb4, 0xf1,
	0xc7, 0x4b, 0x65, 0xe2, 0xc1, 0x27, 0x71, 0x73, 0x3e, 0xf8, 0x4c, 0x10, 0x9e, 0x0f, 0x7e, 0x01,
	0xfc, 0xb2, 0xfa, 0x27, 0x40, 0x75, 0xbe, 0xfe, 0x59, 0xf8, 0xdc, 0x78, 0xeb, 0x1e, 0xa9, 0x78,
	0x71, 0x62, 0x83, 0x87, 0x94, 0xa5, 0x53, 0xb9, 0xa0, 0x38, 0x19, 0x93, 0xab, 0xe4, 0xd0, 0x27,
	0x00, 0xb3, 0x19, 0x43, 0x8f, 0x96, 0xcd, 0x5f, 0x68, 0x77, 0x85, 0x11, 0x55, 0x72, 0xe8, 0xe7,
	0x50, 0x8a, 0x43, 0x0c, 0x5a, 0x16, 0x8d, 0x80, 0x89, 0xc6, 0x93, 0xe5, 0x42, 0xa9, 0x6a, 0x08,
	0x38, 0x41, 0x4b, 0x22, 0xf2, 0x97, 0x55, 0x23, 0x8d, 0x47, 0x4a, 0xee, 0xfc, 0xa3, 0xaf, 0xbe,
	0x6e, 0xe6, 0xfe, 0xfa, 0x75, 0x33, 0xf7, 0xcb, 0x69, 0x53, 0xfa, 0x6a, 0xda, 0x94, 0xfe, 0x32,
	0x6d, 0x4a, 0xff, 0x98, 0x36, 0xa5, 0xcf, 0xbe, 0xf7, 0x9a, 0x0f, 0xd1, 0x2f, 0x37, 0xd8, 0xb3,
	0xf3, 0x7b, 0xff, 0x0c, 0x00, 0x00, 0xff, 0xff, 0x72, 0xc7, 0x5f, 0xa9, 0xca, 0x16, 0x00, 0x00,
}

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4

// NetworkConfigProxyClient is the client API for NetworkConfigProxy service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type NetworkConfigProxyClient interface {
	AddNIC(ctx context.Context, in *AddNICRequest, opts ...grpc.CallOption) (*AddNICResponse, error)
	ModifyNIC(ctx context.Context, in *ModifyNICRequest, opts ...grpc.CallOption) (*ModifyNICResponse, error)
	DeleteNIC(ctx context.Context, in *DeleteNICRequest, opts ...grpc.CallOption) (*DeleteNICResponse, error)
	CreateNetwork(ctx context.Context, in *CreateNetworkRequest, opts ...grpc.CallOption) (*CreateNetworkResponse, error)
	CreateEndpoint(ctx context.Context, in *CreateEndpointRequest, opts ...grpc.CallOption) (*CreateEndpointResponse, error)
	AddEndpoint(ctx context.Context, in *AddEndpointRequest, opts ...grpc.CallOption) (*AddEndpointResponse, error)
	DeleteEndpoint(ctx context.Context, in *DeleteEndpointRequest, opts ...grpc.CallOption) (*DeleteEndpointResponse, error)
	DeleteNetwork(ctx context.Context, in *DeleteNetworkRequest, opts ...grpc.CallOption) (*DeleteNetworkResponse, error)
	GetEndpoint(ctx context.Context, in *GetEndpointRequest, opts ...grpc.CallOption) (*GetEndpointResponse, error)
	GetNetwork(ctx context.Context, in *GetNetworkRequest, opts ...grpc.CallOption) (*GetNetworkResponse, error)
	GetEndpoints(ctx context.Context, in *GetEndpointsRequest, opts ...grpc.CallOption) (*GetEndpointsResponse, error)
	GetNetworks(ctx context.Context, in *GetNetworksRequest, opts ...grpc.CallOption) (*GetNetworksResponse, error)
}

type networkConfigProxyClient struct {
	cc *grpc.ClientConn
}

func NewNetworkConfigProxyClient(cc *grpc.ClientConn) NetworkConfigProxyClient {
	return &networkConfigProxyClient{cc}
}

func (c *networkConfigProxyClient) AddNIC(ctx context.Context, in *AddNICRequest, opts ...grpc.CallOption) (*AddNICResponse, error) {
	out := new(AddNICResponse)
	err := c.cc.Invoke(ctx, "/ncproxygrpc.v1.NetworkConfigProxy/AddNIC", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *networkConfigProxyClient) ModifyNIC(ctx context.Context, in *ModifyNICRequest, opts ...grpc.CallOption) (*ModifyNICResponse, error) {
	out := new(ModifyNICResponse)
	err := c.cc.Invoke(ctx, "/ncproxygrpc.v1.NetworkConfigProxy/ModifyNIC", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *networkConfigProxyClient) DeleteNIC(ctx context.Context, in *DeleteNICRequest, opts ...grpc.CallOption) (*DeleteNICResponse, error) {
	out := new(DeleteNICResponse)
	err := c.cc.Invoke(ctx, "/ncproxygrpc.v1.NetworkConfigProxy/DeleteNIC", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *networkConfigProxyClient) CreateNetwork(ctx context.Context, in *CreateNetworkRequest, opts ...grpc.CallOption) (*CreateNetworkResponse, error) {
	out := new(CreateNetworkResponse)
	err := c.cc.Invoke(ctx, "/ncproxygrpc.v1.NetworkConfigProxy/CreateNetwork", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *networkConfigProxyClient) CreateEndpoint(ctx context.Context, in *CreateEndpointRequest, opts ...grpc.CallOption) (*CreateEndpointResponse, error) {
	out := new(CreateEndpointResponse)
	err := c.cc.Invoke(ctx, "/ncproxygrpc.v1.NetworkConfigProxy/CreateEndpoint", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *networkConfigProxyClient) AddEndpoint(ctx context.Context, in *AddEndpointRequest, opts ...grpc.CallOption) (*AddEndpointResponse, error) {
	out := new(AddEndpointResponse)
	err := c.cc.Invoke(ctx, "/ncproxygrpc.v1.NetworkConfigProxy/AddEndpoint", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *networkConfigProxyClient) DeleteEndpoint(ctx context.Context, in *DeleteEndpointRequest, opts ...grpc.CallOption) (*DeleteEndpointResponse, error) {
	out := new(DeleteEndpointResponse)
	err := c.cc.Invoke(ctx, "/ncproxygrpc.v1.NetworkConfigProxy/DeleteEndpoint", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *networkConfigProxyClient) DeleteNetwork(ctx context.Context, in *DeleteNetworkRequest, opts ...grpc.CallOption) (*DeleteNetworkResponse, error) {
	out := new(DeleteNetworkResponse)
	err := c.cc.Invoke(ctx, "/ncproxygrpc.v1.NetworkConfigProxy/DeleteNetwork", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *networkConfigProxyClient) GetEndpoint(ctx context.Context, in *GetEndpointRequest, opts ...grpc.CallOption) (*GetEndpointResponse, error) {
	out := new(GetEndpointResponse)
	err := c.cc.Invoke(ctx, "/ncproxygrpc.v1.NetworkConfigProxy/GetEndpoint", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *networkConfigProxyClient) GetNetwork(ctx context.Context, in *GetNetworkRequest, opts ...grpc.CallOption) (*GetNetworkResponse, error) {
	out := new(GetNetworkResponse)
	err := c.cc.Invoke(ctx, "/ncproxygrpc.v1.NetworkConfigProxy/GetNetwork", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *networkConfigProxyClient) GetEndpoints(ctx context.Context, in *GetEndpointsRequest, opts ...grpc.CallOption) (*GetEndpointsResponse, error) {
	out := new(GetEndpointsResponse)
	err := c.cc.Invoke(ctx, "/ncproxygrpc.v1.NetworkConfigProxy/GetEndpoints", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *networkConfigProxyClient) GetNetworks(ctx context.Context, in *GetNetworksRequest, opts ...grpc.CallOption) (*GetNetworksResponse, error) {
	out := new(GetNetworksResponse)
	err := c.cc.Invoke(ctx, "/ncproxygrpc.v1.NetworkConfigProxy/GetNetworks", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// NetworkConfigProxyServer is the server API for NetworkConfigProxy service.
type NetworkConfigProxyServer interface {
	AddNIC(context.Context, *AddNICRequest) (*AddNICResponse, error)
	ModifyNIC(context.Context, *ModifyNICRequest) (*ModifyNICResponse, error)
	DeleteNIC(context.Context, *DeleteNICRequest) (*DeleteNICResponse, error)
	CreateNetwork(context.Context, *CreateNetworkRequest) (*CreateNetworkResponse, error)
	CreateEndpoint(context.Context, *CreateEndpointRequest) (*CreateEndpointResponse, error)
	AddEndpoint(context.Context, *AddEndpointRequest) (*AddEndpointResponse, error)
	DeleteEndpoint(context.Context, *DeleteEndpointRequest) (*DeleteEndpointResponse, error)
	DeleteNetwork(context.Context, *DeleteNetworkRequest) (*DeleteNetworkResponse, error)
	GetEndpoint(context.Context, *GetEndpointRequest) (*GetEndpointResponse, error)
	GetNetwork(context.Context, *GetNetworkRequest) (*GetNetworkResponse, error)
	GetEndpoints(context.Context, *GetEndpointsRequest) (*GetEndpointsResponse, error)
	GetNetworks(context.Context, *GetNetworksRequest) (*GetNetworksResponse, error)
}

// UnimplementedNetworkConfigProxyServer can be embedded to have forward compatible implementations.
type UnimplementedNetworkConfigProxyServer struct {
}

func (*UnimplementedNetworkConfigProxyServer) AddNIC(ctx context.Context, req *AddNICRequest) (*AddNICResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AddNIC not implemented")
}
func (*UnimplementedNetworkConfigProxyServer) ModifyNIC(ctx context.Context, req *ModifyNICRequest) (*ModifyNICResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ModifyNIC not implemented")
}
func (*UnimplementedNetworkConfigProxyServer) DeleteNIC(ctx context.Context, req *DeleteNICRequest) (*DeleteNICResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteNIC not implemented")
}
func (*UnimplementedNetworkConfigProxyServer) CreateNetwork(ctx context.Context, req *CreateNetworkRequest) (*CreateNetworkResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateNetwork not implemented")
}
func (*UnimplementedNetworkConfigProxyServer) CreateEndpoint(ctx context.Context, req *CreateEndpointRequest) (*CreateEndpointResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateEndpoint not implemented")
}
func (*UnimplementedNetworkConfigProxyServer) AddEndpoint(ctx context.Context, req *AddEndpointRequest) (*AddEndpointResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AddEndpoint not implemented")
}
func (*UnimplementedNetworkConfigProxyServer) DeleteEndpoint(ctx context.Context, req *DeleteEndpointRequest) (*DeleteEndpointResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteEndpoint not implemented")
}
func (*UnimplementedNetworkConfigProxyServer) DeleteNetwork(ctx context.Context, req *DeleteNetworkRequest) (*DeleteNetworkResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteNetwork not implemented")
}
func (*UnimplementedNetworkConfigProxyServer) GetEndpoint(ctx context.Context, req *GetEndpointRequest) (*GetEndpointResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetEndpoint not implemented")
}
func (*UnimplementedNetworkConfigProxyServer) GetNetwork(ctx context.Context, req *GetNetworkRequest) (*GetNetworkResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetNetwork not implemented")
}
func (*UnimplementedNetworkConfigProxyServer) GetEndpoints(ctx context.Context, req *GetEndpointsRequest) (*GetEndpointsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetEndpoints not implemented")
}
func (*UnimplementedNetworkConfigProxyServer) GetNetworks(ctx context.Context, req *GetNetworksRequest) (*GetNetworksResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetNetworks not implemented")
}

func RegisterNetworkConfigProxyServer(s *grpc.Server, srv NetworkConfigProxyServer) {
	s.RegisterService(&_NetworkConfigProxy_serviceDesc, srv)
}

func _NetworkConfigProxy_AddNIC_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AddNICRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NetworkConfigProxyServer).AddNIC(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/ncproxygrpc.v1.NetworkConfigProxy/AddNIC",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NetworkConfigProxyServer).AddNIC(ctx, req.(*AddNICRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _NetworkConfigProxy_ModifyNIC_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ModifyNICRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NetworkConfigProxyServer).ModifyNIC(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/ncproxygrpc.v1.NetworkConfigProxy/ModifyNIC",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NetworkConfigProxyServer).ModifyNIC(ctx, req.(*ModifyNICRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _NetworkConfigProxy_DeleteNIC_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteNICRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NetworkConfigProxyServer).DeleteNIC(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/ncproxygrpc.v1.NetworkConfigProxy/DeleteNIC",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NetworkConfigProxyServer).DeleteNIC(ctx, req.(*DeleteNICRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _NetworkConfigProxy_CreateNetwork_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateNetworkRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NetworkConfigProxyServer).CreateNetwork(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/ncproxygrpc.v1.NetworkConfigProxy/CreateNetwork",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NetworkConfigProxyServer).CreateNetwork(ctx, req.(*CreateNetworkRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _NetworkConfigProxy_CreateEndpoint_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateEndpointRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NetworkConfigProxyServer).CreateEndpoint(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/ncproxygrpc.v1.NetworkConfigProxy/CreateEndpoint",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NetworkConfigProxyServer).CreateEndpoint(ctx, req.(*CreateEndpointRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _NetworkConfigProxy_AddEndpoint_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AddEndpointRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NetworkConfigProxyServer).AddEndpoint(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/ncproxygrpc.v1.NetworkConfigProxy/AddEndpoint",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NetworkConfigProxyServer).AddEndpoint(ctx, req.(*AddEndpointRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _NetworkConfigProxy_DeleteEndpoint_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteEndpointRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NetworkConfigProxyServer).DeleteEndpoint(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/ncproxygrpc.v1.NetworkConfigProxy/DeleteEndpoint",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NetworkConfigProxyServer).DeleteEndpoint(ctx, req.(*DeleteEndpointRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _NetworkConfigProxy_DeleteNetwork_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteNetworkRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NetworkConfigProxyServer).DeleteNetwork(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/ncproxygrpc.v1.NetworkConfigProxy/DeleteNetwork",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NetworkConfigProxyServer).DeleteNetwork(ctx, req.(*DeleteNetworkRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _NetworkConfigProxy_GetEndpoint_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetEndpointRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NetworkConfigProxyServer).GetEndpoint(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/ncproxygrpc.v1.NetworkConfigProxy/GetEndpoint",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NetworkConfigProxyServer).GetEndpoint(ctx, req.(*GetEndpointRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _NetworkConfigProxy_GetNetwork_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetNetworkRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NetworkConfigProxyServer).GetNetwork(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/ncproxygrpc.v1.NetworkConfigProxy/GetNetwork",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NetworkConfigProxyServer).GetNetwork(ctx, req.(*GetNetworkRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _NetworkConfigProxy_GetEndpoints_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetEndpointsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NetworkConfigProxyServer).GetEndpoints(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/ncproxygrpc.v1.NetworkConfigProxy/GetEndpoints",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NetworkConfigProxyServer).GetEndpoints(ctx, req.(*GetEndpointsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _NetworkConfigProxy_GetNetworks_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetNetworksRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NetworkConfigProxyServer).GetNetworks(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/ncproxygrpc.v1.NetworkConfigProxy/GetNetworks",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NetworkConfigProxyServer).GetNetworks(ctx, req.(*GetNetworksRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _NetworkConfigProxy_serviceDesc = grpc.ServiceDesc{
	ServiceName: "ncproxygrpc.v1.NetworkConfigProxy",
	HandlerType: (*NetworkConfigProxyServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "AddNIC",
			Handler:    _NetworkConfigProxy_AddNIC_Handler,
		},
		{
			MethodName: "ModifyNIC",
			Handler:    _NetworkConfigProxy_ModifyNIC_Handler,
		},
		{
			MethodName: "DeleteNIC",
			Handler:    _NetworkConfigProxy_DeleteNIC_Handler,
		},
		{
			MethodName: "CreateNetwork",
			Handler:    _NetworkConfigProxy_CreateNetwork_Handler,
		},
		{
			MethodName: "CreateEndpoint",
			Handler:    _NetworkConfigProxy_CreateEndpoint_Handler,
		},
		{
			MethodName: "AddEndpoint",
			Handler:    _NetworkConfigProxy_AddEndpoint_Handler,
		},
		{
			MethodName: "DeleteEndpoint",
			Handler:    _NetworkConfigProxy_DeleteEndpoint_Handler,
		},
		{
			MethodName: "DeleteNetwork",
			Handler:    _NetworkConfigProxy_DeleteNetwork_Handler,
		},
		{
			MethodName: "GetEndpoint",
			Handler:    _NetworkConfigProxy_GetEndpoint_Handler,
		},
		{
			MethodName: "GetNetwork",
			Handler:    _NetworkConfigProxy_GetNetwork_Handler,
		},
		{
			MethodName: "GetEndpoints",
			Handler:    _NetworkConfigProxy_GetEndpoints_Handler,
		},
		{
			MethodName: "GetNetworks",
			Handler:    _NetworkConfigProxy_GetNetworks_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "github.com/Microsoft/hcsshim/pkg/ncproxy/ncproxygrpc/v1/networkconfigproxy.proto",
}

func (m *AddNICRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *AddNICRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AddNICRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.EndpointSettings != nil {
		{
			size, err := m.EndpointSettings.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if len(m.EndpointName) > 0 {
		i -= len(m.EndpointName)
		copy(dAtA[i:], m.EndpointName)
		i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.EndpointName)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.NicID) > 0 {
		i -= len(m.NicID)
		copy(dAtA[i:], m.NicID)
		i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.NicID)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ContainerID) > 0 {
		i -= len(m.ContainerID)
		copy(dAtA[i:], m.ContainerID)
		i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.ContainerID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *AddNICResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *AddNICResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AddNICResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	return len(dAtA) - i, nil
}

func (m *ModifyNICRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ModifyNICRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ModifyNICRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.EndpointSettings != nil {
		{
			size, err := m.EndpointSettings.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if len(m.EndpointName) > 0 {
		i -= len(m.EndpointName)
		copy(dAtA[i:], m.EndpointName)
		i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.EndpointName)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.NicID) > 0 {
		i -= len(m.NicID)
		copy(dAtA[i:], m.NicID)
		i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.NicID)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ContainerID) > 0 {
		i -= len(m.ContainerID)
		copy(dAtA[i:], m.ContainerID)
		i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.ContainerID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *ModifyNICResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ModifyNICResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ModifyNICResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	return len(dAtA) - i, nil
}

func (m *DeleteNICRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *DeleteNICRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DeleteNICRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.EndpointName) > 0 {
		i -= len(m.EndpointName)
		copy(dAtA[i:], m.EndpointName)
		i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.EndpointName)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.NicID) > 0 {
		i -= len(m.NicID)
		copy(dAtA[i:], m.NicID)
		i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.NicID)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ContainerID) > 0 {
		i -= len(m.ContainerID)
		copy(dAtA[i:], m.ContainerID)
		i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.ContainerID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *DeleteNICResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *DeleteNICResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DeleteNICResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	return len(dAtA) - i, nil
}

func (m *CreateNetworkRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *CreateNetworkRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CreateNetworkRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Network != nil {
		{
			size, err := m.Network.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *Network) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Network) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Network) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Settings != nil {
		{
			size := m.Settings.Size()
			i -= size
			if _, err := m.Settings.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	return len(dAtA) - i, nil
}

func (m *Network_HcnNetwork) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Network_HcnNetwork) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.HcnNetwork != nil {
		{
			size, err := m.HcnNetwork.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}
func (m *Network_NcproxyNetwork) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Network_NcproxyNetwork) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.NcproxyNetwork != nil {
		{
			size, err := m.NcproxyNetwork.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	return len(dAtA) - i, nil
}
func (m *NCProxyNetworkSettings) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *NCProxyNetworkSettings) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *NCProxyNetworkSettings) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *HostComputeNetworkSettings) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *HostComputeNetworkSettings) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *HostComputeNetworkSettings) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.DefaultGatewayIpv6) > 0 {
		i -= len(m.DefaultGatewayIpv6)
		copy(dAtA[i:], m.DefaultGatewayIpv6)
		i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.DefaultGatewayIpv6)))
		i--
		dAtA[i] = 0x42
	}
	if len(m.SubnetIpaddressPrefixIpv6) > 0 {
		for iNdEx := len(m.SubnetIpaddressPrefixIpv6) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.SubnetIpaddressPrefixIpv6[iNdEx])
			copy(dAtA[i:], m.SubnetIpaddressPrefixIpv6[iNdEx])
			i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.SubnetIpaddressPrefixIpv6[iNdEx])))
			i--
			dAtA[i] = 0x3a
		}
	}
	if len(m.DefaultGateway) > 0 {
		i -= len(m.DefaultGateway)
		copy(dAtA[i:], m.DefaultGateway)
		i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.DefaultGateway)))
		i--
		dAtA[i] = 0x32
	}
	if len(m.SubnetIpaddressPrefix) > 0 {
		for iNdEx := len(m.SubnetIpaddressPrefix) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.SubnetIpaddressPrefix[iNdEx])
			copy(dAtA[i:], m.SubnetIpaddressPrefix[iNdEx])
			i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.SubnetIpaddressPrefix[iNdEx])))
			i--
			dAtA[i] = 0x2a
		}
	}
	if m.IpamType != 0 {
		i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(m.IpamType))
		i--
		dAtA[i] = 0x20
	}
	if len(m.SwitchName) > 0 {
		i -= len(m.SwitchName)
		copy(dAtA[i:], m.SwitchName)
		i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.SwitchName)))
		i--
		dAtA[i] = 0x1a
	}
	if m.Mode != 0 {
		i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(m.Mode))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *CreateNetworkResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *CreateNetworkResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CreateNetworkResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.ID) > 0 {
		i -= len(m.ID)
		copy(dAtA[i:], m.ID)
		i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.ID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *PortNameEndpointPolicySetting) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *PortNameEndpointPolicySetting) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *PortNameEndpointPolicySetting) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.PortName) > 0 {
		i -= len(m.PortName)
		copy(dAtA[i:], m.PortName)
		i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.PortName)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *IovEndpointPolicySetting) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *IovEndpointPolicySetting) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *IovEndpointPolicySetting) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.InterruptModeration != 0 {
		i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(m.InterruptModeration))
		i--
		dAtA[i] = 0x18
	}
	if m.QueuePairsRequested != 0 {
		i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(m.QueuePairsRequested))
		i--
		dAtA[i] = 0x10
	}
	if m.IovOffloadWeight != 0 {
		i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(m.IovOffloadWeight))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *DnsSetting) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *DnsSetting) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DnsSetting) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Search) > 0 {
		for iNdEx := len(m.Search) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Search[iNdEx])
			copy(dAtA[i:], m.Search[iNdEx])
			i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.Search[iNdEx])))
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.Domain) > 0 {
		i -= len(m.Domain)
		copy(dAtA[i:], m.Domain)
		i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.Domain)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ServerIpAddrs) > 0 {
		for iNdEx := len(m.ServerIpAddrs) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.ServerIpAddrs[iNdEx])
			copy(dAtA[i:], m.ServerIpAddrs[iNdEx])
			i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.ServerIpAddrs[iNdEx])))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *CreateEndpointRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *CreateEndpointRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CreateEndpointRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.EndpointSettings != nil {
		{
			size, err := m.EndpointSettings.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EndpointSettings) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *EndpointSettings) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EndpointSettings) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Settings != nil {
		{
			size := m.Settings.Size()
			i -= size
			if _, err := m.Settings.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	return len(dAtA) - i, nil
}

func (m *EndpointSettings_HcnEndpoint) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EndpointSettings_HcnEndpoint) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.HcnEndpoint != nil {
		{
			size, err := m.HcnEndpoint.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}
func (m *EndpointSettings_NcproxyEndpoint) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EndpointSettings_NcproxyEndpoint) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.NcproxyEndpoint != nil {
		{
			size, err := m.NcproxyEndpoint.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	return len(dAtA) - i, nil
}
func (m *HcnEndpointResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *HcnEndpointResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *HcnEndpointResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Settings != nil {
		{
			size, err := m.Settings.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if len(m.ID) > 0 {
		i -= len(m.ID)
		copy(dAtA[i:], m.ID)
		i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.ID)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Namespace) > 0 {
		i -= len(m.Namespace)
		copy(dAtA[i:], m.Namespace)
		i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.Namespace)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *HcnEndpointSettings) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *HcnEndpointSettings) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *HcnEndpointSettings) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Ipv6AddressPrefixlength != 0 {
		i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(m.Ipv6AddressPrefixlength))
		i--
		dAtA[i] = 0x48
	}
	if len(m.Ipv6Address) > 0 {
		i -= len(m.Ipv6Address)
		copy(dAtA[i:], m.Ipv6Address)
		i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.Ipv6Address)))
		i--
		dAtA[i] = 0x42
	}
	if m.DnsSetting != nil {
		{
			size, err := m.DnsSetting.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x3a
	}
	if m.Policies != nil {
		{
			size, err := m.Policies.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	if len(m.NetworkName) > 0 {
		i -= len(m.NetworkName)
		copy(dAtA[i:], m.NetworkName)
		i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.NetworkName)))
		i--
		dAtA[i] = 0x2a
	}
	if m.IpaddressPrefixlength != 0 {
		i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(m.IpaddressPrefixlength))
		i--
		dAtA[i] = 0x20
	}
	if len(m.Ipaddress) > 0 {
		i -= len(m.Ipaddress)
		copy(dAtA[i:], m.Ipaddress)
		i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.Ipaddress)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Macaddress) > 0 {
		i -= len(m.Macaddress)
		copy(dAtA[i:], m.Macaddress)
		i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.Macaddress)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *HcnEndpointPolicies) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *HcnEndpointPolicies) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *HcnEndpointPolicies) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.IovPolicySettings != nil {
		{
			size, err := m.IovPolicySettings.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.PortnamePolicySetting != nil {
		{
			size, err := m.PortnamePolicySetting.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *NCProxyEndpointSettings) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *NCProxyEndpointSettings) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *NCProxyEndpointSettings) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Ipv6AddressPrefixlength) > 0 {
		i -= len(m.Ipv6AddressPrefixlength)
		copy(dAtA[i:], m.Ipv6AddressPrefixlength)
		i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.Ipv6AddressPrefixlength)))
		i--
		dAtA[i] = 0x4a
	}
	if len(m.Ipv6Address) > 0 {
		i -= len(m.Ipv6Address)
		copy(dAtA[i:], m.Ipv6Address)
		i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.Ipv6Address)))
		i--
		dAtA[i] = 0x42
	}
	if m.DeviceDetails != nil {
		{
			size := m.DeviceDetails.Size()
			i -= size
			if _, err := m.DeviceDetails.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	if len(m.DefaultGateway) > 0 {
		i -= len(m.DefaultGateway)
		copy(dAtA[i:], m.DefaultGateway)
		i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.DefaultGateway)))
		i--
		dAtA[i] = 0x32
	}
	if len(m.NetworkName) > 0 {
		i -= len(m.NetworkName)
		copy(dAtA[i:], m.NetworkName)
		i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.NetworkName)))
		i--
		dAtA[i] = 0x2a
	}
	if m.IpaddressPrefixlength != 0 {
		i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(m.IpaddressPrefixlength))
		i--
		dAtA[i] = 0x20
	}
	if len(m.Ipaddress) > 0 {
		i -= len(m.Ipaddress)
		copy(dAtA[i:], m.Ipaddress)
		i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.Ipaddress)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Macaddress) > 0 {
		i -= len(m.Macaddress)
		copy(dAtA[i:], m.Macaddress)
		i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.Macaddress)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *NCProxyEndpointSettings_PciDeviceDetails) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *NCProxyEndpointSettings_PciDeviceDetails) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.PciDeviceDetails != nil {
		{
			size, err := m.PciDeviceDetails.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x3a
	}
	return len(dAtA) - i, nil
}
func (m *PCIDeviceDetails) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *PCIDeviceDetails) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *PCIDeviceDetails) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.VirtualFunctionIndex != 0 {
		i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(m.VirtualFunctionIndex))
		i--
		dAtA[i] = 0x10
	}
	if len(m.DeviceID) > 0 {
		i -= len(m.DeviceID)
		copy(dAtA[i:], m.DeviceID)
		i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.DeviceID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *CreateEndpointResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *CreateEndpointResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CreateEndpointResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.ID) > 0 {
		i -= len(m.ID)
		copy(dAtA[i:], m.ID)
		i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.ID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *AddEndpointRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *AddEndpointRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AddEndpointRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.AttachToHost {
		i--
		if m.AttachToHost {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x18
	}
	if len(m.NamespaceID) > 0 {
		i -= len(m.NamespaceID)
		copy(dAtA[i:], m.NamespaceID)
		i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.NamespaceID)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *AddEndpointResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *AddEndpointResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AddEndpointResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	return len(dAtA) - i, nil
}

func (m *DeleteEndpointRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *DeleteEndpointRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DeleteEndpointRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *DeleteEndpointResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *DeleteEndpointResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DeleteEndpointResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	return len(dAtA) - i, nil
}

func (m *DeleteNetworkRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *DeleteNetworkRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DeleteNetworkRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *DeleteNetworkResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *DeleteNetworkResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DeleteNetworkResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	return len(dAtA) - i, nil
}

func (m *GetEndpointRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *GetEndpointRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GetEndpointRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *GetEndpointResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *GetEndpointResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GetEndpointResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Endpoint != nil {
		{
			size, err := m.Endpoint.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if len(m.ID) > 0 {
		i -= len(m.ID)
		copy(dAtA[i:], m.ID)
		i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.ID)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Namespace) > 0 {
		i -= len(m.Namespace)
		copy(dAtA[i:], m.Namespace)
		i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.Namespace)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *GetNetworkRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *GetNetworkRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GetNetworkRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *GetNetworkResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *GetNetworkResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GetNetworkResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.MacRange != nil {
		{
			size, err := m.MacRange.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.Network != nil {
		{
			size, err := m.Network.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.ID) > 0 {
		i -= len(m.ID)
		copy(dAtA[i:], m.ID)
		i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.ID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *MacRange) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *MacRange) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MacRange) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.EndMacAddress) > 0 {
		i -= len(m.EndMacAddress)
		copy(dAtA[i:], m.EndMacAddress)
		i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.EndMacAddress)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.StartMacAddress) > 0 {
		i -= len(m.StartMacAddress)
		copy(dAtA[i:], m.StartMacAddress)
		i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.StartMacAddress)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *GetEndpointsRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *GetEndpointsRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GetEndpointsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	return len(dAtA) - i, nil
}

func (m *GetEndpointsResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *GetEndpointsResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GetEndpointsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Endpoints) > 0 {
		for iNdEx := len(m.Endpoints) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Endpoints[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *GetNetworksRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *GetNetworksRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GetNetworksRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	return len(dAtA) - i, nil
}

func (m *GetNetworksResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *GetNetworksResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GetNetworksResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Networks) > 0 {
		for iNdEx := len(m.Networks) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Networks[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func encodeVarintNetworkconfigproxy(dAtA []byte, offset int, v uint64) int {
	offset -= sovNetworkconfigproxy(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *AddNICRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContainerID)
	if l > 0 {
		n += 1 + l + sovNetworkconfigproxy(uint64(l))
	}
	l = len(m.NicID)
	if l > 0 {
		n += 1 + l + sovNetworkconfigproxy(uint64(l))
	}
	l = len(m.EndpointName)
	if l > 0 {
		n += 1 + l + sovNetworkconfigproxy(uint64(l))
	}
	if m.EndpointSettings != nil {
		l = m.EndpointSettings.Size()
		n += 1 + l + sovNetworkconfigproxy(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *AddNICResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ModifyNICRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContainerID)
	if l > 0 {
		n += 1 + l + sovNetworkconfigproxy(uint64(l))
	}
	l = len(m.NicID)
	if l > 0 {
		n += 1 + l + sovNetworkconfigproxy(uint64(l))
	}
	l = len(m.EndpointName)
	if l > 0 {
		n += 1 + l + sovNetworkconfigproxy(uint64(l))
	}
	if m.EndpointSettings != nil {
		l = m.EndpointSettings.Size()
		n += 1 + l + sovNetworkconfigproxy(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ModifyNICResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *DeleteNICRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContainerID)
	if l > 0 {
		n += 1 + l + sovNetworkconfigproxy(uint64(l))
	}
	l = len(m.NicID)
	if l > 0 {
		n += 1 + l + sovNetworkconfigproxy(uint64(l))
	}
	l = len(m.EndpointName)
	if l > 0 {
		n += 1 + l + sovNetworkconfigproxy(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *DeleteNICResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *CreateNetworkRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Network != nil {
		l = m.Network.Size()
		n += 1 + l + sovNetworkconfigproxy(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *Network) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Settings != nil {
		n += m.Settings.Size()
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *Network_HcnNetwork) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.HcnNetwork != nil {
		l = m.HcnNetwork.Size()
		n += 1 + l + sovNetworkconfigproxy(uint64(l))
	}
	return n
}
func (m *Network_NcproxyNetwork) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.NcproxyNetwork != nil {
		l = m.NcproxyNetwork.Size()
		n += 1 + l + sovNetworkconfigproxy(uint64(l))
	}
	return n
}
func (m *NCProxyNetworkSettings) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovNetworkconfigproxy(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *HostComputeNetworkSettings) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovNetworkconfigproxy(uint64(l))
	}
	if m.Mode != 0 {
		n += 1 + sovNetworkconfigproxy(uint64(m.Mode))
	}
	l = len(m.SwitchName)
	if l > 0 {
		n += 1 + l + sovNetworkconfigproxy(uint64(l))
	}
	if m.IpamType != 0 {
		n += 1 + sovNetworkconfigproxy(uint64(m.IpamType))
	}
	if len(m.SubnetIpaddressPrefix) > 0 {
		for _, s := range m.SubnetIpaddressPrefix {
			l = len(s)
			n += 1 + l + sovNetworkconfigproxy(uint64(l))
		}
	}
	l = len(m.DefaultGateway)
	if l > 0 {
		n += 1 + l + sovNetworkconfigproxy(uint64(l))
	}
	if len(m.SubnetIpaddressPrefixIpv6) > 0 {
		for _, s := range m.SubnetIpaddressPrefixIpv6 {
			l = len(s)
			n += 1 + l + sovNetworkconfigproxy(uint64(l))
		}
	}
	l = len(m.DefaultGatewayIpv6)
	if l > 0 {
		n += 1 + l + sovNetworkconfigproxy(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *CreateNetworkResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ID)
	if l > 0 {
		n += 1 + l + sovNetworkconfigproxy(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *PortNameEndpointPolicySetting) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.PortName)
	if l > 0 {
		n += 1 + l + sovNetworkconfigproxy(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *IovEndpointPolicySetting) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.IovOffloadWeight != 0 {
		n += 1 + sovNetworkconfigproxy(uint64(m.IovOffloadWeight))
	}
	if m.QueuePairsRequested != 0 {
		n += 1 + sovNetworkconfigproxy(uint64(m.QueuePairsRequested))
	}
	if m.InterruptModeration != 0 {
		n += 1 + sovNetworkconfigproxy(uint64(m.InterruptModeration))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *DnsSetting) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.ServerIpAddrs) > 0 {
		for _, s := range m.ServerIpAddrs {
			l = len(s)
			n += 1 + l + sovNetworkconfigproxy(uint64(l))
		}
	}
	l = len(m.Domain)
	if l > 0 {
		n += 1 + l + sovNetworkconfigproxy(uint64(l))
	}
	if len(m.Search) > 0 {
		for _, s := range m.Search {
			l = len(s)
			n += 1 + l + sovNetworkconfigproxy(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *CreateEndpointRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.EndpointSettings != nil {
		l = m.EndpointSettings.Size()
		n += 1 + l + sovNetworkconfigproxy(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *EndpointSettings) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Settings != nil {
		n += m.Settings.Size()
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *EndpointSettings_HcnEndpoint) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.HcnEndpoint != nil {
		l = m.HcnEndpoint.Size()
		n += 1 + l + sovNetworkconfigproxy(uint64(l))
	}
	return n
}
func (m *EndpointSettings_NcproxyEndpoint) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.NcproxyEndpoint != nil {
		l = m.NcproxyEndpoint.Size()
		n += 1 + l + sovNetworkconfigproxy(uint64(l))
	}
	return n
}
func (m *HcnEndpointResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Namespace)
	if l > 0 {
		n += 1 + l + sovNetworkconfigproxy(uint64(l))
	}
	l = len(m.ID)
	if l > 0 {
		n += 1 + l + sovNetworkconfigproxy(uint64(l))
	}
	if m.Settings != nil {
		l = m.Settings.Size()
		n += 1 + l + sovNetworkconfigproxy(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *HcnEndpointSettings) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovNetworkconfigproxy(uint64(l))
	}
	l = len(m.Macaddress)
	if l > 0 {
		n += 1 + l + sovNetworkconfigproxy(uint64(l))
	}
	l = len(m.Ipaddress)
	if l > 0 {
		n += 1 + l + sovNetworkconfigproxy(uint64(l))
	}
	if m.IpaddressPrefixlength != 0 {
		n += 1 + sovNetworkconfigproxy(uint64(m.IpaddressPrefixlength))
	}
	l = len(m.NetworkName)
	if l > 0 {
		n += 1 + l + sovNetworkconfigproxy(uint64(l))
	}
	if m.Policies != nil {
		l = m.Policies.Size()
		n += 1 + l + sovNetworkconfigproxy(uint64(l))
	}
	if m.DnsSetting != nil {
		l = m.DnsSetting.Size()
		n += 1 + l + sovNetworkconfigproxy(uint64(l))
	}
	l = len(m.Ipv6Address)
	if l > 0 {
		n += 1 + l + sovNetworkconfigproxy(uint64(l))
	}
	if m.Ipv6AddressPrefixlength != 0 {
		n += 1 + sovNetworkconfigproxy(uint64(m.Ipv6AddressPrefixlength))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *HcnEndpointPolicies) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.PortnamePolicySetting != nil {
		l = m.PortnamePolicySetting.Size()
		n += 1 + l + sovNetworkconfigproxy(uint64(l))
	}
	if m.IovPolicySettings != nil {
		l = m.IovPolicySettings.Size()
		n += 1 + l + sovNetworkconfigproxy(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *NCProxyEndpointSettings) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovNetworkconfigproxy(uint64(l))
	}
	l = len(m.Macaddress)
	if l > 0 {
		n += 1 + l + sovNetworkconfigproxy(uint64(l))
	}
	l = len(m.Ipaddress)
	if l > 0 {
		n += 1 + l + sovNetworkconfigproxy(uint64(l))
	}
	if m.IpaddressPrefixlength != 0 {
		n += 1 + sovNetworkconfigproxy(uint64(m.IpaddressPrefixlength))
	}
	l = len(m.NetworkName)
	if l > 0 {
		n += 1 + l + sovNetworkconfigproxy(uint64(l))
	}
	l = len(m.DefaultGateway)
	if l > 0 {
		n += 1 + l + sovNetworkconfigproxy(uint64(l))
	}
	if m.DeviceDetails != nil {
		n += m.DeviceDetails.Size()
	}
	l = len(m.Ipv6Address)
	if l > 0 {
		n += 1 + l + sovNetworkconfigproxy(uint64(l))
	}
	l = len(m.Ipv6AddressPrefixlength)
	if l > 0 {
		n += 1 + l + sovNetworkconfigproxy(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *NCProxyEndpointSettings_PciDeviceDetails) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.PciDeviceDetails != nil {
		l = m.PciDeviceDetails.Size()
		n += 1 + l + sovNetworkconfigproxy(uint64(l))
	}
	return n
}
func (m *PCIDeviceDetails) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.DeviceID)
	if l > 0 {
		n += 1 + l + sovNetworkconfigproxy(uint64(l))
	}
	if m.VirtualFunctionIndex != 0 {
		n += 1 + sovNetworkconfigproxy(uint64(m.VirtualFunctionIndex))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *CreateEndpointResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ID)
	if l > 0 {
		n += 1 + l + sovNetworkconfigproxy(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *AddEndpointRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovNetworkconfigproxy(uint64(l))
	}
	l = len(m.NamespaceID)
	if l > 0 {
		n += 1 + l + sovNetworkconfigproxy(uint64(l))
	}
	if m.AttachToHost {
		n += 2
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *AddEndpointResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *DeleteEndpointRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovNetworkconfigproxy(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *DeleteEndpointResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *DeleteNetworkRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovNetworkconfigproxy(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *DeleteNetworkResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *GetEndpointRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovNetworkconfigproxy(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *GetEndpointResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Namespace)
	if l > 0 {
		n += 1 + l + sovNetworkconfigproxy(uint64(l))
	}
	l = len(m.ID)
	if l > 0 {
		n += 1 + l + sovNetworkconfigproxy(uint64(l))
	}
	if m.Endpoint != nil {
		l = m.Endpoint.Size()
		n += 1 + l + sovNetworkconfigproxy(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *GetNetworkRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovNetworkconfigproxy(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *GetNetworkResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ID)
	if l > 0 {
		n += 1 + l + sovNetworkconfigproxy(uint64(l))
	}
	if m.Network != nil {
		l = m.Network.Size()
		n += 1 + l + sovNetworkconfigproxy(uint64(l))
	}
	if m.MacRange != nil {
		l = m.MacRange.Size()
		n += 1 + l + sovNetworkconfigproxy(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *MacRange) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.StartMacAddress)
	if l > 0 {
		n += 1 + l + sovNetworkconfigproxy(uint64(l))
	}
	l = len(m.EndMacAddress)
	if l > 0 {
		n += 1 + l + sovNetworkconfigproxy(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *GetEndpointsRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *GetEndpointsResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Endpoints) > 0 {
		for _, e := range m.Endpoints {
			l = e.Size()
			n += 1 + l + sovNetworkconfigproxy(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *GetNetworksRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *GetNetworksResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Networks) > 0 {
		for _, e := range m.Networks {
			l = e.Size()
			n += 1 + l + sovNetworkconfigproxy(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func sovNetworkconfigproxy(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozNetworkconfigproxy(x uint64) (n int) {
	return sovNetworkconfigproxy(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (this *AddNICRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&AddNICRequest{`,
		`ContainerID:` + fmt.Sprintf("%v", this.ContainerID) + `,`,
		`NicID:` + fmt.Sprintf("%v", this.NicID) + `,`,
		`EndpointName:` + fmt.Sprintf("%v", this.EndpointName) + `,`,
		`EndpointSettings:` + strings.Replace(this.EndpointSettings.String(), "EndpointSettings", "EndpointSettings", 1) + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *AddNICResponse) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&AddNICResponse{`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ModifyNICRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ModifyNICRequest{`,
		`ContainerID:` + fmt.Sprintf("%v", this.ContainerID) + `,`,
		`NicID:` + fmt.Sprintf("%v", this.NicID) + `,`,
		`EndpointName:` + fmt.Sprintf("%v", this.EndpointName) + `,`,
		`EndpointSettings:` + strings.Replace(this.EndpointSettings.String(), "EndpointSettings", "EndpointSettings", 1) + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ModifyNICResponse) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ModifyNICResponse{`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *DeleteNICRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&DeleteNICRequest{`,
		`ContainerID:` + fmt.Sprintf("%v", this.ContainerID) + `,`,
		`NicID:` + fmt.Sprintf("%v", this.NicID) + `,`,
		`EndpointName:` + fmt.Sprintf("%v", this.EndpointName) + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *DeleteNICResponse) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&DeleteNICResponse{`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *CreateNetworkRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&CreateNetworkRequest{`,
		`Network:` + strings.Replace(this.Network.String(), "Network", "Network", 1) + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Network) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Network{`,
		`Settings:` + fmt.Sprintf("%v", this.Settings) + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Network_HcnNetwork) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Network_HcnNetwork{`,
		`HcnNetwork:` + strings.Replace(fmt.Sprintf("%v", this.HcnNetwork), "HostComputeNetworkSettings", "HostComputeNetworkSettings", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Network_NcproxyNetwork) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Network_NcproxyNetwork{`,
		`NcproxyNetwork:` + strings.Replace(fmt.Sprintf("%v", this.NcproxyNetwork), "NCProxyNetworkSettings", "NCProxyNetworkSettings", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *NCProxyNetworkSettings) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&NCProxyNetworkSettings{`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *HostComputeNetworkSettings) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&HostComputeNetworkSettings{`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`Mode:` + fmt.Sprintf("%v", this.Mode) + `,`,
		`SwitchName:` + fmt.Sprintf("%v", this.SwitchName) + `,`,
		`IpamType:` + fmt.Sprintf("%v", this.IpamType) + `,`,
		`SubnetIpaddressPrefix:` + fmt.Sprintf("%v", this.SubnetIpaddressPrefix) + `,`,
		`DefaultGateway:` + fmt.Sprintf("%v", this.DefaultGateway) + `,`,
		`SubnetIpaddressPrefixIpv6:` + fmt.Sprintf("%v", this.SubnetIpaddressPrefixIpv6) + `,`,
		`DefaultGatewayIpv6:` + fmt.Sprintf("%v", this.DefaultGatewayIpv6) + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *CreateNetworkResponse) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&CreateNetworkResponse{`,
		`ID:` + fmt.Sprintf("%v", this.ID) + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *PortNameEndpointPolicySetting) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&PortNameEndpointPolicySetting{`,
		`PortName:` + fmt.Sprintf("%v", this.PortName) + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *IovEndpointPolicySetting) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&IovEndpointPolicySetting{`,
		`IovOffloadWeight:` + fmt.Sprintf("%v", this.IovOffloadWeight) + `,`,
		`QueuePairsRequested:` + fmt.Sprintf("%v", this.QueuePairsRequested) + `,`,
		`InterruptModeration:` + fmt.Sprintf("%v", this.InterruptModeration) + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *DnsSetting) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&DnsSetting{`,
		`ServerIpAddrs:` + fmt.Sprintf("%v", this.ServerIpAddrs) + `,`,
		`Domain:` + fmt.Sprintf("%v", this.Domain) + `,`,
		`Search:` + fmt.Sprintf("%v", this.Search) + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *CreateEndpointRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&CreateEndpointRequest{`,
		`EndpointSettings:` + strings.Replace(this.EndpointSettings.String(), "EndpointSettings", "EndpointSettings", 1) + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *EndpointSettings) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&EndpointSettings{`,
		`Settings:` + fmt.Sprintf("%v", this.Settings) + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *EndpointSettings_HcnEndpoint) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&EndpointSettings_HcnEndpoint{`,
		`HcnEndpoint:` + strings.Replace(fmt.Sprintf("%v", this.HcnEndpoint), "HcnEndpointSettings", "HcnEndpointSettings", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *EndpointSettings_NcproxyEndpoint) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&EndpointSettings_NcproxyEndpoint{`,
		`NcproxyEndpoint:` + strings.Replace(fmt.Sprintf("%v", this.NcproxyEndpoint), "NCProxyEndpointSettings", "NCProxyEndpointSettings", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *HcnEndpointResponse) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&HcnEndpointResponse{`,
		`Namespace:` + fmt.Sprintf("%v", this.Namespace) + `,`,
		`ID:` + fmt.Sprintf("%v", this.ID) + `,`,
		`Settings:` + strings.Replace(this.Settings.String(), "HcnEndpointSettings", "HcnEndpointSettings", 1) + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *HcnEndpointSettings) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&HcnEndpointSettings{`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`Macaddress:` + fmt.Sprintf("%v", this.Macaddress) + `,`,
		`Ipaddress:` + fmt.Sprintf("%v", this.Ipaddress) + `,`,
		`IpaddressPrefixlength:` + fmt.Sprintf("%v", this.IpaddressPrefixlength) + `,`,
		`NetworkName:` + fmt.Sprintf("%v", this.NetworkName) + `,`,
		`Policies:` + strings.Replace(this.Policies.String(), "HcnEndpointPolicies", "HcnEndpointPolicies", 1) + `,`,
		`DnsSetting:` + strings.Replace(this.DnsSetting.String(), "DnsSetting", "DnsSetting", 1) + `,`,
		`Ipv6Address:` + fmt.Sprintf("%v", this.Ipv6Address) + `,`,
		`Ipv6AddressPrefixlength:` + fmt.Sprintf("%v", this.Ipv6AddressPrefixlength) + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *HcnEndpointPolicies) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&HcnEndpointPolicies{`,
		`PortnamePolicySetting:` + strings.Replace(this.PortnamePolicySetting.String(), "PortNameEndpointPolicySetting", "PortNameEndpointPolicySetting", 1) + `,`,
		`IovPolicySettings:` + strings.Replace(this.IovPolicySettings.String(), "IovEndpointPolicySetting", "IovEndpointPolicySetting", 1) + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *NCProxyEndpointSettings) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&NCProxyEndpointSettings{`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`Macaddress:` + fmt.Sprintf("%v", this.Macaddress) + `,`,
		`Ipaddress:` + fmt.Sprintf("%v", this.Ipaddress) + `,`,
		`IpaddressPrefixlength:` + fmt.Sprintf("%v", this.IpaddressPrefixlength) + `,`,
		`NetworkName:` + fmt.Sprintf("%v", this.NetworkName) + `,`,
		`DefaultGateway:` + fmt.Sprintf("%v", this.DefaultGateway) + `,`,
		`DeviceDetails:` + fmt.Sprintf("%v", this.DeviceDetails) + `,`,
		`Ipv6Address:` + fmt.Sprintf("%v", this.Ipv6Address) + `,`,
		`Ipv6AddressPrefixlength:` + fmt.Sprintf("%v", this.Ipv6AddressPrefixlength) + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *NCProxyEndpointSettings_PciDeviceDetails) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&NCProxyEndpointSettings_PciDeviceDetails{`,
		`PciDeviceDetails:` + strings.Replace(fmt.Sprintf("%v", this.PciDeviceDetails), "PCIDeviceDetails", "PCIDeviceDetails", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *PCIDeviceDetails) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&PCIDeviceDetails{`,
		`DeviceID:` + fmt.Sprintf("%v", this.DeviceID) + `,`,
		`VirtualFunctionIndex:` + fmt.Sprintf("%v", this.VirtualFunctionIndex) + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *CreateEndpointResponse) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&CreateEndpointResponse{`,
		`ID:` + fmt.Sprintf("%v", this.ID) + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *AddEndpointRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&AddEndpointRequest{`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`NamespaceID:` + fmt.Sprintf("%v", this.NamespaceID) + `,`,
		`AttachToHost:` + fmt.Sprintf("%v", this.AttachToHost) + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *AddEndpointResponse) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&AddEndpointResponse{`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *DeleteEndpointRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&DeleteEndpointRequest{`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *DeleteEndpointResponse) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&DeleteEndpointResponse{`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *DeleteNetworkRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&DeleteNetworkRequest{`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *DeleteNetworkResponse) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&DeleteNetworkResponse{`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *GetEndpointRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&GetEndpointRequest{`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *GetEndpointResponse) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&GetEndpointResponse{`,
		`Namespace:` + fmt.Sprintf("%v", this.Namespace) + `,`,
		`ID:` + fmt.Sprintf("%v", this.ID) + `,`,
		`Endpoint:` + strings.Replace(this.Endpoint.String(), "EndpointSettings", "EndpointSettings", 1) + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *GetNetworkRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&GetNetworkRequest{`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *GetNetworkResponse) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&GetNetworkResponse{`,
		`ID:` + fmt.Sprintf("%v", this.ID) + `,`,
		`Network:` + strings.Replace(this.Network.String(), "Network", "Network", 1) + `,`,
		`MacRange:` + strings.Replace(this.MacRange.String(), "MacRange", "MacRange", 1) + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *MacRange) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&MacRange{`,
		`StartMacAddress:` + fmt.Sprintf("%v", this.StartMacAddress) + `,`,
		`EndMacAddress:` + fmt.Sprintf("%v", this.EndMacAddress) + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *GetEndpointsRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&GetEndpointsRequest{`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *GetEndpointsResponse) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForEndpoints := "[]*GetEndpointResponse{"
	for _, f := range this.Endpoints {
		repeatedStringForEndpoints += strings.Replace(f.String(), "GetEndpointResponse", "GetEndpointResponse", 1) + ","
	}
	repeatedStringForEndpoints += "}"
	s := strings.Join([]string{`&GetEndpointsResponse{`,
		`Endpoints:` + repeatedStringForEndpoints + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *GetNetworksRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&GetNetworksRequest{`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *GetNetworksResponse) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForNetworks := "[]*GetNetworkResponse{"
	for _, f := range this.Networks {
		repeatedStringForNetworks += strings.Replace(f.String(), "GetNetworkResponse", "GetNetworkResponse", 1) + ","
	}
	repeatedStringForNetworks += "}"
	s := strings.Join([]string{`&GetNetworksResponse{`,
		`Networks:` + repeatedStringForNetworks + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func valueToStringNetworkconfigproxy(v interface{}) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("*%v", pv)
}
func (m *AddNICRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowNetworkconfigproxy
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: AddNICRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AddNICRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContainerID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNetworkconfigproxy
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContainerID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NicID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNetworkconfigproxy
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NicID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EndpointName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNetworkconfigproxy
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.EndpointName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EndpointSettings", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNetworkconfigproxy
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.EndpointSettings == nil {
				m.EndpointSettings = &EndpointSettings{}
			}
			if err := m.EndpointSettings.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AddNICResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowNetworkconfigproxy
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: AddNICResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AddNICResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ModifyNICRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowNetworkconfigproxy
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ModifyNICRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ModifyNICRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContainerID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNetworkconfigproxy
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContainerID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NicID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNetworkconfigproxy
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NicID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EndpointName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNetworkconfigproxy
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.EndpointName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EndpointSettings", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNetworkconfigproxy
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.EndpointSettings == nil {
				m.EndpointSettings = &EndpointSettings{}
			}
			if err := m.EndpointSettings.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ModifyNICResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowNetworkconfigproxy
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ModifyNICResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ModifyNICResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DeleteNICRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowNetworkconfigproxy
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: DeleteNICRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DeleteNICRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContainerID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNetworkconfigproxy
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContainerID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NicID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNetworkconfigproxy
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NicID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EndpointName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNetworkconfigproxy
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.EndpointName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DeleteNICResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowNetworkconfigproxy
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: DeleteNICResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DeleteNICResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CreateNetworkRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowNetworkconfigproxy
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: CreateNetworkRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CreateNetworkRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Network", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNetworkconfigproxy
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Network == nil {
				m.Network = &Network{}
			}
			if err := m.Network.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Network) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowNetworkconfigproxy
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Network: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Network: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field HcnNetwork", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNetworkconfigproxy
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &HostComputeNetworkSettings{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Settings = &Network_HcnNetwork{v}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NcproxyNetwork", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNetworkconfigproxy
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &NCProxyNetworkSettings{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Settings = &Network_NcproxyNetwork{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *NCProxyNetworkSettings) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowNetworkconfigproxy
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: NCProxyNetworkSettings: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: NCProxyNetworkSettings: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNetworkconfigproxy
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *HostComputeNetworkSettings) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowNetworkconfigproxy
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: HostComputeNetworkSettings: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: HostComputeNetworkSettings: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNetworkconfigproxy
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Mode", wireType)
			}
			m.Mode = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNetworkconfigproxy
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Mode |= HostComputeNetworkSettings_NetworkMode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SwitchName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNetworkconfigproxy
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SwitchName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IpamType", wireType)
			}
			m.IpamType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNetworkconfigproxy
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.IpamType |= HostComputeNetworkSettings_IpamType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SubnetIpaddressPrefix", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNetworkconfigproxy
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SubnetIpaddressPrefix = append(m.SubnetIpaddressPrefix, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DefaultGateway", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNetworkconfigproxy
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DefaultGateway = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SubnetIpaddressPrefixIpv6", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNetworkconfigproxy
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SubnetIpaddressPrefixIpv6 = append(m.SubnetIpaddressPrefixIpv6, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DefaultGatewayIpv6", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNetworkconfigproxy
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DefaultGatewayIpv6 = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CreateNetworkResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowNetworkconfigproxy
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: CreateNetworkResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CreateNetworkResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNetworkconfigproxy
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *PortNameEndpointPolicySetting) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowNetworkconfigproxy
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: PortNameEndpointPolicySetting: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PortNameEndpointPolicySetting: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PortName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNetworkconfigproxy
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PortName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *IovEndpointPolicySetting) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowNetworkconfigproxy
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: IovEndpointPolicySetting: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: IovEndpointPolicySetting: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IovOffloadWeight", wireType)
			}
			m.IovOffloadWeight = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNetworkconfigproxy
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.IovOffloadWeight |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field QueuePairsRequested", wireType)
			}
			m.QueuePairsRequested = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNetworkconfigproxy
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.QueuePairsRequested |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field InterruptModeration", wireType)
			}
			m.InterruptModeration = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNetworkconfigproxy
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.InterruptModeration |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DnsSetting) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowNetworkconfigproxy
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: DnsSetting: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DnsSetting: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ServerIpAddrs", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNetworkconfigproxy
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ServerIpAddrs = append(m.ServerIpAddrs, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Domain", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNetworkconfigproxy
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Domain = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Search", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNetworkconfigproxy
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Search = append(m.Search, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CreateEndpointRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowNetworkconfigproxy
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: CreateEndpointRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CreateEndpointRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EndpointSettings", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNetworkconfigproxy
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.EndpointSettings == nil {
				m.EndpointSettings = &EndpointSettings{}
			}
			if err := m.EndpointSettings.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EndpointSettings) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowNetworkconfigproxy
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: EndpointSettings: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EndpointSettings: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field HcnEndpoint", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNetworkconfigproxy
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &HcnEndpointSettings{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Settings = &EndpointSettings_HcnEndpoint{v}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NcproxyEndpoint", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNetworkconfigproxy
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &NCProxyEndpointSettings{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Settings = &EndpointSettings_NcproxyEndpoint{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *HcnEndpointResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowNetworkconfigproxy
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: HcnEndpointResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: HcnEndpointResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Namespace", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNetworkconfigproxy
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Namespace = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNetworkconfigproxy
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Settings", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNetworkconfigproxy
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Settings == nil {
				m.Settings = &HcnEndpointSettings{}
			}
			if err := m.Settings.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *HcnEndpointSettings) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowNetworkconfigproxy
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: HcnEndpointSettings: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: HcnEndpointSettings: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNetworkconfigproxy
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Macaddress", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNetworkconfigproxy
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Macaddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ipaddress", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNetworkconfigproxy
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Ipaddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IpaddressPrefixlength", wireType)
			}
			m.IpaddressPrefixlength = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNetworkconfigproxy
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.IpaddressPrefixlength |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NetworkName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNetworkconfigproxy
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NetworkName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Policies", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNetworkconfigproxy
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Policies == nil {
				m.Policies = &HcnEndpointPolicies{}
			}
			if err := m.Policies.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DnsSetting", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNetworkconfigproxy
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.DnsSetting == nil {
				m.DnsSetting = &DnsSetting{}
			}
			if err := m.DnsSetting.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ipv6Address", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNetworkconfigproxy
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Ipv6Address = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ipv6AddressPrefixlength", wireType)
			}
			m.Ipv6AddressPrefixlength = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNetworkconfigproxy
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Ipv6AddressPrefixlength |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *HcnEndpointPolicies) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowNetworkconfigproxy
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: HcnEndpointPolicies: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: HcnEndpointPolicies: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PortnamePolicySetting", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNetworkconfigproxy
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.PortnamePolicySetting == nil {
				m.PortnamePolicySetting = &PortNameEndpointPolicySetting{}
			}
			if err := m.PortnamePolicySetting.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IovPolicySettings", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNetworkconfigproxy
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.IovPolicySettings == nil {
				m.IovPolicySettings = &IovEndpointPolicySetting{}
			}
			if err := m.IovPolicySettings.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *NCProxyEndpointSettings) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowNetworkconfigproxy
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: NCProxyEndpointSettings: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: NCProxyEndpointSettings: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNetworkconfigproxy
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Macaddress", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNetworkconfigproxy
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Macaddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ipaddress", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNetworkconfigproxy
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Ipaddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IpaddressPrefixlength", wireType)
			}
			m.IpaddressPrefixlength = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNetworkconfigproxy
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.IpaddressPrefixlength |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NetworkName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNetworkconfigproxy
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NetworkName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DefaultGateway", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNetworkconfigproxy
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DefaultGateway = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PciDeviceDetails", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNetworkconfigproxy
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &PCIDeviceDetails{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.DeviceDetails = &NCProxyEndpointSettings_PciDeviceDetails{v}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ipv6Address", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNetworkconfigproxy
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Ipv6Address = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ipv6AddressPrefixlength", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNetworkconfigproxy
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Ipv6AddressPrefixlength = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *PCIDeviceDetails) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowNetworkconfigproxy
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: PCIDeviceDetails: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PCIDeviceDetails: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DeviceID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNetworkconfigproxy
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DeviceID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field VirtualFunctionIndex", wireType)
			}
			m.VirtualFunctionIndex = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNetworkconfigproxy
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.VirtualFunctionIndex |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CreateEndpointResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowNetworkconfigproxy
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: CreateEndpointResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CreateEndpointResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNetworkconfigproxy
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AddEndpointRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowNetworkconfigproxy
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: AddEndpointRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AddEndpointRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNetworkconfigproxy
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NamespaceID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNetworkconfigproxy
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NamespaceID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AttachToHost", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNetworkconfigproxy
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.AttachToHost = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AddEndpointResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowNetworkconfigproxy
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: AddEndpointResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AddEndpointResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DeleteEndpointRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowNetworkconfigproxy
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: DeleteEndpointRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DeleteEndpointRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNetworkconfigproxy
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DeleteEndpointResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowNetworkconfigproxy
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: DeleteEndpointResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DeleteEndpointResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DeleteNetworkRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowNetworkconfigproxy
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: DeleteNetworkRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DeleteNetworkRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNetworkconfigproxy
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DeleteNetworkResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowNetworkconfigproxy
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: DeleteNetworkResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DeleteNetworkResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GetEndpointRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowNetworkconfigproxy
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: GetEndpointRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetEndpointRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNetworkconfigproxy
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GetEndpointResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowNetworkconfigproxy
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: GetEndpointResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetEndpointResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Namespace", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNetworkconfigproxy
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Namespace = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNetworkconfigproxy
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Endpoint", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNetworkconfigproxy
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Endpoint == nil {
				m.Endpoint = &EndpointSettings{}
			}
			if err := m.Endpoint.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GetNetworkRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowNetworkconfigproxy
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: GetNetworkRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetNetworkRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNetworkconfigproxy
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GetNetworkResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowNetworkconfigproxy
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: GetNetworkResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetNetworkResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNetworkconfigproxy
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Network", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNetworkconfigproxy
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Network == nil {
				m.Network = &Network{}
			}
			if err := m.Network.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MacRange", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNetworkconfigproxy
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.MacRange == nil {
				m.MacRange = &MacRange{}
			}
			if err := m.MacRange.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MacRange) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowNetworkconfigproxy
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MacRange: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MacRange: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StartMacAddress", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNetworkconfigproxy
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.StartMacAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EndMacAddress", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNetworkconfigproxy
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.EndMacAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GetEndpointsRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowNetworkconfigproxy
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: GetEndpointsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetEndpointsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GetEndpointsResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowNetworkconfigproxy
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: GetEndpointsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetEndpointsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Endpoints", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNetworkconfigproxy
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Endpoints = append(m.Endpoints, &GetEndpointResponse{})
			if err := m.Endpoints[len(m.Endpoints)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GetNetworksRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowNetworkconfigproxy
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: GetNetworksRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetNetworksRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GetNetworksResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowNetworkconfigproxy
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: GetNetworksResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetNetworksResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Networks", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNetworkconfigproxy
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Networks = append(m.Networks, &GetNetworkResponse{})
			if err := m.Networks[len(m.Networks)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthNetworkconfigproxy
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipNetworkconfigproxy(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	depth := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowNetworkconfigproxy
			}
			if iNdEx >= l {
				return 0, io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		wireType := int(wire & 0x7)
		switch wireType {
		case 0:
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowNetworkconfigproxy
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
		case 1:
			iNdEx += 8
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowNetworkconfigproxy
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if length < 0 {
				return 0, ErrInvalidLengthNetworkconfigproxy
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupNetworkconfigproxy
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthNetworkconfigproxy
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthNetworkconfigproxy        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowNetworkconfigproxy          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupNetworkconfigproxy = fmt.Errorf("proto: unexpected end of group")
)