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

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

// Package onos.e2t.admin defines the administrative gRPC interfaces.

package admin

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"
)

// 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

// E2NodeConnectionType specifies the type of an E2 connection
type E2NodeConnectionType int32

const (
	E2NodeConnectionType_UNKNOWN E2NodeConnectionType = 0
	E2NodeConnectionType_G_NB    E2NodeConnectionType = 1
	E2NodeConnectionType_E_NB    E2NodeConnectionType = 2
	E2NodeConnectionType_ENG_MB  E2NodeConnectionType = 3
	E2NodeConnectionType_NGE_NB  E2NodeConnectionType = 4
)

var E2NodeConnectionType_name = map[int32]string{
	0: "UNKNOWN",
	1: "G_NB",
	2: "E_NB",
	3: "ENG_MB",
	4: "NGE_NB",
}

var E2NodeConnectionType_value = map[string]int32{
	"UNKNOWN": 0,
	"G_NB":    1,
	"E_NB":    2,
	"ENG_MB":  3,
	"NGE_NB":  4,
}

func (x E2NodeConnectionType) String() string {
	return proto.EnumName(E2NodeConnectionType_name, int32(x))
}

func (E2NodeConnectionType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_3529d62ca467159b, []int{0}
}

// UploadRegisterServiceModelRequest is for streaming a model plugin file to the server.
// There is a built in limit in gRPC of 4MB - plugin is usually around 20MB
// so break in to chunks of approx 1-2MB.
type UploadRegisterServiceModelRequest struct {
	// so_file is the name being streamed.
	SoFile string `protobuf:"bytes,1,opt,name=so_file,json=soFile,proto3" json:"so_file,omitempty"`
	// content is the bytes content.
	Content []byte `protobuf:"bytes,2,opt,name=content,proto3" json:"content,omitempty"`
}

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

var xxx_messageInfo_UploadRegisterServiceModelRequest proto.InternalMessageInfo

func (m *UploadRegisterServiceModelRequest) GetSoFile() string {
	if m != nil {
		return m.SoFile
	}
	return ""
}

func (m *UploadRegisterServiceModelRequest) GetContent() []byte {
	if m != nil {
		return m.Content
	}
	return nil
}

// UploadRegisterServiceModelResponse carries status of model plugin registration.
type UploadRegisterServiceModelResponse struct {
	// name is name of the model plugin.
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// version is the semantic version of the model plugin.
	Version string `protobuf:"bytes,2,opt,name=version,proto3" json:"version,omitempty"`
}

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

var xxx_messageInfo_UploadRegisterServiceModelResponse proto.InternalMessageInfo

func (m *UploadRegisterServiceModelResponse) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *UploadRegisterServiceModelResponse) GetVersion() string {
	if m != nil {
		return m.Version
	}
	return ""
}

// ListRegisteredServiceModelsResponse is general information about a service model plugin.
type ListRegisteredServiceModelsResponse struct {
	// name is the name given to the service model plugin - no spaces and title case.
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// version is the semantic version of the Plugin e.g. 1.0.0.
	Version string `protobuf:"bytes,2,opt,name=version,proto3" json:"version,omitempty"`
}

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

var xxx_messageInfo_ListRegisteredServiceModelsResponse proto.InternalMessageInfo

func (m *ListRegisteredServiceModelsResponse) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *ListRegisteredServiceModelsResponse) GetVersion() string {
	if m != nil {
		return m.Version
	}
	return ""
}

// ListRegisteredServiceModelsRequest carries data for querying registered service model plugins.
type ListRegisteredServiceModelsRequest struct {
	// An optional filter on the name of the model plugins to list.
	ModelName string `protobuf:"bytes,1,opt,name=model_name,json=modelName,proto3" json:"model_name,omitempty"`
	// An optional filter on the version of the model plugins to list
	ModelVersion string `protobuf:"bytes,2,opt,name=model_version,json=modelVersion,proto3" json:"model_version,omitempty"`
}

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

var xxx_messageInfo_ListRegisteredServiceModelsRequest proto.InternalMessageInfo

func (m *ListRegisteredServiceModelsRequest) GetModelName() string {
	if m != nil {
		return m.ModelName
	}
	return ""
}

func (m *ListRegisteredServiceModelsRequest) GetModelVersion() string {
	if m != nil {
		return m.ModelVersion
	}
	return ""
}

// ListE2NodeConnectionsRequest carries request for a list of E2 node SCTP connections.
type ListE2NodeConnectionsRequest struct {
}

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

var xxx_messageInfo_ListE2NodeConnectionsRequest proto.InternalMessageInfo

type RANFunction struct {
	Oid           string `protobuf:"bytes,1,opt,name=oid,proto3" json:"oid,omitempty"`
	RanFunctionId string `protobuf:"bytes,2,opt,name=ran_function_id,json=ranFunctionId,proto3" json:"ran_function_id,omitempty"`
	Description   []byte `protobuf:"bytes,3,opt,name=description,proto3" json:"description,omitempty"`
}

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

var xxx_messageInfo_RANFunction proto.InternalMessageInfo

func (m *RANFunction) GetOid() string {
	if m != nil {
		return m.Oid
	}
	return ""
}

func (m *RANFunction) GetRanFunctionId() string {
	if m != nil {
		return m.RanFunctionId
	}
	return ""
}

func (m *RANFunction) GetDescription() []byte {
	if m != nil {
		return m.Description
	}
	return nil
}

// ListE2NodeConnectionsResponse carries information about the SCTP connection to the remote E2 node.
type ListE2NodeConnectionsResponse struct {
	Id             string               `protobuf:"bytes,3,opt,name=id,proto3" json:"id,omitempty"`
	RemoteIp       []string             `protobuf:"bytes,1,rep,name=remote_ip,json=remoteIp,proto3" json:"remote_ip,omitempty"`
	RemotePort     uint32               `protobuf:"varint,2,opt,name=remote_port,json=remotePort,proto3" json:"remote_port,omitempty"`
	NodeId         string               `protobuf:"bytes,7,opt,name=node_id,json=nodeId,proto3" json:"node_id,omitempty"`
	PlmnId         string               `protobuf:"bytes,4,opt,name=plmn_id,json=plmnId,proto3" json:"plmn_id,omitempty"`
	ConnectionType E2NodeConnectionType `protobuf:"varint,5,opt,name=connection_type,json=connectionType,proto3,enum=onos.e2t.admin.E2NodeConnectionType" json:"connection_type,omitempty"`
	RanFunctions   []*RANFunction       `protobuf:"bytes,6,rep,name=ran_functions,json=ranFunctions,proto3" json:"ran_functions,omitempty"`
	AgeMs          int32                `protobuf:"varint,8,opt,name=age_ms,json=ageMs,proto3" json:"age_ms,omitempty"`
}

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

var xxx_messageInfo_ListE2NodeConnectionsResponse proto.InternalMessageInfo

func (m *ListE2NodeConnectionsResponse) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *ListE2NodeConnectionsResponse) GetRemoteIp() []string {
	if m != nil {
		return m.RemoteIp
	}
	return nil
}

func (m *ListE2NodeConnectionsResponse) GetRemotePort() uint32 {
	if m != nil {
		return m.RemotePort
	}
	return 0
}

func (m *ListE2NodeConnectionsResponse) GetNodeId() string {
	if m != nil {
		return m.NodeId
	}
	return ""
}

func (m *ListE2NodeConnectionsResponse) GetPlmnId() string {
	if m != nil {
		return m.PlmnId
	}
	return ""
}

func (m *ListE2NodeConnectionsResponse) GetConnectionType() E2NodeConnectionType {
	if m != nil {
		return m.ConnectionType
	}
	return E2NodeConnectionType_UNKNOWN
}

func (m *ListE2NodeConnectionsResponse) GetRanFunctions() []*RANFunction {
	if m != nil {
		return m.RanFunctions
	}
	return nil
}

func (m *ListE2NodeConnectionsResponse) GetAgeMs() int32 {
	if m != nil {
		return m.AgeMs
	}
	return 0
}

// DropE2NodeConnectionsRequest carries drop connection request
type DropE2NodeConnectionsRequest struct {
	Connections []*ListE2NodeConnectionsResponse `protobuf:"bytes,1,rep,name=connections,proto3" json:"connections,omitempty"`
}

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

var xxx_messageInfo_DropE2NodeConnectionsRequest proto.InternalMessageInfo

func (m *DropE2NodeConnectionsRequest) GetConnections() []*ListE2NodeConnectionsResponse {
	if m != nil {
		return m.Connections
	}
	return nil
}

// DropE2NodeConnectionsResponse carries drop connection response
type DropE2NodeConnectionsResponse struct {
	Success []bool `protobuf:"varint,1,rep,packed,name=success,proto3" json:"success,omitempty"`
}

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

var xxx_messageInfo_DropE2NodeConnectionsResponse proto.InternalMessageInfo

func (m *DropE2NodeConnectionsResponse) GetSuccess() []bool {
	if m != nil {
		return m.Success
	}
	return nil
}

func init() {
	proto.RegisterEnum("onos.e2t.admin.E2NodeConnectionType", E2NodeConnectionType_name, E2NodeConnectionType_value)
	proto.RegisterType((*UploadRegisterServiceModelRequest)(nil), "onos.e2t.admin.UploadRegisterServiceModelRequest")
	proto.RegisterType((*UploadRegisterServiceModelResponse)(nil), "onos.e2t.admin.UploadRegisterServiceModelResponse")
	proto.RegisterType((*ListRegisteredServiceModelsResponse)(nil), "onos.e2t.admin.ListRegisteredServiceModelsResponse")
	proto.RegisterType((*ListRegisteredServiceModelsRequest)(nil), "onos.e2t.admin.ListRegisteredServiceModelsRequest")
	proto.RegisterType((*ListE2NodeConnectionsRequest)(nil), "onos.e2t.admin.ListE2NodeConnectionsRequest")
	proto.RegisterType((*RANFunction)(nil), "onos.e2t.admin.RANFunction")
	proto.RegisterType((*ListE2NodeConnectionsResponse)(nil), "onos.e2t.admin.ListE2NodeConnectionsResponse")
	proto.RegisterType((*DropE2NodeConnectionsRequest)(nil), "onos.e2t.admin.DropE2NodeConnectionsRequest")
	proto.RegisterType((*DropE2NodeConnectionsResponse)(nil), "onos.e2t.admin.DropE2NodeConnectionsResponse")
}

func init() { proto.RegisterFile("onos/e2t/admin/admin.proto", fileDescriptor_3529d62ca467159b) }

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

// E2TAdminServiceClient is the client API for E2TAdminService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type E2TAdminServiceClient interface {
	// UploadRegisterServiceModel uploads and adds the model plugin to the list of supported models.
	// The file is serialized in to Chunks of less than 4MB so as not to break the
	// gRPC byte array limit
	UploadRegisterServiceModel(ctx context.Context, opts ...grpc.CallOption) (E2TAdminService_UploadRegisterServiceModelClient, error)
	// ListRegisteredServiceModels returns a stream of registered service models.
	ListRegisteredServiceModels(ctx context.Context, in *ListRegisteredServiceModelsRequest, opts ...grpc.CallOption) (E2TAdminService_ListRegisteredServiceModelsClient, error)
	// ListE2NodeConnections returns a stream of existing SCTP connections.
	ListE2NodeConnections(ctx context.Context, in *ListE2NodeConnectionsRequest, opts ...grpc.CallOption) (E2TAdminService_ListE2NodeConnectionsClient, error)
	// DropE2NodeConnections drops the specified E2 node SCTP connections
	DropE2NodeConnections(ctx context.Context, in *DropE2NodeConnectionsRequest, opts ...grpc.CallOption) (*DropE2NodeConnectionsResponse, error)
}

type e2TAdminServiceClient struct {
	cc *grpc.ClientConn
}

func NewE2TAdminServiceClient(cc *grpc.ClientConn) E2TAdminServiceClient {
	return &e2TAdminServiceClient{cc}
}

func (c *e2TAdminServiceClient) UploadRegisterServiceModel(ctx context.Context, opts ...grpc.CallOption) (E2TAdminService_UploadRegisterServiceModelClient, error) {
	stream, err := c.cc.NewStream(ctx, &_E2TAdminService_serviceDesc.Streams[0], "/onos.e2t.admin.E2TAdminService/UploadRegisterServiceModel", opts...)
	if err != nil {
		return nil, err
	}
	x := &e2TAdminServiceUploadRegisterServiceModelClient{stream}
	return x, nil
}

type E2TAdminService_UploadRegisterServiceModelClient interface {
	Send(*UploadRegisterServiceModelRequest) error
	CloseAndRecv() (*UploadRegisterServiceModelResponse, error)
	grpc.ClientStream
}

type e2TAdminServiceUploadRegisterServiceModelClient struct {
	grpc.ClientStream
}

func (x *e2TAdminServiceUploadRegisterServiceModelClient) Send(m *UploadRegisterServiceModelRequest) error {
	return x.ClientStream.SendMsg(m)
}

func (x *e2TAdminServiceUploadRegisterServiceModelClient) CloseAndRecv() (*UploadRegisterServiceModelResponse, error) {
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	m := new(UploadRegisterServiceModelResponse)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *e2TAdminServiceClient) ListRegisteredServiceModels(ctx context.Context, in *ListRegisteredServiceModelsRequest, opts ...grpc.CallOption) (E2TAdminService_ListRegisteredServiceModelsClient, error) {
	stream, err := c.cc.NewStream(ctx, &_E2TAdminService_serviceDesc.Streams[1], "/onos.e2t.admin.E2TAdminService/ListRegisteredServiceModels", opts...)
	if err != nil {
		return nil, err
	}
	x := &e2TAdminServiceListRegisteredServiceModelsClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type E2TAdminService_ListRegisteredServiceModelsClient interface {
	Recv() (*ListRegisteredServiceModelsResponse, error)
	grpc.ClientStream
}

type e2TAdminServiceListRegisteredServiceModelsClient struct {
	grpc.ClientStream
}

func (x *e2TAdminServiceListRegisteredServiceModelsClient) Recv() (*ListRegisteredServiceModelsResponse, error) {
	m := new(ListRegisteredServiceModelsResponse)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *e2TAdminServiceClient) ListE2NodeConnections(ctx context.Context, in *ListE2NodeConnectionsRequest, opts ...grpc.CallOption) (E2TAdminService_ListE2NodeConnectionsClient, error) {
	stream, err := c.cc.NewStream(ctx, &_E2TAdminService_serviceDesc.Streams[2], "/onos.e2t.admin.E2TAdminService/ListE2NodeConnections", opts...)
	if err != nil {
		return nil, err
	}
	x := &e2TAdminServiceListE2NodeConnectionsClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type E2TAdminService_ListE2NodeConnectionsClient interface {
	Recv() (*ListE2NodeConnectionsResponse, error)
	grpc.ClientStream
}

type e2TAdminServiceListE2NodeConnectionsClient struct {
	grpc.ClientStream
}

func (x *e2TAdminServiceListE2NodeConnectionsClient) Recv() (*ListE2NodeConnectionsResponse, error) {
	m := new(ListE2NodeConnectionsResponse)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *e2TAdminServiceClient) DropE2NodeConnections(ctx context.Context, in *DropE2NodeConnectionsRequest, opts ...grpc.CallOption) (*DropE2NodeConnectionsResponse, error) {
	out := new(DropE2NodeConnectionsResponse)
	err := c.cc.Invoke(ctx, "/onos.e2t.admin.E2TAdminService/DropE2NodeConnections", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// E2TAdminServiceServer is the server API for E2TAdminService service.
type E2TAdminServiceServer interface {
	// UploadRegisterServiceModel uploads and adds the model plugin to the list of supported models.
	// The file is serialized in to Chunks of less than 4MB so as not to break the
	// gRPC byte array limit
	UploadRegisterServiceModel(E2TAdminService_UploadRegisterServiceModelServer) error
	// ListRegisteredServiceModels returns a stream of registered service models.
	ListRegisteredServiceModels(*ListRegisteredServiceModelsRequest, E2TAdminService_ListRegisteredServiceModelsServer) error
	// ListE2NodeConnections returns a stream of existing SCTP connections.
	ListE2NodeConnections(*ListE2NodeConnectionsRequest, E2TAdminService_ListE2NodeConnectionsServer) error
	// DropE2NodeConnections drops the specified E2 node SCTP connections
	DropE2NodeConnections(context.Context, *DropE2NodeConnectionsRequest) (*DropE2NodeConnectionsResponse, error)
}

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

func (*UnimplementedE2TAdminServiceServer) UploadRegisterServiceModel(srv E2TAdminService_UploadRegisterServiceModelServer) error {
	return status.Errorf(codes.Unimplemented, "method UploadRegisterServiceModel not implemented")
}
func (*UnimplementedE2TAdminServiceServer) ListRegisteredServiceModels(req *ListRegisteredServiceModelsRequest, srv E2TAdminService_ListRegisteredServiceModelsServer) error {
	return status.Errorf(codes.Unimplemented, "method ListRegisteredServiceModels not implemented")
}
func (*UnimplementedE2TAdminServiceServer) ListE2NodeConnections(req *ListE2NodeConnectionsRequest, srv E2TAdminService_ListE2NodeConnectionsServer) error {
	return status.Errorf(codes.Unimplemented, "method ListE2NodeConnections not implemented")
}
func (*UnimplementedE2TAdminServiceServer) DropE2NodeConnections(ctx context.Context, req *DropE2NodeConnectionsRequest) (*DropE2NodeConnectionsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DropE2NodeConnections not implemented")
}

func RegisterE2TAdminServiceServer(s *grpc.Server, srv E2TAdminServiceServer) {
	s.RegisterService(&_E2TAdminService_serviceDesc, srv)
}

func _E2TAdminService_UploadRegisterServiceModel_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(E2TAdminServiceServer).UploadRegisterServiceModel(&e2TAdminServiceUploadRegisterServiceModelServer{stream})
}

type E2TAdminService_UploadRegisterServiceModelServer interface {
	SendAndClose(*UploadRegisterServiceModelResponse) error
	Recv() (*UploadRegisterServiceModelRequest, error)
	grpc.ServerStream
}

type e2TAdminServiceUploadRegisterServiceModelServer struct {
	grpc.ServerStream
}

func (x *e2TAdminServiceUploadRegisterServiceModelServer) SendAndClose(m *UploadRegisterServiceModelResponse) error {
	return x.ServerStream.SendMsg(m)
}

func (x *e2TAdminServiceUploadRegisterServiceModelServer) Recv() (*UploadRegisterServiceModelRequest, error) {
	m := new(UploadRegisterServiceModelRequest)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func _E2TAdminService_ListRegisteredServiceModels_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(ListRegisteredServiceModelsRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(E2TAdminServiceServer).ListRegisteredServiceModels(m, &e2TAdminServiceListRegisteredServiceModelsServer{stream})
}

type E2TAdminService_ListRegisteredServiceModelsServer interface {
	Send(*ListRegisteredServiceModelsResponse) error
	grpc.ServerStream
}

type e2TAdminServiceListRegisteredServiceModelsServer struct {
	grpc.ServerStream
}

func (x *e2TAdminServiceListRegisteredServiceModelsServer) Send(m *ListRegisteredServiceModelsResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _E2TAdminService_ListE2NodeConnections_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(ListE2NodeConnectionsRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(E2TAdminServiceServer).ListE2NodeConnections(m, &e2TAdminServiceListE2NodeConnectionsServer{stream})
}

type E2TAdminService_ListE2NodeConnectionsServer interface {
	Send(*ListE2NodeConnectionsResponse) error
	grpc.ServerStream
}

type e2TAdminServiceListE2NodeConnectionsServer struct {
	grpc.ServerStream
}

func (x *e2TAdminServiceListE2NodeConnectionsServer) Send(m *ListE2NodeConnectionsResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _E2TAdminService_DropE2NodeConnections_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DropE2NodeConnectionsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(E2TAdminServiceServer).DropE2NodeConnections(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/onos.e2t.admin.E2TAdminService/DropE2NodeConnections",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(E2TAdminServiceServer).DropE2NodeConnections(ctx, req.(*DropE2NodeConnectionsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _E2TAdminService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "onos.e2t.admin.E2TAdminService",
	HandlerType: (*E2TAdminServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "DropE2NodeConnections",
			Handler:    _E2TAdminService_DropE2NodeConnections_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "UploadRegisterServiceModel",
			Handler:       _E2TAdminService_UploadRegisterServiceModel_Handler,
			ClientStreams: true,
		},
		{
			StreamName:    "ListRegisteredServiceModels",
			Handler:       _E2TAdminService_ListRegisteredServiceModels_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "ListE2NodeConnections",
			Handler:       _E2TAdminService_ListE2NodeConnections_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "onos/e2t/admin/admin.proto",
}

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

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

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

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

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

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

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

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

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

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

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

func (m *RANFunction) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintAdmin(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.RanFunctionId) > 0 {
		i -= len(m.RanFunctionId)
		copy(dAtA[i:], m.RanFunctionId)
		i = encodeVarintAdmin(dAtA, i, uint64(len(m.RanFunctionId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Oid) > 0 {
		i -= len(m.Oid)
		copy(dAtA[i:], m.Oid)
		i = encodeVarintAdmin(dAtA, i, uint64(len(m.Oid)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *ListE2NodeConnectionsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.AgeMs != 0 {
		i = encodeVarintAdmin(dAtA, i, uint64(m.AgeMs))
		i--
		dAtA[i] = 0x40
	}
	if len(m.NodeId) > 0 {
		i -= len(m.NodeId)
		copy(dAtA[i:], m.NodeId)
		i = encodeVarintAdmin(dAtA, i, uint64(len(m.NodeId)))
		i--
		dAtA[i] = 0x3a
	}
	if len(m.RanFunctions) > 0 {
		for iNdEx := len(m.RanFunctions) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.RanFunctions[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintAdmin(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x32
		}
	}
	if m.ConnectionType != 0 {
		i = encodeVarintAdmin(dAtA, i, uint64(m.ConnectionType))
		i--
		dAtA[i] = 0x28
	}
	if len(m.PlmnId) > 0 {
		i -= len(m.PlmnId)
		copy(dAtA[i:], m.PlmnId)
		i = encodeVarintAdmin(dAtA, i, uint64(len(m.PlmnId)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintAdmin(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0x1a
	}
	if m.RemotePort != 0 {
		i = encodeVarintAdmin(dAtA, i, uint64(m.RemotePort))
		i--
		dAtA[i] = 0x10
	}
	if len(m.RemoteIp) > 0 {
		for iNdEx := len(m.RemoteIp) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.RemoteIp[iNdEx])
			copy(dAtA[i:], m.RemoteIp[iNdEx])
			i = encodeVarintAdmin(dAtA, i, uint64(len(m.RemoteIp[iNdEx])))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *DropE2NodeConnectionsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Success) > 0 {
		for iNdEx := len(m.Success) - 1; iNdEx >= 0; iNdEx-- {
			i--
			if m.Success[iNdEx] {
				dAtA[i] = 1
			} else {
				dAtA[i] = 0
			}
		}
		i = encodeVarintAdmin(dAtA, i, uint64(len(m.Success)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *UploadRegisterServiceModelResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovAdmin(uint64(l))
	}
	l = len(m.Version)
	if l > 0 {
		n += 1 + l + sovAdmin(uint64(l))
	}
	return n
}

func (m *ListRegisteredServiceModelsResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovAdmin(uint64(l))
	}
	l = len(m.Version)
	if l > 0 {
		n += 1 + l + sovAdmin(uint64(l))
	}
	return n
}

func (m *ListRegisteredServiceModelsRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ModelName)
	if l > 0 {
		n += 1 + l + sovAdmin(uint64(l))
	}
	l = len(m.ModelVersion)
	if l > 0 {
		n += 1 + l + sovAdmin(uint64(l))
	}
	return n
}

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

func (m *RANFunction) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Oid)
	if l > 0 {
		n += 1 + l + sovAdmin(uint64(l))
	}
	l = len(m.RanFunctionId)
	if l > 0 {
		n += 1 + l + sovAdmin(uint64(l))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovAdmin(uint64(l))
	}
	return n
}

func (m *ListE2NodeConnectionsResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.RemoteIp) > 0 {
		for _, s := range m.RemoteIp {
			l = len(s)
			n += 1 + l + sovAdmin(uint64(l))
		}
	}
	if m.RemotePort != 0 {
		n += 1 + sovAdmin(uint64(m.RemotePort))
	}
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovAdmin(uint64(l))
	}
	l = len(m.PlmnId)
	if l > 0 {
		n += 1 + l + sovAdmin(uint64(l))
	}
	if m.ConnectionType != 0 {
		n += 1 + sovAdmin(uint64(m.ConnectionType))
	}
	if len(m.RanFunctions) > 0 {
		for _, e := range m.RanFunctions {
			l = e.Size()
			n += 1 + l + sovAdmin(uint64(l))
		}
	}
	l = len(m.NodeId)
	if l > 0 {
		n += 1 + l + sovAdmin(uint64(l))
	}
	if m.AgeMs != 0 {
		n += 1 + sovAdmin(uint64(m.AgeMs))
	}
	return n
}

func (m *DropE2NodeConnectionsRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Connections) > 0 {
		for _, e := range m.Connections {
			l = e.Size()
			n += 1 + l + sovAdmin(uint64(l))
		}
	}
	return n
}

func (m *DropE2NodeConnectionsResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Success) > 0 {
		n += 1 + sovAdmin(uint64(len(m.Success))) + len(m.Success)*1
	}
	return n
}

func sovAdmin(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozAdmin(x uint64) (n int) {
	return sovAdmin(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *UploadRegisterServiceModelRequest) 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 ErrIntOverflowAdmin
			}
			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: UploadRegisterServiceModelRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UploadRegisterServiceModelRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SoFile", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAdmin
				}
				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 ErrInvalidLengthAdmin
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAdmin
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SoFile = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Content", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAdmin
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthAdmin
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthAdmin
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Content = append(m.Content[:0], dAtA[iNdEx:postIndex]...)
			if m.Content == nil {
				m.Content = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAdmin(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAdmin
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

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

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ListE2NodeConnectionsResponse) 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 ErrIntOverflowAdmin
			}
			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: ListE2NodeConnectionsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ListE2NodeConnectionsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RemoteIp", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAdmin
				}
				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 ErrInvalidLengthAdmin
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAdmin
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RemoteIp = append(m.RemoteIp, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RemotePort", wireType)
			}
			m.RemotePort = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAdmin
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RemotePort |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			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 ErrIntOverflowAdmin
				}
				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 ErrInvalidLengthAdmin
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAdmin
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Id = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PlmnId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAdmin
				}
				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 ErrInvalidLengthAdmin
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAdmin
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PlmnId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ConnectionType", wireType)
			}
			m.ConnectionType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAdmin
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ConnectionType |= E2NodeConnectionType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RanFunctions", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAdmin
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAdmin
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAdmin
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RanFunctions = append(m.RanFunctions, &RANFunction{})
			if err := m.RanFunctions[len(m.RanFunctions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NodeId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAdmin
				}
				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 ErrInvalidLengthAdmin
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAdmin
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NodeId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AgeMs", wireType)
			}
			m.AgeMs = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAdmin
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.AgeMs |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipAdmin(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAdmin
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DropE2NodeConnectionsRequest) 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 ErrIntOverflowAdmin
			}
			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: DropE2NodeConnectionsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DropE2NodeConnectionsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Connections", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAdmin
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAdmin
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAdmin
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Connections = append(m.Connections, &ListE2NodeConnectionsResponse{})
			if err := m.Connections[len(m.Connections)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAdmin(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAdmin
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DropE2NodeConnectionsResponse) 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 ErrIntOverflowAdmin
			}
			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: DropE2NodeConnectionsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DropE2NodeConnectionsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType == 0 {
				var v int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowAdmin
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.Success = append(m.Success, bool(v != 0))
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowAdmin
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthAdmin
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthAdmin
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				elementCount = packedLen
				if elementCount != 0 && len(m.Success) == 0 {
					m.Success = make([]bool, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowAdmin
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.Success = append(m.Success, bool(v != 0))
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field Success", wireType)
			}
		default:
			iNdEx = preIndex
			skippy, err := skipAdmin(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAdmin
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

var (
	ErrInvalidLengthAdmin        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowAdmin          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupAdmin = fmt.Errorf("proto: unexpected end of group")
)