github.com/onosproject/onos-api/go@v0.10.32/onos/discovery/discovery.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: onos/discovery/discovery.proto

package discovery

import (
	context "context"
	fmt "fmt"
	_ "github.com/gogo/protobuf/gogoproto"
	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"
)

// 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 AddPodRequest struct {
	ID string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
}

func (m *AddPodRequest) Reset()         { *m = AddPodRequest{} }
func (m *AddPodRequest) String() string { return proto.CompactTextString(m) }
func (*AddPodRequest) ProtoMessage()    {}
func (*AddPodRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_ee9a9e1db4c6208c, []int{0}
}
func (m *AddPodRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AddPodRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AddPodRequest.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 *AddPodRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AddPodRequest.Merge(m, src)
}
func (m *AddPodRequest) XXX_Size() int {
	return m.Size()
}
func (m *AddPodRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_AddPodRequest.DiscardUnknown(m)
}

var xxx_messageInfo_AddPodRequest proto.InternalMessageInfo

func (m *AddPodRequest) GetID() string {
	if m != nil {
		return m.ID
	}
	return ""
}

type AddPodResponse struct {
}

func (m *AddPodResponse) Reset()         { *m = AddPodResponse{} }
func (m *AddPodResponse) String() string { return proto.CompactTextString(m) }
func (*AddPodResponse) ProtoMessage()    {}
func (*AddPodResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_ee9a9e1db4c6208c, []int{1}
}
func (m *AddPodResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AddPodResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AddPodResponse.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 *AddPodResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AddPodResponse.Merge(m, src)
}
func (m *AddPodResponse) XXX_Size() int {
	return m.Size()
}
func (m *AddPodResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_AddPodResponse.DiscardUnknown(m)
}

var xxx_messageInfo_AddPodResponse proto.InternalMessageInfo

type AddRackRequest struct {
	ID    string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	PodID string `protobuf:"bytes,2,opt,name=pod_id,json=podId,proto3" json:"pod_id,omitempty"`
}

func (m *AddRackRequest) Reset()         { *m = AddRackRequest{} }
func (m *AddRackRequest) String() string { return proto.CompactTextString(m) }
func (*AddRackRequest) ProtoMessage()    {}
func (*AddRackRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_ee9a9e1db4c6208c, []int{2}
}
func (m *AddRackRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AddRackRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AddRackRequest.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 *AddRackRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AddRackRequest.Merge(m, src)
}
func (m *AddRackRequest) XXX_Size() int {
	return m.Size()
}
func (m *AddRackRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_AddRackRequest.DiscardUnknown(m)
}

var xxx_messageInfo_AddRackRequest proto.InternalMessageInfo

func (m *AddRackRequest) GetID() string {
	if m != nil {
		return m.ID
	}
	return ""
}

func (m *AddRackRequest) GetPodID() string {
	if m != nil {
		return m.PodID
	}
	return ""
}

type AddRackResponse struct {
}

func (m *AddRackResponse) Reset()         { *m = AddRackResponse{} }
func (m *AddRackResponse) String() string { return proto.CompactTextString(m) }
func (*AddRackResponse) ProtoMessage()    {}
func (*AddRackResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_ee9a9e1db4c6208c, []int{3}
}
func (m *AddRackResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AddRackResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AddRackResponse.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 *AddRackResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AddRackResponse.Merge(m, src)
}
func (m *AddRackResponse) XXX_Size() int {
	return m.Size()
}
func (m *AddRackResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_AddRackResponse.DiscardUnknown(m)
}

var xxx_messageInfo_AddRackResponse proto.InternalMessageInfo

type ManagementInfo struct {
	P4RTEndpoint      string `protobuf:"bytes,1,opt,name=p4rt_endpoint,json=p4rtEndpoint,proto3" json:"p4rt_endpoint,omitempty"`
	GNMIEndpoint      string `protobuf:"bytes,2,opt,name=gnmi_endpoint,json=gnmiEndpoint,proto3" json:"gnmi_endpoint,omitempty"`
	PipelineConfigID  string `protobuf:"bytes,3,opt,name=pipeline_config_id,json=pipelineConfigId,proto3" json:"pipeline_config_id,omitempty"`
	ChassisConfigID   string `protobuf:"bytes,4,opt,name=chassis_config_id,json=chassisConfigId,proto3" json:"chassis_config_id,omitempty"`
	LinkAgentEndpoint string `protobuf:"bytes,5,opt,name=link_agent_endpoint,json=linkAgentEndpoint,proto3" json:"link_agent_endpoint,omitempty"`
	HostAgentEndpoint string `protobuf:"bytes,6,opt,name=host_agent_endpoint,json=hostAgentEndpoint,proto3" json:"host_agent_endpoint,omitempty"`
	NatAgentEndpoint  string `protobuf:"bytes,7,opt,name=nat_agent_endpoint,json=natAgentEndpoint,proto3" json:"nat_agent_endpoint,omitempty"`
	DeviceID          uint64 `protobuf:"varint,8,opt,name=device_id,json=deviceId,proto3" json:"device_id,omitempty"`
	Realm             string `protobuf:"bytes,9,opt,name=realm,proto3" json:"realm,omitempty"`
	Role              string `protobuf:"bytes,10,opt,name=role,proto3" json:"role,omitempty"`
}

func (m *ManagementInfo) Reset()         { *m = ManagementInfo{} }
func (m *ManagementInfo) String() string { return proto.CompactTextString(m) }
func (*ManagementInfo) ProtoMessage()    {}
func (*ManagementInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_ee9a9e1db4c6208c, []int{4}
}
func (m *ManagementInfo) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ManagementInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ManagementInfo.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 *ManagementInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ManagementInfo.Merge(m, src)
}
func (m *ManagementInfo) XXX_Size() int {
	return m.Size()
}
func (m *ManagementInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_ManagementInfo.DiscardUnknown(m)
}

var xxx_messageInfo_ManagementInfo proto.InternalMessageInfo

func (m *ManagementInfo) GetP4RTEndpoint() string {
	if m != nil {
		return m.P4RTEndpoint
	}
	return ""
}

func (m *ManagementInfo) GetGNMIEndpoint() string {
	if m != nil {
		return m.GNMIEndpoint
	}
	return ""
}

func (m *ManagementInfo) GetPipelineConfigID() string {
	if m != nil {
		return m.PipelineConfigID
	}
	return ""
}

func (m *ManagementInfo) GetChassisConfigID() string {
	if m != nil {
		return m.ChassisConfigID
	}
	return ""
}

func (m *ManagementInfo) GetLinkAgentEndpoint() string {
	if m != nil {
		return m.LinkAgentEndpoint
	}
	return ""
}

func (m *ManagementInfo) GetHostAgentEndpoint() string {
	if m != nil {
		return m.HostAgentEndpoint
	}
	return ""
}

func (m *ManagementInfo) GetNatAgentEndpoint() string {
	if m != nil {
		return m.NatAgentEndpoint
	}
	return ""
}

func (m *ManagementInfo) GetDeviceID() uint64 {
	if m != nil {
		return m.DeviceID
	}
	return 0
}

func (m *ManagementInfo) GetRealm() string {
	if m != nil {
		return m.Realm
	}
	return ""
}

func (m *ManagementInfo) GetRole() string {
	if m != nil {
		return m.Role
	}
	return ""
}

type AddSwitchRequest struct {
	ID             string          `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	PodID          string          `protobuf:"bytes,2,opt,name=pod_id,json=podId,proto3" json:"pod_id,omitempty"`
	RackID         string          `protobuf:"bytes,3,opt,name=rack_id,json=rackId,proto3" json:"rack_id,omitempty"`
	ManagementInfo *ManagementInfo `protobuf:"bytes,4,opt,name=management_info,json=managementInfo,proto3" json:"management_info,omitempty"`
}

func (m *AddSwitchRequest) Reset()         { *m = AddSwitchRequest{} }
func (m *AddSwitchRequest) String() string { return proto.CompactTextString(m) }
func (*AddSwitchRequest) ProtoMessage()    {}
func (*AddSwitchRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_ee9a9e1db4c6208c, []int{5}
}
func (m *AddSwitchRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AddSwitchRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AddSwitchRequest.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 *AddSwitchRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AddSwitchRequest.Merge(m, src)
}
func (m *AddSwitchRequest) XXX_Size() int {
	return m.Size()
}
func (m *AddSwitchRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_AddSwitchRequest.DiscardUnknown(m)
}

var xxx_messageInfo_AddSwitchRequest proto.InternalMessageInfo

func (m *AddSwitchRequest) GetID() string {
	if m != nil {
		return m.ID
	}
	return ""
}

func (m *AddSwitchRequest) GetPodID() string {
	if m != nil {
		return m.PodID
	}
	return ""
}

func (m *AddSwitchRequest) GetRackID() string {
	if m != nil {
		return m.RackID
	}
	return ""
}

func (m *AddSwitchRequest) GetManagementInfo() *ManagementInfo {
	if m != nil {
		return m.ManagementInfo
	}
	return nil
}

type AddSwitchResponse struct {
}

func (m *AddSwitchResponse) Reset()         { *m = AddSwitchResponse{} }
func (m *AddSwitchResponse) String() string { return proto.CompactTextString(m) }
func (*AddSwitchResponse) ProtoMessage()    {}
func (*AddSwitchResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_ee9a9e1db4c6208c, []int{6}
}
func (m *AddSwitchResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AddSwitchResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AddSwitchResponse.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 *AddSwitchResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AddSwitchResponse.Merge(m, src)
}
func (m *AddSwitchResponse) XXX_Size() int {
	return m.Size()
}
func (m *AddSwitchResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_AddSwitchResponse.DiscardUnknown(m)
}

var xxx_messageInfo_AddSwitchResponse proto.InternalMessageInfo

type AddServerIPURequest struct {
	ID             string          `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	PodID          string          `protobuf:"bytes,2,opt,name=pod_id,json=podId,proto3" json:"pod_id,omitempty"`
	RackID         string          `protobuf:"bytes,3,opt,name=rack_id,json=rackId,proto3" json:"rack_id,omitempty"`
	ManagementInfo *ManagementInfo `protobuf:"bytes,4,opt,name=management_info,json=managementInfo,proto3" json:"management_info,omitempty"`
	Links          []*InjectedLink `protobuf:"bytes,5,rep,name=links,proto3" json:"links,omitempty"`
}

func (m *AddServerIPURequest) Reset()         { *m = AddServerIPURequest{} }
func (m *AddServerIPURequest) String() string { return proto.CompactTextString(m) }
func (*AddServerIPURequest) ProtoMessage()    {}
func (*AddServerIPURequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_ee9a9e1db4c6208c, []int{7}
}
func (m *AddServerIPURequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AddServerIPURequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AddServerIPURequest.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 *AddServerIPURequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AddServerIPURequest.Merge(m, src)
}
func (m *AddServerIPURequest) XXX_Size() int {
	return m.Size()
}
func (m *AddServerIPURequest) XXX_DiscardUnknown() {
	xxx_messageInfo_AddServerIPURequest.DiscardUnknown(m)
}

var xxx_messageInfo_AddServerIPURequest proto.InternalMessageInfo

func (m *AddServerIPURequest) GetID() string {
	if m != nil {
		return m.ID
	}
	return ""
}

func (m *AddServerIPURequest) GetPodID() string {
	if m != nil {
		return m.PodID
	}
	return ""
}

func (m *AddServerIPURequest) GetRackID() string {
	if m != nil {
		return m.RackID
	}
	return ""
}

func (m *AddServerIPURequest) GetManagementInfo() *ManagementInfo {
	if m != nil {
		return m.ManagementInfo
	}
	return nil
}

func (m *AddServerIPURequest) GetLinks() []*InjectedLink {
	if m != nil {
		return m.Links
	}
	return nil
}

type InjectedLink struct {
	Port       uint64 `protobuf:"varint,1,opt,name=port,proto3" json:"port,omitempty"`
	RemotePort string `protobuf:"bytes,2,opt,name=remote_port,json=remotePort,proto3" json:"remote_port,omitempty"`
}

func (m *InjectedLink) Reset()         { *m = InjectedLink{} }
func (m *InjectedLink) String() string { return proto.CompactTextString(m) }
func (*InjectedLink) ProtoMessage()    {}
func (*InjectedLink) Descriptor() ([]byte, []int) {
	return fileDescriptor_ee9a9e1db4c6208c, []int{8}
}
func (m *InjectedLink) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *InjectedLink) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_InjectedLink.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 *InjectedLink) XXX_Merge(src proto.Message) {
	xxx_messageInfo_InjectedLink.Merge(m, src)
}
func (m *InjectedLink) XXX_Size() int {
	return m.Size()
}
func (m *InjectedLink) XXX_DiscardUnknown() {
	xxx_messageInfo_InjectedLink.DiscardUnknown(m)
}

var xxx_messageInfo_InjectedLink proto.InternalMessageInfo

func (m *InjectedLink) GetPort() uint64 {
	if m != nil {
		return m.Port
	}
	return 0
}

func (m *InjectedLink) GetRemotePort() string {
	if m != nil {
		return m.RemotePort
	}
	return ""
}

type AddServerIPUResponse struct {
}

func (m *AddServerIPUResponse) Reset()         { *m = AddServerIPUResponse{} }
func (m *AddServerIPUResponse) String() string { return proto.CompactTextString(m) }
func (*AddServerIPUResponse) ProtoMessage()    {}
func (*AddServerIPUResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_ee9a9e1db4c6208c, []int{9}
}
func (m *AddServerIPUResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AddServerIPUResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AddServerIPUResponse.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 *AddServerIPUResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AddServerIPUResponse.Merge(m, src)
}
func (m *AddServerIPUResponse) XXX_Size() int {
	return m.Size()
}
func (m *AddServerIPUResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_AddServerIPUResponse.DiscardUnknown(m)
}

var xxx_messageInfo_AddServerIPUResponse proto.InternalMessageInfo

func init() {
	proto.RegisterType((*AddPodRequest)(nil), "onos.discovery.AddPodRequest")
	proto.RegisterType((*AddPodResponse)(nil), "onos.discovery.AddPodResponse")
	proto.RegisterType((*AddRackRequest)(nil), "onos.discovery.AddRackRequest")
	proto.RegisterType((*AddRackResponse)(nil), "onos.discovery.AddRackResponse")
	proto.RegisterType((*ManagementInfo)(nil), "onos.discovery.ManagementInfo")
	proto.RegisterType((*AddSwitchRequest)(nil), "onos.discovery.AddSwitchRequest")
	proto.RegisterType((*AddSwitchResponse)(nil), "onos.discovery.AddSwitchResponse")
	proto.RegisterType((*AddServerIPURequest)(nil), "onos.discovery.AddServerIPURequest")
	proto.RegisterType((*InjectedLink)(nil), "onos.discovery.InjectedLink")
	proto.RegisterType((*AddServerIPUResponse)(nil), "onos.discovery.AddServerIPUResponse")
}

func init() { proto.RegisterFile("onos/discovery/discovery.proto", fileDescriptor_ee9a9e1db4c6208c) }

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

// DiscoveryServiceClient is the client API for DiscoveryService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type DiscoveryServiceClient interface {
	// AddPod adds a new POD entity with the requisite aspects
	AddPod(ctx context.Context, in *AddPodRequest, opts ...grpc.CallOption) (*AddPodResponse, error)
	// AddRack adds a new rack entity with the requisite aspects as part of a POD
	AddRack(ctx context.Context, in *AddRackRequest, opts ...grpc.CallOption) (*AddRackResponse, error)
	// AddSwitch adds a new switch entity with the requisite aspects into a rack
	AddSwitch(ctx context.Context, in *AddSwitchRequest, opts ...grpc.CallOption) (*AddSwitchResponse, error)
	// AddServerIPU adds a new server entity and an associated IPU entity, both with the requisite aspects into a rack
	AddServerIPU(ctx context.Context, in *AddServerIPURequest, opts ...grpc.CallOption) (*AddServerIPUResponse, error)
}

type discoveryServiceClient struct {
	cc *grpc.ClientConn
}

func NewDiscoveryServiceClient(cc *grpc.ClientConn) DiscoveryServiceClient {
	return &discoveryServiceClient{cc}
}

func (c *discoveryServiceClient) AddPod(ctx context.Context, in *AddPodRequest, opts ...grpc.CallOption) (*AddPodResponse, error) {
	out := new(AddPodResponse)
	err := c.cc.Invoke(ctx, "/onos.discovery.DiscoveryService/AddPod", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *discoveryServiceClient) AddRack(ctx context.Context, in *AddRackRequest, opts ...grpc.CallOption) (*AddRackResponse, error) {
	out := new(AddRackResponse)
	err := c.cc.Invoke(ctx, "/onos.discovery.DiscoveryService/AddRack", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *discoveryServiceClient) AddSwitch(ctx context.Context, in *AddSwitchRequest, opts ...grpc.CallOption) (*AddSwitchResponse, error) {
	out := new(AddSwitchResponse)
	err := c.cc.Invoke(ctx, "/onos.discovery.DiscoveryService/AddSwitch", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *discoveryServiceClient) AddServerIPU(ctx context.Context, in *AddServerIPURequest, opts ...grpc.CallOption) (*AddServerIPUResponse, error) {
	out := new(AddServerIPUResponse)
	err := c.cc.Invoke(ctx, "/onos.discovery.DiscoveryService/AddServerIPU", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// DiscoveryServiceServer is the server API for DiscoveryService service.
type DiscoveryServiceServer interface {
	// AddPod adds a new POD entity with the requisite aspects
	AddPod(context.Context, *AddPodRequest) (*AddPodResponse, error)
	// AddRack adds a new rack entity with the requisite aspects as part of a POD
	AddRack(context.Context, *AddRackRequest) (*AddRackResponse, error)
	// AddSwitch adds a new switch entity with the requisite aspects into a rack
	AddSwitch(context.Context, *AddSwitchRequest) (*AddSwitchResponse, error)
	// AddServerIPU adds a new server entity and an associated IPU entity, both with the requisite aspects into a rack
	AddServerIPU(context.Context, *AddServerIPURequest) (*AddServerIPUResponse, error)
}

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

func (*UnimplementedDiscoveryServiceServer) AddPod(ctx context.Context, req *AddPodRequest) (*AddPodResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AddPod not implemented")
}
func (*UnimplementedDiscoveryServiceServer) AddRack(ctx context.Context, req *AddRackRequest) (*AddRackResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AddRack not implemented")
}
func (*UnimplementedDiscoveryServiceServer) AddSwitch(ctx context.Context, req *AddSwitchRequest) (*AddSwitchResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AddSwitch not implemented")
}
func (*UnimplementedDiscoveryServiceServer) AddServerIPU(ctx context.Context, req *AddServerIPURequest) (*AddServerIPUResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AddServerIPU not implemented")
}

func RegisterDiscoveryServiceServer(s *grpc.Server, srv DiscoveryServiceServer) {
	s.RegisterService(&_DiscoveryService_serviceDesc, srv)
}

func _DiscoveryService_AddPod_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AddPodRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DiscoveryServiceServer).AddPod(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/onos.discovery.DiscoveryService/AddPod",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DiscoveryServiceServer).AddPod(ctx, req.(*AddPodRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _DiscoveryService_AddRack_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AddRackRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DiscoveryServiceServer).AddRack(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/onos.discovery.DiscoveryService/AddRack",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DiscoveryServiceServer).AddRack(ctx, req.(*AddRackRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _DiscoveryService_AddSwitch_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AddSwitchRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DiscoveryServiceServer).AddSwitch(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/onos.discovery.DiscoveryService/AddSwitch",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DiscoveryServiceServer).AddSwitch(ctx, req.(*AddSwitchRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _DiscoveryService_AddServerIPU_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AddServerIPURequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DiscoveryServiceServer).AddServerIPU(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/onos.discovery.DiscoveryService/AddServerIPU",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DiscoveryServiceServer).AddServerIPU(ctx, req.(*AddServerIPURequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _DiscoveryService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "onos.discovery.DiscoveryService",
	HandlerType: (*DiscoveryServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "AddPod",
			Handler:    _DiscoveryService_AddPod_Handler,
		},
		{
			MethodName: "AddRack",
			Handler:    _DiscoveryService_AddRack_Handler,
		},
		{
			MethodName: "AddSwitch",
			Handler:    _DiscoveryService_AddSwitch_Handler,
		},
		{
			MethodName: "AddServerIPU",
			Handler:    _DiscoveryService_AddServerIPU_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "onos/discovery/discovery.proto",
}

func (m *AddPodRequest) 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 *AddPodRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *AddPodResponse) 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 *AddPodResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AddPodResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *AddRackRequest) 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 *AddRackRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *AddRackResponse) 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 *AddRackResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AddRackResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *ManagementInfo) 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 *ManagementInfo) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ManagementInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Role) > 0 {
		i -= len(m.Role)
		copy(dAtA[i:], m.Role)
		i = encodeVarintDiscovery(dAtA, i, uint64(len(m.Role)))
		i--
		dAtA[i] = 0x52
	}
	if len(m.Realm) > 0 {
		i -= len(m.Realm)
		copy(dAtA[i:], m.Realm)
		i = encodeVarintDiscovery(dAtA, i, uint64(len(m.Realm)))
		i--
		dAtA[i] = 0x4a
	}
	if m.DeviceID != 0 {
		i = encodeVarintDiscovery(dAtA, i, uint64(m.DeviceID))
		i--
		dAtA[i] = 0x40
	}
	if len(m.NatAgentEndpoint) > 0 {
		i -= len(m.NatAgentEndpoint)
		copy(dAtA[i:], m.NatAgentEndpoint)
		i = encodeVarintDiscovery(dAtA, i, uint64(len(m.NatAgentEndpoint)))
		i--
		dAtA[i] = 0x3a
	}
	if len(m.HostAgentEndpoint) > 0 {
		i -= len(m.HostAgentEndpoint)
		copy(dAtA[i:], m.HostAgentEndpoint)
		i = encodeVarintDiscovery(dAtA, i, uint64(len(m.HostAgentEndpoint)))
		i--
		dAtA[i] = 0x32
	}
	if len(m.LinkAgentEndpoint) > 0 {
		i -= len(m.LinkAgentEndpoint)
		copy(dAtA[i:], m.LinkAgentEndpoint)
		i = encodeVarintDiscovery(dAtA, i, uint64(len(m.LinkAgentEndpoint)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.ChassisConfigID) > 0 {
		i -= len(m.ChassisConfigID)
		copy(dAtA[i:], m.ChassisConfigID)
		i = encodeVarintDiscovery(dAtA, i, uint64(len(m.ChassisConfigID)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.PipelineConfigID) > 0 {
		i -= len(m.PipelineConfigID)
		copy(dAtA[i:], m.PipelineConfigID)
		i = encodeVarintDiscovery(dAtA, i, uint64(len(m.PipelineConfigID)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.GNMIEndpoint) > 0 {
		i -= len(m.GNMIEndpoint)
		copy(dAtA[i:], m.GNMIEndpoint)
		i = encodeVarintDiscovery(dAtA, i, uint64(len(m.GNMIEndpoint)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.P4RTEndpoint) > 0 {
		i -= len(m.P4RTEndpoint)
		copy(dAtA[i:], m.P4RTEndpoint)
		i = encodeVarintDiscovery(dAtA, i, uint64(len(m.P4RTEndpoint)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *AddSwitchRequest) 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 *AddSwitchRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AddSwitchRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ManagementInfo != nil {
		{
			size, err := m.ManagementInfo.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintDiscovery(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if len(m.RackID) > 0 {
		i -= len(m.RackID)
		copy(dAtA[i:], m.RackID)
		i = encodeVarintDiscovery(dAtA, i, uint64(len(m.RackID)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.PodID) > 0 {
		i -= len(m.PodID)
		copy(dAtA[i:], m.PodID)
		i = encodeVarintDiscovery(dAtA, i, uint64(len(m.PodID)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ID) > 0 {
		i -= len(m.ID)
		copy(dAtA[i:], m.ID)
		i = encodeVarintDiscovery(dAtA, i, uint64(len(m.ID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *AddSwitchResponse) 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 *AddSwitchResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AddSwitchResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *AddServerIPURequest) 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 *AddServerIPURequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AddServerIPURequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Links) > 0 {
		for iNdEx := len(m.Links) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Links[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintDiscovery(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x2a
		}
	}
	if m.ManagementInfo != nil {
		{
			size, err := m.ManagementInfo.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintDiscovery(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if len(m.RackID) > 0 {
		i -= len(m.RackID)
		copy(dAtA[i:], m.RackID)
		i = encodeVarintDiscovery(dAtA, i, uint64(len(m.RackID)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.PodID) > 0 {
		i -= len(m.PodID)
		copy(dAtA[i:], m.PodID)
		i = encodeVarintDiscovery(dAtA, i, uint64(len(m.PodID)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ID) > 0 {
		i -= len(m.ID)
		copy(dAtA[i:], m.ID)
		i = encodeVarintDiscovery(dAtA, i, uint64(len(m.ID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *InjectedLink) 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 *InjectedLink) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *InjectedLink) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.RemotePort) > 0 {
		i -= len(m.RemotePort)
		copy(dAtA[i:], m.RemotePort)
		i = encodeVarintDiscovery(dAtA, i, uint64(len(m.RemotePort)))
		i--
		dAtA[i] = 0x12
	}
	if m.Port != 0 {
		i = encodeVarintDiscovery(dAtA, i, uint64(m.Port))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *AddServerIPUResponse) 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 *AddServerIPUResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AddServerIPUResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func encodeVarintDiscovery(dAtA []byte, offset int, v uint64) int {
	offset -= sovDiscovery(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *AddPodRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ID)
	if l > 0 {
		n += 1 + l + sovDiscovery(uint64(l))
	}
	return n
}

func (m *AddPodResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *AddRackRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ID)
	if l > 0 {
		n += 1 + l + sovDiscovery(uint64(l))
	}
	l = len(m.PodID)
	if l > 0 {
		n += 1 + l + sovDiscovery(uint64(l))
	}
	return n
}

func (m *AddRackResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *ManagementInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.P4RTEndpoint)
	if l > 0 {
		n += 1 + l + sovDiscovery(uint64(l))
	}
	l = len(m.GNMIEndpoint)
	if l > 0 {
		n += 1 + l + sovDiscovery(uint64(l))
	}
	l = len(m.PipelineConfigID)
	if l > 0 {
		n += 1 + l + sovDiscovery(uint64(l))
	}
	l = len(m.ChassisConfigID)
	if l > 0 {
		n += 1 + l + sovDiscovery(uint64(l))
	}
	l = len(m.LinkAgentEndpoint)
	if l > 0 {
		n += 1 + l + sovDiscovery(uint64(l))
	}
	l = len(m.HostAgentEndpoint)
	if l > 0 {
		n += 1 + l + sovDiscovery(uint64(l))
	}
	l = len(m.NatAgentEndpoint)
	if l > 0 {
		n += 1 + l + sovDiscovery(uint64(l))
	}
	if m.DeviceID != 0 {
		n += 1 + sovDiscovery(uint64(m.DeviceID))
	}
	l = len(m.Realm)
	if l > 0 {
		n += 1 + l + sovDiscovery(uint64(l))
	}
	l = len(m.Role)
	if l > 0 {
		n += 1 + l + sovDiscovery(uint64(l))
	}
	return n
}

func (m *AddSwitchRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ID)
	if l > 0 {
		n += 1 + l + sovDiscovery(uint64(l))
	}
	l = len(m.PodID)
	if l > 0 {
		n += 1 + l + sovDiscovery(uint64(l))
	}
	l = len(m.RackID)
	if l > 0 {
		n += 1 + l + sovDiscovery(uint64(l))
	}
	if m.ManagementInfo != nil {
		l = m.ManagementInfo.Size()
		n += 1 + l + sovDiscovery(uint64(l))
	}
	return n
}

func (m *AddSwitchResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *AddServerIPURequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ID)
	if l > 0 {
		n += 1 + l + sovDiscovery(uint64(l))
	}
	l = len(m.PodID)
	if l > 0 {
		n += 1 + l + sovDiscovery(uint64(l))
	}
	l = len(m.RackID)
	if l > 0 {
		n += 1 + l + sovDiscovery(uint64(l))
	}
	if m.ManagementInfo != nil {
		l = m.ManagementInfo.Size()
		n += 1 + l + sovDiscovery(uint64(l))
	}
	if len(m.Links) > 0 {
		for _, e := range m.Links {
			l = e.Size()
			n += 1 + l + sovDiscovery(uint64(l))
		}
	}
	return n
}

func (m *InjectedLink) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Port != 0 {
		n += 1 + sovDiscovery(uint64(m.Port))
	}
	l = len(m.RemotePort)
	if l > 0 {
		n += 1 + l + sovDiscovery(uint64(l))
	}
	return n
}

func (m *AddServerIPUResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func sovDiscovery(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozDiscovery(x uint64) (n int) {
	return sovDiscovery(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *AddPodRequest) 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 ErrIntOverflowDiscovery
			}
			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: AddPodRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AddPodRequest: 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 ErrIntOverflowDiscovery
				}
				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 ErrInvalidLengthDiscovery
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDiscovery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDiscovery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthDiscovery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AddPodResponse) 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 ErrIntOverflowDiscovery
			}
			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: AddPodResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AddPodResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipDiscovery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthDiscovery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AddRackRequest) 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 ErrIntOverflowDiscovery
			}
			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: AddRackRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AddRackRequest: 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 ErrIntOverflowDiscovery
				}
				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 ErrInvalidLengthDiscovery
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDiscovery
			}
			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 PodID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDiscovery
				}
				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 ErrInvalidLengthDiscovery
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDiscovery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PodID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDiscovery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthDiscovery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AddRackResponse) 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 ErrIntOverflowDiscovery
			}
			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: AddRackResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AddRackResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipDiscovery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthDiscovery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ManagementInfo) 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 ErrIntOverflowDiscovery
			}
			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: ManagementInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ManagementInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field P4RTEndpoint", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDiscovery
				}
				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 ErrInvalidLengthDiscovery
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDiscovery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.P4RTEndpoint = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GNMIEndpoint", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDiscovery
				}
				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 ErrInvalidLengthDiscovery
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDiscovery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.GNMIEndpoint = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PipelineConfigID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDiscovery
				}
				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 ErrInvalidLengthDiscovery
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDiscovery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PipelineConfigID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChassisConfigID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDiscovery
				}
				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 ErrInvalidLengthDiscovery
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDiscovery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ChassisConfigID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LinkAgentEndpoint", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDiscovery
				}
				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 ErrInvalidLengthDiscovery
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDiscovery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.LinkAgentEndpoint = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field HostAgentEndpoint", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDiscovery
				}
				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 ErrInvalidLengthDiscovery
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDiscovery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.HostAgentEndpoint = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NatAgentEndpoint", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDiscovery
				}
				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 ErrInvalidLengthDiscovery
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDiscovery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NatAgentEndpoint = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DeviceID", wireType)
			}
			m.DeviceID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDiscovery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.DeviceID |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Realm", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDiscovery
				}
				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 ErrInvalidLengthDiscovery
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDiscovery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Realm = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Role", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDiscovery
				}
				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 ErrInvalidLengthDiscovery
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDiscovery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Role = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDiscovery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthDiscovery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AddSwitchRequest) 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 ErrIntOverflowDiscovery
			}
			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: AddSwitchRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AddSwitchRequest: 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 ErrIntOverflowDiscovery
				}
				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 ErrInvalidLengthDiscovery
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDiscovery
			}
			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 PodID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDiscovery
				}
				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 ErrInvalidLengthDiscovery
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDiscovery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PodID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RackID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDiscovery
				}
				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 ErrInvalidLengthDiscovery
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDiscovery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RackID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ManagementInfo", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDiscovery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDiscovery
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDiscovery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ManagementInfo == nil {
				m.ManagementInfo = &ManagementInfo{}
			}
			if err := m.ManagementInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDiscovery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthDiscovery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AddSwitchResponse) 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 ErrIntOverflowDiscovery
			}
			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: AddSwitchResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AddSwitchResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipDiscovery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthDiscovery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AddServerIPURequest) 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 ErrIntOverflowDiscovery
			}
			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: AddServerIPURequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AddServerIPURequest: 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 ErrIntOverflowDiscovery
				}
				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 ErrInvalidLengthDiscovery
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDiscovery
			}
			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 PodID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDiscovery
				}
				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 ErrInvalidLengthDiscovery
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDiscovery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PodID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RackID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDiscovery
				}
				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 ErrInvalidLengthDiscovery
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDiscovery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RackID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ManagementInfo", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDiscovery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDiscovery
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDiscovery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ManagementInfo == nil {
				m.ManagementInfo = &ManagementInfo{}
			}
			if err := m.ManagementInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Links", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDiscovery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDiscovery
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDiscovery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Links = append(m.Links, &InjectedLink{})
			if err := m.Links[len(m.Links)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDiscovery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthDiscovery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *InjectedLink) 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 ErrIntOverflowDiscovery
			}
			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: InjectedLink: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: InjectedLink: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Port", wireType)
			}
			m.Port = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDiscovery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Port |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RemotePort", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDiscovery
				}
				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 ErrInvalidLengthDiscovery
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDiscovery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RemotePort = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDiscovery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthDiscovery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AddServerIPUResponse) 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 ErrIntOverflowDiscovery
			}
			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: AddServerIPUResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AddServerIPUResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipDiscovery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthDiscovery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipDiscovery(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, ErrIntOverflowDiscovery
			}
			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, ErrIntOverflowDiscovery
				}
				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, ErrIntOverflowDiscovery
				}
				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, ErrInvalidLengthDiscovery
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupDiscovery
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthDiscovery
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthDiscovery        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowDiscovery          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupDiscovery = fmt.Errorf("proto: unexpected end of group")
)