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

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

package model

import (
	context "context"
	fmt "fmt"
	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	github_com_onosproject_onos_api_go_onos_ransim_types "github.com/onosproject/onos-api/go/onos/ransim/types"
	types "github.com/onosproject/onos-api/go/onos/ransim/types"
	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

// Change event type
type EventType int32

const (
	// NONE indicates this response represents a pre-existing entity
	EventType_NONE EventType = 0
	// CREATED indicates a new entity was created
	EventType_CREATED EventType = 1
	// UPDATED indicates an existing entity was updated
	EventType_UPDATED EventType = 2
	// DELETED indicates an entity was deleted
	EventType_DELETED EventType = 3
)

var EventType_name = map[int32]string{
	0: "NONE",
	1: "CREATED",
	2: "UPDATED",
	3: "DELETED",
}

var EventType_value = map[string]int32{
	"NONE":    0,
	"CREATED": 1,
	"UPDATED": 2,
	"DELETED": 3,
}

func (x EventType) String() string {
	return proto.EnumName(EventType_name, int32(x))
}

func (EventType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_9942ba2f94296ec8, []int{0}
}

type DataSet struct {
	Type string `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"`
	Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
}

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

var xxx_messageInfo_DataSet proto.InternalMessageInfo

func (m *DataSet) GetType() string {
	if m != nil {
		return m.Type
	}
	return ""
}

func (m *DataSet) GetData() []byte {
	if m != nil {
		return m.Data
	}
	return nil
}

type LoadRequest struct {
	DataSet []*DataSet `protobuf:"bytes,1,rep,name=dataSet,proto3" json:"dataSet,omitempty"`
	Resume  bool       `protobuf:"varint,2,opt,name=resume,proto3" json:"resume,omitempty"`
}

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

var xxx_messageInfo_LoadRequest proto.InternalMessageInfo

func (m *LoadRequest) GetDataSet() []*DataSet {
	if m != nil {
		return m.DataSet
	}
	return nil
}

func (m *LoadRequest) GetResume() bool {
	if m != nil {
		return m.Resume
	}
	return false
}

type LoadResponse struct {
}

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

var xxx_messageInfo_LoadResponse proto.InternalMessageInfo

type ClearRequest struct {
	Resume bool `protobuf:"varint,1,opt,name=resume,proto3" json:"resume,omitempty"`
}

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

var xxx_messageInfo_ClearRequest proto.InternalMessageInfo

func (m *ClearRequest) GetResume() bool {
	if m != nil {
		return m.Resume
	}
	return false
}

type ClearResponse struct {
}

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

var xxx_messageInfo_ClearResponse proto.InternalMessageInfo

type PlmnIDRequest struct {
}

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

var xxx_messageInfo_PlmnIDRequest proto.InternalMessageInfo

type PlmnIDResponse struct {
	PlmnID github_com_onosproject_onos_api_go_onos_ransim_types.PlmnID `protobuf:"varint,1,opt,name=plmnid,proto3,casttype=github.com/onosproject/onos-api/go/onos/ransim/types.PlmnID" json:"plmnid,omitempty"`
}

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

var xxx_messageInfo_PlmnIDResponse proto.InternalMessageInfo

func (m *PlmnIDResponse) GetPlmnID() github_com_onosproject_onos_api_go_onos_ransim_types.PlmnID {
	if m != nil {
		return m.PlmnID
	}
	return 0
}

// CreateNodeRequest create a node request
type CreateNodeRequest struct {
	Node *types.Node `protobuf:"bytes,1,opt,name=node,proto3" json:"node,omitempty"`
}

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

var xxx_messageInfo_CreateNodeRequest proto.InternalMessageInfo

func (m *CreateNodeRequest) GetNode() *types.Node {
	if m != nil {
		return m.Node
	}
	return nil
}

// CreateNodeResponse create a node response
type CreateNodeResponse struct {
}

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

var xxx_messageInfo_CreateNodeResponse proto.InternalMessageInfo

// GetNodeRequest get a node request
type GetNodeRequest struct {
	GnbID github_com_onosproject_onos_api_go_onos_ransim_types.GnbID `protobuf:"varint,1,opt,name=enbid,proto3,casttype=github.com/onosproject/onos-api/go/onos/ransim/types.GnbID" json:"enbid,omitempty"`
}

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

var xxx_messageInfo_GetNodeRequest proto.InternalMessageInfo

func (m *GetNodeRequest) GetGnbID() github_com_onosproject_onos_api_go_onos_ransim_types.GnbID {
	if m != nil {
		return m.GnbID
	}
	return 0
}

// GetNodeResponse get a node response
type GetNodeResponse struct {
	Node *types.Node `protobuf:"bytes,1,opt,name=node,proto3" json:"node,omitempty"`
}

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

var xxx_messageInfo_GetNodeResponse proto.InternalMessageInfo

func (m *GetNodeResponse) GetNode() *types.Node {
	if m != nil {
		return m.Node
	}
	return nil
}

// UpdateNodeRequest update a node request
type UpdateNodeRequest struct {
	Node *types.Node `protobuf:"bytes,1,opt,name=node,proto3" json:"node,omitempty"`
}

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

var xxx_messageInfo_UpdateNodeRequest proto.InternalMessageInfo

func (m *UpdateNodeRequest) GetNode() *types.Node {
	if m != nil {
		return m.Node
	}
	return nil
}

// UpdateNodeResponse update a node response
type UpdateNodeResponse struct {
}

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

var xxx_messageInfo_UpdateNodeResponse proto.InternalMessageInfo

// DeleteNodeRequest delete a node request
type DeleteNodeRequest struct {
	GnbID github_com_onosproject_onos_api_go_onos_ransim_types.GnbID `protobuf:"varint,1,opt,name=enbid,proto3,casttype=github.com/onosproject/onos-api/go/onos/ransim/types.GnbID" json:"enbid,omitempty"`
}

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

var xxx_messageInfo_DeleteNodeRequest proto.InternalMessageInfo

func (m *DeleteNodeRequest) GetGnbID() github_com_onosproject_onos_api_go_onos_ransim_types.GnbID {
	if m != nil {
		return m.GnbID
	}
	return 0
}

// DeleteNodeResponse delete a node response
type DeleteNodeResponse struct {
}

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

var xxx_messageInfo_DeleteNodeResponse proto.InternalMessageInfo

type ListNodesRequest struct {
}

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

var xxx_messageInfo_ListNodesRequest proto.InternalMessageInfo

type ListNodesResponse struct {
	Node *types.Node `protobuf:"bytes,1,opt,name=node,proto3" json:"node,omitempty"`
}

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

var xxx_messageInfo_ListNodesResponse proto.InternalMessageInfo

func (m *ListNodesResponse) GetNode() *types.Node {
	if m != nil {
		return m.Node
	}
	return nil
}

type WatchNodesRequest struct {
	NoReplay    bool `protobuf:"varint,1,opt,name=no_replay,json=noReplay,proto3" json:"no_replay,omitempty"`
	NoSubscribe bool `protobuf:"varint,2,opt,name=no_subscribe,json=noSubscribe,proto3" json:"no_subscribe,omitempty"`
}

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

var xxx_messageInfo_WatchNodesRequest proto.InternalMessageInfo

func (m *WatchNodesRequest) GetNoReplay() bool {
	if m != nil {
		return m.NoReplay
	}
	return false
}

func (m *WatchNodesRequest) GetNoSubscribe() bool {
	if m != nil {
		return m.NoSubscribe
	}
	return false
}

type WatchNodesResponse struct {
	Node *types.Node `protobuf:"bytes,1,opt,name=node,proto3" json:"node,omitempty"`
	Type EventType   `protobuf:"varint,2,opt,name=type,proto3,enum=onos.ransim.model.EventType" json:"type,omitempty"`
}

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

var xxx_messageInfo_WatchNodesResponse proto.InternalMessageInfo

func (m *WatchNodesResponse) GetNode() *types.Node {
	if m != nil {
		return m.Node
	}
	return nil
}

func (m *WatchNodesResponse) GetType() EventType {
	if m != nil {
		return m.Type
	}
	return EventType_NONE
}

type AgentControlRequest struct {
	GnbID   github_com_onosproject_onos_api_go_onos_ransim_types.GnbID `protobuf:"varint,1,opt,name=enbid,proto3,casttype=github.com/onosproject/onos-api/go/onos/ransim/types.GnbID" json:"enbid,omitempty"`
	Command string                                                     `protobuf:"bytes,2,opt,name=command,proto3" json:"command,omitempty"`
	Args    []string                                                   `protobuf:"bytes,3,rep,name=args,proto3" json:"args,omitempty"`
}

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

var xxx_messageInfo_AgentControlRequest proto.InternalMessageInfo

func (m *AgentControlRequest) GetGnbID() github_com_onosproject_onos_api_go_onos_ransim_types.GnbID {
	if m != nil {
		return m.GnbID
	}
	return 0
}

func (m *AgentControlRequest) GetCommand() string {
	if m != nil {
		return m.Command
	}
	return ""
}

func (m *AgentControlRequest) GetArgs() []string {
	if m != nil {
		return m.Args
	}
	return nil
}

type AgentControlResponse struct {
	Node *types.Node `protobuf:"bytes,1,opt,name=node,proto3" json:"node,omitempty"`
}

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

var xxx_messageInfo_AgentControlResponse proto.InternalMessageInfo

func (m *AgentControlResponse) GetNode() *types.Node {
	if m != nil {
		return m.Node
	}
	return nil
}

type CreateCellRequest struct {
	Cell *types.Cell `protobuf:"bytes,1,opt,name=cell,proto3" json:"cell,omitempty"`
}

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

var xxx_messageInfo_CreateCellRequest proto.InternalMessageInfo

func (m *CreateCellRequest) GetCell() *types.Cell {
	if m != nil {
		return m.Cell
	}
	return nil
}

type CreateCellResponse struct {
}

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

var xxx_messageInfo_CreateCellResponse proto.InternalMessageInfo

type GetCellRequest struct {
	NCGI github_com_onosproject_onos_api_go_onos_ransim_types.NCGI `protobuf:"varint,1,opt,name=ecgi,proto3,casttype=github.com/onosproject/onos-api/go/onos/ransim/types.NCGI" json:"ecgi,omitempty"`
}

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

var xxx_messageInfo_GetCellRequest proto.InternalMessageInfo

func (m *GetCellRequest) GetNCGI() github_com_onosproject_onos_api_go_onos_ransim_types.NCGI {
	if m != nil {
		return m.NCGI
	}
	return 0
}

type GetCellResponse struct {
	Cell *types.Cell `protobuf:"bytes,1,opt,name=cell,proto3" json:"cell,omitempty"`
}

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

var xxx_messageInfo_GetCellResponse proto.InternalMessageInfo

func (m *GetCellResponse) GetCell() *types.Cell {
	if m != nil {
		return m.Cell
	}
	return nil
}

type UpdateCellRequest struct {
	Cell *types.Cell `protobuf:"bytes,1,opt,name=cell,proto3" json:"cell,omitempty"`
}

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

var xxx_messageInfo_UpdateCellRequest proto.InternalMessageInfo

func (m *UpdateCellRequest) GetCell() *types.Cell {
	if m != nil {
		return m.Cell
	}
	return nil
}

type UpdateCellResponse struct {
}

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

var xxx_messageInfo_UpdateCellResponse proto.InternalMessageInfo

type DeleteCellRequest struct {
	NCGI github_com_onosproject_onos_api_go_onos_ransim_types.NCGI `protobuf:"varint,1,opt,name=enbid,proto3,casttype=github.com/onosproject/onos-api/go/onos/ransim/types.NCGI" json:"enbid,omitempty"`
}

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

var xxx_messageInfo_DeleteCellRequest proto.InternalMessageInfo

func (m *DeleteCellRequest) GetNCGI() github_com_onosproject_onos_api_go_onos_ransim_types.NCGI {
	if m != nil {
		return m.NCGI
	}
	return 0
}

type DeleteCellResponse struct {
}

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

var xxx_messageInfo_DeleteCellResponse proto.InternalMessageInfo

type WatchCellsRequest struct {
	NoReplay    bool `protobuf:"varint,1,opt,name=no_replay,json=noReplay,proto3" json:"no_replay,omitempty"`
	NoSubscribe bool `protobuf:"varint,2,opt,name=no_subscribe,json=noSubscribe,proto3" json:"no_subscribe,omitempty"`
}

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

var xxx_messageInfo_WatchCellsRequest proto.InternalMessageInfo

func (m *WatchCellsRequest) GetNoReplay() bool {
	if m != nil {
		return m.NoReplay
	}
	return false
}

func (m *WatchCellsRequest) GetNoSubscribe() bool {
	if m != nil {
		return m.NoSubscribe
	}
	return false
}

type WatchCellsResponse struct {
	Cell *types.Cell `protobuf:"bytes,1,opt,name=cell,proto3" json:"cell,omitempty"`
	Type EventType   `protobuf:"varint,2,opt,name=type,proto3,enum=onos.ransim.model.EventType" json:"type,omitempty"`
}

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

var xxx_messageInfo_WatchCellsResponse proto.InternalMessageInfo

func (m *WatchCellsResponse) GetCell() *types.Cell {
	if m != nil {
		return m.Cell
	}
	return nil
}

func (m *WatchCellsResponse) GetType() EventType {
	if m != nil {
		return m.Type
	}
	return EventType_NONE
}

type ListCellsRequest struct {
}

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

var xxx_messageInfo_ListCellsRequest proto.InternalMessageInfo

type ListCellsResponse struct {
	Cell *types.Cell `protobuf:"bytes,1,opt,name=Cell,proto3" json:"Cell,omitempty"`
}

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

var xxx_messageInfo_ListCellsResponse proto.InternalMessageInfo

func (m *ListCellsResponse) GetCell() *types.Cell {
	if m != nil {
		return m.Cell
	}
	return nil
}

type CreateRouteRequest struct {
	Route *types.Route `protobuf:"bytes,1,opt,name=route,proto3" json:"route,omitempty"`
}

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

var xxx_messageInfo_CreateRouteRequest proto.InternalMessageInfo

func (m *CreateRouteRequest) GetRoute() *types.Route {
	if m != nil {
		return m.Route
	}
	return nil
}

type CreateRouteResponse struct {
}

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

var xxx_messageInfo_CreateRouteResponse proto.InternalMessageInfo

type GetRouteRequest struct {
	IMSI github_com_onosproject_onos_api_go_onos_ransim_types.IMSI `protobuf:"varint,1,opt,name=imsi,proto3,casttype=github.com/onosproject/onos-api/go/onos/ransim/types.IMSI" json:"imsi,omitempty"`
}

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

var xxx_messageInfo_GetRouteRequest proto.InternalMessageInfo

func (m *GetRouteRequest) GetIMSI() github_com_onosproject_onos_api_go_onos_ransim_types.IMSI {
	if m != nil {
		return m.IMSI
	}
	return 0
}

type GetRouteResponse struct {
	Route *types.Route `protobuf:"bytes,1,opt,name=route,proto3" json:"route,omitempty"`
}

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

var xxx_messageInfo_GetRouteResponse proto.InternalMessageInfo

func (m *GetRouteResponse) GetRoute() *types.Route {
	if m != nil {
		return m.Route
	}
	return nil
}

type DeleteRouteRequest struct {
	IMSI github_com_onosproject_onos_api_go_onos_ransim_types.IMSI `protobuf:"varint,1,opt,name=enbid,proto3,casttype=github.com/onosproject/onos-api/go/onos/ransim/types.IMSI" json:"enbid,omitempty"`
}

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

var xxx_messageInfo_DeleteRouteRequest proto.InternalMessageInfo

func (m *DeleteRouteRequest) GetIMSI() github_com_onosproject_onos_api_go_onos_ransim_types.IMSI {
	if m != nil {
		return m.IMSI
	}
	return 0
}

type DeleteRouteResponse struct {
}

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

var xxx_messageInfo_DeleteRouteResponse proto.InternalMessageInfo

type WatchRoutesRequest struct {
	NoReplay    bool `protobuf:"varint,1,opt,name=no_replay,json=noReplay,proto3" json:"no_replay,omitempty"`
	NoSubscribe bool `protobuf:"varint,2,opt,name=no_subscribe,json=noSubscribe,proto3" json:"no_subscribe,omitempty"`
}

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

var xxx_messageInfo_WatchRoutesRequest proto.InternalMessageInfo

func (m *WatchRoutesRequest) GetNoReplay() bool {
	if m != nil {
		return m.NoReplay
	}
	return false
}

func (m *WatchRoutesRequest) GetNoSubscribe() bool {
	if m != nil {
		return m.NoSubscribe
	}
	return false
}

type WatchRoutesResponse struct {
	Route *types.Route `protobuf:"bytes,1,opt,name=route,proto3" json:"route,omitempty"`
	Type  EventType    `protobuf:"varint,2,opt,name=type,proto3,enum=onos.ransim.model.EventType" json:"type,omitempty"`
}

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

var xxx_messageInfo_WatchRoutesResponse proto.InternalMessageInfo

func (m *WatchRoutesResponse) GetRoute() *types.Route {
	if m != nil {
		return m.Route
	}
	return nil
}

func (m *WatchRoutesResponse) GetType() EventType {
	if m != nil {
		return m.Type
	}
	return EventType_NONE
}

type ListRoutesRequest struct {
}

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

var xxx_messageInfo_ListRoutesRequest proto.InternalMessageInfo

type ListRoutesResponse struct {
	Route *types.Route `protobuf:"bytes,1,opt,name=route,proto3" json:"route,omitempty"`
}

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

var xxx_messageInfo_ListRoutesResponse proto.InternalMessageInfo

func (m *ListRoutesResponse) GetRoute() *types.Route {
	if m != nil {
		return m.Route
	}
	return nil
}

type GetUERequest struct {
	IMSI github_com_onosproject_onos_api_go_onos_ransim_types.IMSI `protobuf:"varint,1,opt,name=imsi,proto3,casttype=github.com/onosproject/onos-api/go/onos/ransim/types.IMSI" json:"imsi,omitempty"`
}

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

var xxx_messageInfo_GetUERequest proto.InternalMessageInfo

func (m *GetUERequest) GetIMSI() github_com_onosproject_onos_api_go_onos_ransim_types.IMSI {
	if m != nil {
		return m.IMSI
	}
	return 0
}

type GetUEResponse struct {
	Ue *types.Ue `protobuf:"bytes,1,opt,name=ue,proto3" json:"ue,omitempty"`
}

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

var xxx_messageInfo_GetUEResponse proto.InternalMessageInfo

func (m *GetUEResponse) GetUe() *types.Ue {
	if m != nil {
		return m.Ue
	}
	return nil
}

type MoveToCellRequest struct {
	IMSI github_com_onosproject_onos_api_go_onos_ransim_types.IMSI `protobuf:"varint,1,opt,name=imsi,proto3,casttype=github.com/onosproject/onos-api/go/onos/ransim/types.IMSI" json:"imsi,omitempty"`
	NCGI github_com_onosproject_onos_api_go_onos_ransim_types.NCGI `protobuf:"varint,2,opt,name=ecgi,proto3,casttype=github.com/onosproject/onos-api/go/onos/ransim/types.NCGI" json:"ecgi,omitempty"`
}

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

var xxx_messageInfo_MoveToCellRequest proto.InternalMessageInfo

func (m *MoveToCellRequest) GetIMSI() github_com_onosproject_onos_api_go_onos_ransim_types.IMSI {
	if m != nil {
		return m.IMSI
	}
	return 0
}

func (m *MoveToCellRequest) GetNCGI() github_com_onosproject_onos_api_go_onos_ransim_types.NCGI {
	if m != nil {
		return m.NCGI
	}
	return 0
}

type MoveToCellResponse struct {
}

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

var xxx_messageInfo_MoveToCellResponse proto.InternalMessageInfo

type MoveToLocationRequest struct {
	IMSI     github_com_onosproject_onos_api_go_onos_ransim_types.IMSI `protobuf:"varint,1,opt,name=imsi,proto3,casttype=github.com/onosproject/onos-api/go/onos/ransim/types.IMSI" json:"imsi,omitempty"`
	Location *types.Point                                              `protobuf:"bytes,2,opt,name=location,proto3" json:"location,omitempty"`
	Heading  uint32                                                    `protobuf:"varint,3,opt,name=heading,proto3" json:"heading,omitempty"`
}

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

var xxx_messageInfo_MoveToLocationRequest proto.InternalMessageInfo

func (m *MoveToLocationRequest) GetIMSI() github_com_onosproject_onos_api_go_onos_ransim_types.IMSI {
	if m != nil {
		return m.IMSI
	}
	return 0
}

func (m *MoveToLocationRequest) GetLocation() *types.Point {
	if m != nil {
		return m.Location
	}
	return nil
}

func (m *MoveToLocationRequest) GetHeading() uint32 {
	if m != nil {
		return m.Heading
	}
	return 0
}

type MoveToLocationResponse struct {
}

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

var xxx_messageInfo_MoveToLocationResponse proto.InternalMessageInfo

type DeleteUERequest struct {
	IMSI github_com_onosproject_onos_api_go_onos_ransim_types.IMSI `protobuf:"varint,1,opt,name=imsi,proto3,casttype=github.com/onosproject/onos-api/go/onos/ransim/types.IMSI" json:"imsi,omitempty"`
}

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

var xxx_messageInfo_DeleteUERequest proto.InternalMessageInfo

func (m *DeleteUERequest) GetIMSI() github_com_onosproject_onos_api_go_onos_ransim_types.IMSI {
	if m != nil {
		return m.IMSI
	}
	return 0
}

type DeleteUEResponse struct {
}

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

var xxx_messageInfo_DeleteUEResponse proto.InternalMessageInfo

type WatchUEsRequest struct {
	NoReplay    bool `protobuf:"varint,1,opt,name=no_replay,json=noReplay,proto3" json:"no_replay,omitempty"`
	NoSubscribe bool `protobuf:"varint,2,opt,name=no_subscribe,json=noSubscribe,proto3" json:"no_subscribe,omitempty"`
}

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

var xxx_messageInfo_WatchUEsRequest proto.InternalMessageInfo

func (m *WatchUEsRequest) GetNoReplay() bool {
	if m != nil {
		return m.NoReplay
	}
	return false
}

func (m *WatchUEsRequest) GetNoSubscribe() bool {
	if m != nil {
		return m.NoSubscribe
	}
	return false
}

type WatchUEsResponse struct {
	Ue   *types.Ue `protobuf:"bytes,1,opt,name=ue,proto3" json:"ue,omitempty"`
	Type EventType `protobuf:"varint,2,opt,name=type,proto3,enum=onos.ransim.model.EventType" json:"type,omitempty"`
}

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

var xxx_messageInfo_WatchUEsResponse proto.InternalMessageInfo

func (m *WatchUEsResponse) GetUe() *types.Ue {
	if m != nil {
		return m.Ue
	}
	return nil
}

func (m *WatchUEsResponse) GetType() EventType {
	if m != nil {
		return m.Type
	}
	return EventType_NONE
}

type ListUEsRequest struct {
}

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

var xxx_messageInfo_ListUEsRequest proto.InternalMessageInfo

type ListUEsResponse struct {
	Ue *types.Ue `protobuf:"bytes,1,opt,name=ue,proto3" json:"ue,omitempty"`
}

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

var xxx_messageInfo_ListUEsResponse proto.InternalMessageInfo

func (m *ListUEsResponse) GetUe() *types.Ue {
	if m != nil {
		return m.Ue
	}
	return nil
}

type GetUECountRequest struct {
}

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

var xxx_messageInfo_GetUECountRequest proto.InternalMessageInfo

type GetUECountResponse struct {
	Count uint32 `protobuf:"varint,1,opt,name=count,proto3" json:"count,omitempty"`
}

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

var xxx_messageInfo_GetUECountResponse proto.InternalMessageInfo

func (m *GetUECountResponse) GetCount() uint32 {
	if m != nil {
		return m.Count
	}
	return 0
}

type SetUECountRequest struct {
	Count uint32 `protobuf:"varint,1,opt,name=count,proto3" json:"count,omitempty"`
}

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

var xxx_messageInfo_SetUECountRequest proto.InternalMessageInfo

func (m *SetUECountRequest) GetCount() uint32 {
	if m != nil {
		return m.Count
	}
	return 0
}

type SetUECountResponse struct {
}

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

var xxx_messageInfo_SetUECountResponse proto.InternalMessageInfo

func init() {
	proto.RegisterEnum("onos.ransim.model.EventType", EventType_name, EventType_value)
	proto.RegisterType((*DataSet)(nil), "onos.ransim.model.DataSet")
	proto.RegisterType((*LoadRequest)(nil), "onos.ransim.model.LoadRequest")
	proto.RegisterType((*LoadResponse)(nil), "onos.ransim.model.LoadResponse")
	proto.RegisterType((*ClearRequest)(nil), "onos.ransim.model.ClearRequest")
	proto.RegisterType((*ClearResponse)(nil), "onos.ransim.model.ClearResponse")
	proto.RegisterType((*PlmnIDRequest)(nil), "onos.ransim.model.PlmnIDRequest")
	proto.RegisterType((*PlmnIDResponse)(nil), "onos.ransim.model.PlmnIDResponse")
	proto.RegisterType((*CreateNodeRequest)(nil), "onos.ransim.model.CreateNodeRequest")
	proto.RegisterType((*CreateNodeResponse)(nil), "onos.ransim.model.CreateNodeResponse")
	proto.RegisterType((*GetNodeRequest)(nil), "onos.ransim.model.GetNodeRequest")
	proto.RegisterType((*GetNodeResponse)(nil), "onos.ransim.model.GetNodeResponse")
	proto.RegisterType((*UpdateNodeRequest)(nil), "onos.ransim.model.UpdateNodeRequest")
	proto.RegisterType((*UpdateNodeResponse)(nil), "onos.ransim.model.UpdateNodeResponse")
	proto.RegisterType((*DeleteNodeRequest)(nil), "onos.ransim.model.DeleteNodeRequest")
	proto.RegisterType((*DeleteNodeResponse)(nil), "onos.ransim.model.DeleteNodeResponse")
	proto.RegisterType((*ListNodesRequest)(nil), "onos.ransim.model.ListNodesRequest")
	proto.RegisterType((*ListNodesResponse)(nil), "onos.ransim.model.ListNodesResponse")
	proto.RegisterType((*WatchNodesRequest)(nil), "onos.ransim.model.WatchNodesRequest")
	proto.RegisterType((*WatchNodesResponse)(nil), "onos.ransim.model.WatchNodesResponse")
	proto.RegisterType((*AgentControlRequest)(nil), "onos.ransim.model.AgentControlRequest")
	proto.RegisterType((*AgentControlResponse)(nil), "onos.ransim.model.AgentControlResponse")
	proto.RegisterType((*CreateCellRequest)(nil), "onos.ransim.model.CreateCellRequest")
	proto.RegisterType((*CreateCellResponse)(nil), "onos.ransim.model.CreateCellResponse")
	proto.RegisterType((*GetCellRequest)(nil), "onos.ransim.model.GetCellRequest")
	proto.RegisterType((*GetCellResponse)(nil), "onos.ransim.model.GetCellResponse")
	proto.RegisterType((*UpdateCellRequest)(nil), "onos.ransim.model.UpdateCellRequest")
	proto.RegisterType((*UpdateCellResponse)(nil), "onos.ransim.model.UpdateCellResponse")
	proto.RegisterType((*DeleteCellRequest)(nil), "onos.ransim.model.DeleteCellRequest")
	proto.RegisterType((*DeleteCellResponse)(nil), "onos.ransim.model.DeleteCellResponse")
	proto.RegisterType((*WatchCellsRequest)(nil), "onos.ransim.model.WatchCellsRequest")
	proto.RegisterType((*WatchCellsResponse)(nil), "onos.ransim.model.WatchCellsResponse")
	proto.RegisterType((*ListCellsRequest)(nil), "onos.ransim.model.ListCellsRequest")
	proto.RegisterType((*ListCellsResponse)(nil), "onos.ransim.model.ListCellsResponse")
	proto.RegisterType((*CreateRouteRequest)(nil), "onos.ransim.model.CreateRouteRequest")
	proto.RegisterType((*CreateRouteResponse)(nil), "onos.ransim.model.CreateRouteResponse")
	proto.RegisterType((*GetRouteRequest)(nil), "onos.ransim.model.GetRouteRequest")
	proto.RegisterType((*GetRouteResponse)(nil), "onos.ransim.model.GetRouteResponse")
	proto.RegisterType((*DeleteRouteRequest)(nil), "onos.ransim.model.DeleteRouteRequest")
	proto.RegisterType((*DeleteRouteResponse)(nil), "onos.ransim.model.DeleteRouteResponse")
	proto.RegisterType((*WatchRoutesRequest)(nil), "onos.ransim.model.WatchRoutesRequest")
	proto.RegisterType((*WatchRoutesResponse)(nil), "onos.ransim.model.WatchRoutesResponse")
	proto.RegisterType((*ListRoutesRequest)(nil), "onos.ransim.model.ListRoutesRequest")
	proto.RegisterType((*ListRoutesResponse)(nil), "onos.ransim.model.ListRoutesResponse")
	proto.RegisterType((*GetUERequest)(nil), "onos.ransim.model.GetUERequest")
	proto.RegisterType((*GetUEResponse)(nil), "onos.ransim.model.GetUEResponse")
	proto.RegisterType((*MoveToCellRequest)(nil), "onos.ransim.model.MoveToCellRequest")
	proto.RegisterType((*MoveToCellResponse)(nil), "onos.ransim.model.MoveToCellResponse")
	proto.RegisterType((*MoveToLocationRequest)(nil), "onos.ransim.model.MoveToLocationRequest")
	proto.RegisterType((*MoveToLocationResponse)(nil), "onos.ransim.model.MoveToLocationResponse")
	proto.RegisterType((*DeleteUERequest)(nil), "onos.ransim.model.DeleteUERequest")
	proto.RegisterType((*DeleteUEResponse)(nil), "onos.ransim.model.DeleteUEResponse")
	proto.RegisterType((*WatchUEsRequest)(nil), "onos.ransim.model.WatchUEsRequest")
	proto.RegisterType((*WatchUEsResponse)(nil), "onos.ransim.model.WatchUEsResponse")
	proto.RegisterType((*ListUEsRequest)(nil), "onos.ransim.model.ListUEsRequest")
	proto.RegisterType((*ListUEsResponse)(nil), "onos.ransim.model.ListUEsResponse")
	proto.RegisterType((*GetUECountRequest)(nil), "onos.ransim.model.GetUECountRequest")
	proto.RegisterType((*GetUECountResponse)(nil), "onos.ransim.model.GetUECountResponse")
	proto.RegisterType((*SetUECountRequest)(nil), "onos.ransim.model.SetUECountRequest")
	proto.RegisterType((*SetUECountResponse)(nil), "onos.ransim.model.SetUECountResponse")
}

func init() { proto.RegisterFile("onos/ransim/model/model.proto", fileDescriptor_9942ba2f94296ec8) }

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

// ModelServiceClient is the client API for ModelService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type ModelServiceClient interface {
	Load(ctx context.Context, in *LoadRequest, opts ...grpc.CallOption) (*LoadResponse, error)
	Clear(ctx context.Context, in *ClearRequest, opts ...grpc.CallOption) (*ClearResponse, error)
}

type modelServiceClient struct {
	cc *grpc.ClientConn
}

func NewModelServiceClient(cc *grpc.ClientConn) ModelServiceClient {
	return &modelServiceClient{cc}
}

func (c *modelServiceClient) Load(ctx context.Context, in *LoadRequest, opts ...grpc.CallOption) (*LoadResponse, error) {
	out := new(LoadResponse)
	err := c.cc.Invoke(ctx, "/onos.ransim.model.ModelService/Load", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *modelServiceClient) Clear(ctx context.Context, in *ClearRequest, opts ...grpc.CallOption) (*ClearResponse, error) {
	out := new(ClearResponse)
	err := c.cc.Invoke(ctx, "/onos.ransim.model.ModelService/Clear", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// ModelServiceServer is the server API for ModelService service.
type ModelServiceServer interface {
	Load(context.Context, *LoadRequest) (*LoadResponse, error)
	Clear(context.Context, *ClearRequest) (*ClearResponse, error)
}

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

func (*UnimplementedModelServiceServer) Load(ctx context.Context, req *LoadRequest) (*LoadResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Load not implemented")
}
func (*UnimplementedModelServiceServer) Clear(ctx context.Context, req *ClearRequest) (*ClearResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Clear not implemented")
}

func RegisterModelServiceServer(s *grpc.Server, srv ModelServiceServer) {
	s.RegisterService(&_ModelService_serviceDesc, srv)
}

func _ModelService_Load_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(LoadRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ModelServiceServer).Load(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/onos.ransim.model.ModelService/Load",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ModelServiceServer).Load(ctx, req.(*LoadRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ModelService_Clear_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ClearRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ModelServiceServer).Clear(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/onos.ransim.model.ModelService/Clear",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ModelServiceServer).Clear(ctx, req.(*ClearRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _ModelService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "onos.ransim.model.ModelService",
	HandlerType: (*ModelServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Load",
			Handler:    _ModelService_Load_Handler,
		},
		{
			MethodName: "Clear",
			Handler:    _ModelService_Clear_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "onos/ransim/model/model.proto",
}

// NodeModelClient is the client API for NodeModel service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type NodeModelClient interface {
	GetPlmnID(ctx context.Context, in *PlmnIDRequest, opts ...grpc.CallOption) (*PlmnIDResponse, error)
	CreateNode(ctx context.Context, in *CreateNodeRequest, opts ...grpc.CallOption) (*CreateNodeResponse, error)
	GetNode(ctx context.Context, in *GetNodeRequest, opts ...grpc.CallOption) (*GetNodeResponse, error)
	UpdateNode(ctx context.Context, in *UpdateNodeRequest, opts ...grpc.CallOption) (*UpdateNodeResponse, error)
	DeleteNode(ctx context.Context, in *DeleteNodeRequest, opts ...grpc.CallOption) (*DeleteNodeResponse, error)
	WatchNodes(ctx context.Context, in *WatchNodesRequest, opts ...grpc.CallOption) (NodeModel_WatchNodesClient, error)
	ListNodes(ctx context.Context, in *ListNodesRequest, opts ...grpc.CallOption) (NodeModel_ListNodesClient, error)
	AgentControl(ctx context.Context, in *AgentControlRequest, opts ...grpc.CallOption) (*AgentControlResponse, error)
}

type nodeModelClient struct {
	cc *grpc.ClientConn
}

func NewNodeModelClient(cc *grpc.ClientConn) NodeModelClient {
	return &nodeModelClient{cc}
}

func (c *nodeModelClient) GetPlmnID(ctx context.Context, in *PlmnIDRequest, opts ...grpc.CallOption) (*PlmnIDResponse, error) {
	out := new(PlmnIDResponse)
	err := c.cc.Invoke(ctx, "/onos.ransim.model.NodeModel/GetPlmnID", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *nodeModelClient) CreateNode(ctx context.Context, in *CreateNodeRequest, opts ...grpc.CallOption) (*CreateNodeResponse, error) {
	out := new(CreateNodeResponse)
	err := c.cc.Invoke(ctx, "/onos.ransim.model.NodeModel/CreateNode", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *nodeModelClient) GetNode(ctx context.Context, in *GetNodeRequest, opts ...grpc.CallOption) (*GetNodeResponse, error) {
	out := new(GetNodeResponse)
	err := c.cc.Invoke(ctx, "/onos.ransim.model.NodeModel/GetNode", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *nodeModelClient) UpdateNode(ctx context.Context, in *UpdateNodeRequest, opts ...grpc.CallOption) (*UpdateNodeResponse, error) {
	out := new(UpdateNodeResponse)
	err := c.cc.Invoke(ctx, "/onos.ransim.model.NodeModel/UpdateNode", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *nodeModelClient) DeleteNode(ctx context.Context, in *DeleteNodeRequest, opts ...grpc.CallOption) (*DeleteNodeResponse, error) {
	out := new(DeleteNodeResponse)
	err := c.cc.Invoke(ctx, "/onos.ransim.model.NodeModel/DeleteNode", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *nodeModelClient) WatchNodes(ctx context.Context, in *WatchNodesRequest, opts ...grpc.CallOption) (NodeModel_WatchNodesClient, error) {
	stream, err := c.cc.NewStream(ctx, &_NodeModel_serviceDesc.Streams[0], "/onos.ransim.model.NodeModel/WatchNodes", opts...)
	if err != nil {
		return nil, err
	}
	x := &nodeModelWatchNodesClient{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 NodeModel_WatchNodesClient interface {
	Recv() (*WatchNodesResponse, error)
	grpc.ClientStream
}

type nodeModelWatchNodesClient struct {
	grpc.ClientStream
}

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

func (c *nodeModelClient) ListNodes(ctx context.Context, in *ListNodesRequest, opts ...grpc.CallOption) (NodeModel_ListNodesClient, error) {
	stream, err := c.cc.NewStream(ctx, &_NodeModel_serviceDesc.Streams[1], "/onos.ransim.model.NodeModel/ListNodes", opts...)
	if err != nil {
		return nil, err
	}
	x := &nodeModelListNodesClient{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 NodeModel_ListNodesClient interface {
	Recv() (*ListNodesResponse, error)
	grpc.ClientStream
}

type nodeModelListNodesClient struct {
	grpc.ClientStream
}

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

func (c *nodeModelClient) AgentControl(ctx context.Context, in *AgentControlRequest, opts ...grpc.CallOption) (*AgentControlResponse, error) {
	out := new(AgentControlResponse)
	err := c.cc.Invoke(ctx, "/onos.ransim.model.NodeModel/AgentControl", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// NodeModelServer is the server API for NodeModel service.
type NodeModelServer interface {
	GetPlmnID(context.Context, *PlmnIDRequest) (*PlmnIDResponse, error)
	CreateNode(context.Context, *CreateNodeRequest) (*CreateNodeResponse, error)
	GetNode(context.Context, *GetNodeRequest) (*GetNodeResponse, error)
	UpdateNode(context.Context, *UpdateNodeRequest) (*UpdateNodeResponse, error)
	DeleteNode(context.Context, *DeleteNodeRequest) (*DeleteNodeResponse, error)
	WatchNodes(*WatchNodesRequest, NodeModel_WatchNodesServer) error
	ListNodes(*ListNodesRequest, NodeModel_ListNodesServer) error
	AgentControl(context.Context, *AgentControlRequest) (*AgentControlResponse, error)
}

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

func (*UnimplementedNodeModelServer) GetPlmnID(ctx context.Context, req *PlmnIDRequest) (*PlmnIDResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetPlmnID not implemented")
}
func (*UnimplementedNodeModelServer) CreateNode(ctx context.Context, req *CreateNodeRequest) (*CreateNodeResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateNode not implemented")
}
func (*UnimplementedNodeModelServer) GetNode(ctx context.Context, req *GetNodeRequest) (*GetNodeResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetNode not implemented")
}
func (*UnimplementedNodeModelServer) UpdateNode(ctx context.Context, req *UpdateNodeRequest) (*UpdateNodeResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateNode not implemented")
}
func (*UnimplementedNodeModelServer) DeleteNode(ctx context.Context, req *DeleteNodeRequest) (*DeleteNodeResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteNode not implemented")
}
func (*UnimplementedNodeModelServer) WatchNodes(req *WatchNodesRequest, srv NodeModel_WatchNodesServer) error {
	return status.Errorf(codes.Unimplemented, "method WatchNodes not implemented")
}
func (*UnimplementedNodeModelServer) ListNodes(req *ListNodesRequest, srv NodeModel_ListNodesServer) error {
	return status.Errorf(codes.Unimplemented, "method ListNodes not implemented")
}
func (*UnimplementedNodeModelServer) AgentControl(ctx context.Context, req *AgentControlRequest) (*AgentControlResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AgentControl not implemented")
}

func RegisterNodeModelServer(s *grpc.Server, srv NodeModelServer) {
	s.RegisterService(&_NodeModel_serviceDesc, srv)
}

func _NodeModel_GetPlmnID_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PlmnIDRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NodeModelServer).GetPlmnID(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/onos.ransim.model.NodeModel/GetPlmnID",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NodeModelServer).GetPlmnID(ctx, req.(*PlmnIDRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _NodeModel_CreateNode_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateNodeRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NodeModelServer).CreateNode(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/onos.ransim.model.NodeModel/CreateNode",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NodeModelServer).CreateNode(ctx, req.(*CreateNodeRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _NodeModel_GetNode_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetNodeRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NodeModelServer).GetNode(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/onos.ransim.model.NodeModel/GetNode",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NodeModelServer).GetNode(ctx, req.(*GetNodeRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _NodeModel_UpdateNode_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateNodeRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NodeModelServer).UpdateNode(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/onos.ransim.model.NodeModel/UpdateNode",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NodeModelServer).UpdateNode(ctx, req.(*UpdateNodeRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _NodeModel_DeleteNode_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteNodeRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NodeModelServer).DeleteNode(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/onos.ransim.model.NodeModel/DeleteNode",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NodeModelServer).DeleteNode(ctx, req.(*DeleteNodeRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _NodeModel_WatchNodes_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(WatchNodesRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(NodeModelServer).WatchNodes(m, &nodeModelWatchNodesServer{stream})
}

type NodeModel_WatchNodesServer interface {
	Send(*WatchNodesResponse) error
	grpc.ServerStream
}

type nodeModelWatchNodesServer struct {
	grpc.ServerStream
}

func (x *nodeModelWatchNodesServer) Send(m *WatchNodesResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _NodeModel_ListNodes_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(ListNodesRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(NodeModelServer).ListNodes(m, &nodeModelListNodesServer{stream})
}

type NodeModel_ListNodesServer interface {
	Send(*ListNodesResponse) error
	grpc.ServerStream
}

type nodeModelListNodesServer struct {
	grpc.ServerStream
}

func (x *nodeModelListNodesServer) Send(m *ListNodesResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _NodeModel_AgentControl_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AgentControlRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NodeModelServer).AgentControl(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/onos.ransim.model.NodeModel/AgentControl",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NodeModelServer).AgentControl(ctx, req.(*AgentControlRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _NodeModel_serviceDesc = grpc.ServiceDesc{
	ServiceName: "onos.ransim.model.NodeModel",
	HandlerType: (*NodeModelServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetPlmnID",
			Handler:    _NodeModel_GetPlmnID_Handler,
		},
		{
			MethodName: "CreateNode",
			Handler:    _NodeModel_CreateNode_Handler,
		},
		{
			MethodName: "GetNode",
			Handler:    _NodeModel_GetNode_Handler,
		},
		{
			MethodName: "UpdateNode",
			Handler:    _NodeModel_UpdateNode_Handler,
		},
		{
			MethodName: "DeleteNode",
			Handler:    _NodeModel_DeleteNode_Handler,
		},
		{
			MethodName: "AgentControl",
			Handler:    _NodeModel_AgentControl_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "WatchNodes",
			Handler:       _NodeModel_WatchNodes_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "ListNodes",
			Handler:       _NodeModel_ListNodes_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "onos/ransim/model/model.proto",
}

// CellModelClient is the client API for CellModel service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type CellModelClient interface {
	CreateCell(ctx context.Context, in *CreateCellRequest, opts ...grpc.CallOption) (*CreateCellResponse, error)
	DeleteCell(ctx context.Context, in *DeleteCellRequest, opts ...grpc.CallOption) (*DeleteCellResponse, error)
	UpdateCell(ctx context.Context, in *UpdateCellRequest, opts ...grpc.CallOption) (*UpdateCellResponse, error)
	GetCell(ctx context.Context, in *GetCellRequest, opts ...grpc.CallOption) (*GetCellResponse, error)
	WatchCells(ctx context.Context, in *WatchCellsRequest, opts ...grpc.CallOption) (CellModel_WatchCellsClient, error)
	ListCells(ctx context.Context, in *ListCellsRequest, opts ...grpc.CallOption) (CellModel_ListCellsClient, error)
}

type cellModelClient struct {
	cc *grpc.ClientConn
}

func NewCellModelClient(cc *grpc.ClientConn) CellModelClient {
	return &cellModelClient{cc}
}

func (c *cellModelClient) CreateCell(ctx context.Context, in *CreateCellRequest, opts ...grpc.CallOption) (*CreateCellResponse, error) {
	out := new(CreateCellResponse)
	err := c.cc.Invoke(ctx, "/onos.ransim.model.CellModel/CreateCell", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *cellModelClient) DeleteCell(ctx context.Context, in *DeleteCellRequest, opts ...grpc.CallOption) (*DeleteCellResponse, error) {
	out := new(DeleteCellResponse)
	err := c.cc.Invoke(ctx, "/onos.ransim.model.CellModel/DeleteCell", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *cellModelClient) UpdateCell(ctx context.Context, in *UpdateCellRequest, opts ...grpc.CallOption) (*UpdateCellResponse, error) {
	out := new(UpdateCellResponse)
	err := c.cc.Invoke(ctx, "/onos.ransim.model.CellModel/UpdateCell", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *cellModelClient) GetCell(ctx context.Context, in *GetCellRequest, opts ...grpc.CallOption) (*GetCellResponse, error) {
	out := new(GetCellResponse)
	err := c.cc.Invoke(ctx, "/onos.ransim.model.CellModel/GetCell", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *cellModelClient) WatchCells(ctx context.Context, in *WatchCellsRequest, opts ...grpc.CallOption) (CellModel_WatchCellsClient, error) {
	stream, err := c.cc.NewStream(ctx, &_CellModel_serviceDesc.Streams[0], "/onos.ransim.model.CellModel/WatchCells", opts...)
	if err != nil {
		return nil, err
	}
	x := &cellModelWatchCellsClient{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 CellModel_WatchCellsClient interface {
	Recv() (*WatchCellsResponse, error)
	grpc.ClientStream
}

type cellModelWatchCellsClient struct {
	grpc.ClientStream
}

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

func (c *cellModelClient) ListCells(ctx context.Context, in *ListCellsRequest, opts ...grpc.CallOption) (CellModel_ListCellsClient, error) {
	stream, err := c.cc.NewStream(ctx, &_CellModel_serviceDesc.Streams[1], "/onos.ransim.model.CellModel/ListCells", opts...)
	if err != nil {
		return nil, err
	}
	x := &cellModelListCellsClient{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 CellModel_ListCellsClient interface {
	Recv() (*ListCellsResponse, error)
	grpc.ClientStream
}

type cellModelListCellsClient struct {
	grpc.ClientStream
}

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

// CellModelServer is the server API for CellModel service.
type CellModelServer interface {
	CreateCell(context.Context, *CreateCellRequest) (*CreateCellResponse, error)
	DeleteCell(context.Context, *DeleteCellRequest) (*DeleteCellResponse, error)
	UpdateCell(context.Context, *UpdateCellRequest) (*UpdateCellResponse, error)
	GetCell(context.Context, *GetCellRequest) (*GetCellResponse, error)
	WatchCells(*WatchCellsRequest, CellModel_WatchCellsServer) error
	ListCells(*ListCellsRequest, CellModel_ListCellsServer) error
}

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

func (*UnimplementedCellModelServer) CreateCell(ctx context.Context, req *CreateCellRequest) (*CreateCellResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateCell not implemented")
}
func (*UnimplementedCellModelServer) DeleteCell(ctx context.Context, req *DeleteCellRequest) (*DeleteCellResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteCell not implemented")
}
func (*UnimplementedCellModelServer) UpdateCell(ctx context.Context, req *UpdateCellRequest) (*UpdateCellResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateCell not implemented")
}
func (*UnimplementedCellModelServer) GetCell(ctx context.Context, req *GetCellRequest) (*GetCellResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetCell not implemented")
}
func (*UnimplementedCellModelServer) WatchCells(req *WatchCellsRequest, srv CellModel_WatchCellsServer) error {
	return status.Errorf(codes.Unimplemented, "method WatchCells not implemented")
}
func (*UnimplementedCellModelServer) ListCells(req *ListCellsRequest, srv CellModel_ListCellsServer) error {
	return status.Errorf(codes.Unimplemented, "method ListCells not implemented")
}

func RegisterCellModelServer(s *grpc.Server, srv CellModelServer) {
	s.RegisterService(&_CellModel_serviceDesc, srv)
}

func _CellModel_CreateCell_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateCellRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CellModelServer).CreateCell(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/onos.ransim.model.CellModel/CreateCell",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CellModelServer).CreateCell(ctx, req.(*CreateCellRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CellModel_DeleteCell_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteCellRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CellModelServer).DeleteCell(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/onos.ransim.model.CellModel/DeleteCell",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CellModelServer).DeleteCell(ctx, req.(*DeleteCellRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CellModel_UpdateCell_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateCellRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CellModelServer).UpdateCell(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/onos.ransim.model.CellModel/UpdateCell",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CellModelServer).UpdateCell(ctx, req.(*UpdateCellRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CellModel_GetCell_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetCellRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CellModelServer).GetCell(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/onos.ransim.model.CellModel/GetCell",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CellModelServer).GetCell(ctx, req.(*GetCellRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CellModel_WatchCells_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(WatchCellsRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(CellModelServer).WatchCells(m, &cellModelWatchCellsServer{stream})
}

type CellModel_WatchCellsServer interface {
	Send(*WatchCellsResponse) error
	grpc.ServerStream
}

type cellModelWatchCellsServer struct {
	grpc.ServerStream
}

func (x *cellModelWatchCellsServer) Send(m *WatchCellsResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _CellModel_ListCells_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(ListCellsRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(CellModelServer).ListCells(m, &cellModelListCellsServer{stream})
}

type CellModel_ListCellsServer interface {
	Send(*ListCellsResponse) error
	grpc.ServerStream
}

type cellModelListCellsServer struct {
	grpc.ServerStream
}

func (x *cellModelListCellsServer) Send(m *ListCellsResponse) error {
	return x.ServerStream.SendMsg(m)
}

var _CellModel_serviceDesc = grpc.ServiceDesc{
	ServiceName: "onos.ransim.model.CellModel",
	HandlerType: (*CellModelServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "CreateCell",
			Handler:    _CellModel_CreateCell_Handler,
		},
		{
			MethodName: "DeleteCell",
			Handler:    _CellModel_DeleteCell_Handler,
		},
		{
			MethodName: "UpdateCell",
			Handler:    _CellModel_UpdateCell_Handler,
		},
		{
			MethodName: "GetCell",
			Handler:    _CellModel_GetCell_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "WatchCells",
			Handler:       _CellModel_WatchCells_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "ListCells",
			Handler:       _CellModel_ListCells_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "onos/ransim/model/model.proto",
}

// RouteModelClient is the client API for RouteModel service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type RouteModelClient interface {
	CreateRoute(ctx context.Context, in *CreateRouteRequest, opts ...grpc.CallOption) (*CreateRouteResponse, error)
	DeleteRoute(ctx context.Context, in *DeleteRouteRequest, opts ...grpc.CallOption) (*DeleteRouteResponse, error)
	GetRoute(ctx context.Context, in *GetRouteRequest, opts ...grpc.CallOption) (*GetRouteResponse, error)
	WatchRoutes(ctx context.Context, in *WatchRoutesRequest, opts ...grpc.CallOption) (RouteModel_WatchRoutesClient, error)
	ListRoutes(ctx context.Context, in *ListRoutesRequest, opts ...grpc.CallOption) (RouteModel_ListRoutesClient, error)
}

type routeModelClient struct {
	cc *grpc.ClientConn
}

func NewRouteModelClient(cc *grpc.ClientConn) RouteModelClient {
	return &routeModelClient{cc}
}

func (c *routeModelClient) CreateRoute(ctx context.Context, in *CreateRouteRequest, opts ...grpc.CallOption) (*CreateRouteResponse, error) {
	out := new(CreateRouteResponse)
	err := c.cc.Invoke(ctx, "/onos.ransim.model.RouteModel/CreateRoute", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *routeModelClient) DeleteRoute(ctx context.Context, in *DeleteRouteRequest, opts ...grpc.CallOption) (*DeleteRouteResponse, error) {
	out := new(DeleteRouteResponse)
	err := c.cc.Invoke(ctx, "/onos.ransim.model.RouteModel/DeleteRoute", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *routeModelClient) GetRoute(ctx context.Context, in *GetRouteRequest, opts ...grpc.CallOption) (*GetRouteResponse, error) {
	out := new(GetRouteResponse)
	err := c.cc.Invoke(ctx, "/onos.ransim.model.RouteModel/GetRoute", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *routeModelClient) WatchRoutes(ctx context.Context, in *WatchRoutesRequest, opts ...grpc.CallOption) (RouteModel_WatchRoutesClient, error) {
	stream, err := c.cc.NewStream(ctx, &_RouteModel_serviceDesc.Streams[0], "/onos.ransim.model.RouteModel/WatchRoutes", opts...)
	if err != nil {
		return nil, err
	}
	x := &routeModelWatchRoutesClient{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 RouteModel_WatchRoutesClient interface {
	Recv() (*WatchRoutesResponse, error)
	grpc.ClientStream
}

type routeModelWatchRoutesClient struct {
	grpc.ClientStream
}

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

func (c *routeModelClient) ListRoutes(ctx context.Context, in *ListRoutesRequest, opts ...grpc.CallOption) (RouteModel_ListRoutesClient, error) {
	stream, err := c.cc.NewStream(ctx, &_RouteModel_serviceDesc.Streams[1], "/onos.ransim.model.RouteModel/ListRoutes", opts...)
	if err != nil {
		return nil, err
	}
	x := &routeModelListRoutesClient{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 RouteModel_ListRoutesClient interface {
	Recv() (*ListRoutesResponse, error)
	grpc.ClientStream
}

type routeModelListRoutesClient struct {
	grpc.ClientStream
}

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

// RouteModelServer is the server API for RouteModel service.
type RouteModelServer interface {
	CreateRoute(context.Context, *CreateRouteRequest) (*CreateRouteResponse, error)
	DeleteRoute(context.Context, *DeleteRouteRequest) (*DeleteRouteResponse, error)
	GetRoute(context.Context, *GetRouteRequest) (*GetRouteResponse, error)
	WatchRoutes(*WatchRoutesRequest, RouteModel_WatchRoutesServer) error
	ListRoutes(*ListRoutesRequest, RouteModel_ListRoutesServer) error
}

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

func (*UnimplementedRouteModelServer) CreateRoute(ctx context.Context, req *CreateRouteRequest) (*CreateRouteResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateRoute not implemented")
}
func (*UnimplementedRouteModelServer) DeleteRoute(ctx context.Context, req *DeleteRouteRequest) (*DeleteRouteResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteRoute not implemented")
}
func (*UnimplementedRouteModelServer) GetRoute(ctx context.Context, req *GetRouteRequest) (*GetRouteResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetRoute not implemented")
}
func (*UnimplementedRouteModelServer) WatchRoutes(req *WatchRoutesRequest, srv RouteModel_WatchRoutesServer) error {
	return status.Errorf(codes.Unimplemented, "method WatchRoutes not implemented")
}
func (*UnimplementedRouteModelServer) ListRoutes(req *ListRoutesRequest, srv RouteModel_ListRoutesServer) error {
	return status.Errorf(codes.Unimplemented, "method ListRoutes not implemented")
}

func RegisterRouteModelServer(s *grpc.Server, srv RouteModelServer) {
	s.RegisterService(&_RouteModel_serviceDesc, srv)
}

func _RouteModel_CreateRoute_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateRouteRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RouteModelServer).CreateRoute(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/onos.ransim.model.RouteModel/CreateRoute",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RouteModelServer).CreateRoute(ctx, req.(*CreateRouteRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RouteModel_DeleteRoute_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteRouteRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RouteModelServer).DeleteRoute(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/onos.ransim.model.RouteModel/DeleteRoute",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RouteModelServer).DeleteRoute(ctx, req.(*DeleteRouteRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RouteModel_GetRoute_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetRouteRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RouteModelServer).GetRoute(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/onos.ransim.model.RouteModel/GetRoute",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RouteModelServer).GetRoute(ctx, req.(*GetRouteRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RouteModel_WatchRoutes_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(WatchRoutesRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(RouteModelServer).WatchRoutes(m, &routeModelWatchRoutesServer{stream})
}

type RouteModel_WatchRoutesServer interface {
	Send(*WatchRoutesResponse) error
	grpc.ServerStream
}

type routeModelWatchRoutesServer struct {
	grpc.ServerStream
}

func (x *routeModelWatchRoutesServer) Send(m *WatchRoutesResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _RouteModel_ListRoutes_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(ListRoutesRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(RouteModelServer).ListRoutes(m, &routeModelListRoutesServer{stream})
}

type RouteModel_ListRoutesServer interface {
	Send(*ListRoutesResponse) error
	grpc.ServerStream
}

type routeModelListRoutesServer struct {
	grpc.ServerStream
}

func (x *routeModelListRoutesServer) Send(m *ListRoutesResponse) error {
	return x.ServerStream.SendMsg(m)
}

var _RouteModel_serviceDesc = grpc.ServiceDesc{
	ServiceName: "onos.ransim.model.RouteModel",
	HandlerType: (*RouteModelServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "CreateRoute",
			Handler:    _RouteModel_CreateRoute_Handler,
		},
		{
			MethodName: "DeleteRoute",
			Handler:    _RouteModel_DeleteRoute_Handler,
		},
		{
			MethodName: "GetRoute",
			Handler:    _RouteModel_GetRoute_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "WatchRoutes",
			Handler:       _RouteModel_WatchRoutes_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "ListRoutes",
			Handler:       _RouteModel_ListRoutes_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "onos/ransim/model/model.proto",
}

// UEModelClient is the client API for UEModel service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type UEModelClient interface {
	GetUE(ctx context.Context, in *GetUERequest, opts ...grpc.CallOption) (*GetUEResponse, error)
	MoveToCell(ctx context.Context, in *MoveToCellRequest, opts ...grpc.CallOption) (*MoveToCellResponse, error)
	MoveToLocation(ctx context.Context, in *MoveToLocationRequest, opts ...grpc.CallOption) (*MoveToLocationResponse, error)
	DeleteUE(ctx context.Context, in *DeleteUERequest, opts ...grpc.CallOption) (*DeleteUEResponse, error)
	WatchUEs(ctx context.Context, in *WatchUEsRequest, opts ...grpc.CallOption) (UEModel_WatchUEsClient, error)
	ListUEs(ctx context.Context, in *ListUEsRequest, opts ...grpc.CallOption) (UEModel_ListUEsClient, error)
	GetUECount(ctx context.Context, in *GetUECountRequest, opts ...grpc.CallOption) (*GetUECountResponse, error)
	SetUECount(ctx context.Context, in *SetUECountRequest, opts ...grpc.CallOption) (*SetUECountResponse, error)
}

type uEModelClient struct {
	cc *grpc.ClientConn
}

func NewUEModelClient(cc *grpc.ClientConn) UEModelClient {
	return &uEModelClient{cc}
}

func (c *uEModelClient) GetUE(ctx context.Context, in *GetUERequest, opts ...grpc.CallOption) (*GetUEResponse, error) {
	out := new(GetUEResponse)
	err := c.cc.Invoke(ctx, "/onos.ransim.model.UEModel/GetUE", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *uEModelClient) MoveToCell(ctx context.Context, in *MoveToCellRequest, opts ...grpc.CallOption) (*MoveToCellResponse, error) {
	out := new(MoveToCellResponse)
	err := c.cc.Invoke(ctx, "/onos.ransim.model.UEModel/MoveToCell", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *uEModelClient) MoveToLocation(ctx context.Context, in *MoveToLocationRequest, opts ...grpc.CallOption) (*MoveToLocationResponse, error) {
	out := new(MoveToLocationResponse)
	err := c.cc.Invoke(ctx, "/onos.ransim.model.UEModel/MoveToLocation", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *uEModelClient) DeleteUE(ctx context.Context, in *DeleteUERequest, opts ...grpc.CallOption) (*DeleteUEResponse, error) {
	out := new(DeleteUEResponse)
	err := c.cc.Invoke(ctx, "/onos.ransim.model.UEModel/DeleteUE", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *uEModelClient) WatchUEs(ctx context.Context, in *WatchUEsRequest, opts ...grpc.CallOption) (UEModel_WatchUEsClient, error) {
	stream, err := c.cc.NewStream(ctx, &_UEModel_serviceDesc.Streams[0], "/onos.ransim.model.UEModel/WatchUEs", opts...)
	if err != nil {
		return nil, err
	}
	x := &uEModelWatchUEsClient{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 UEModel_WatchUEsClient interface {
	Recv() (*WatchUEsResponse, error)
	grpc.ClientStream
}

type uEModelWatchUEsClient struct {
	grpc.ClientStream
}

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

func (c *uEModelClient) ListUEs(ctx context.Context, in *ListUEsRequest, opts ...grpc.CallOption) (UEModel_ListUEsClient, error) {
	stream, err := c.cc.NewStream(ctx, &_UEModel_serviceDesc.Streams[1], "/onos.ransim.model.UEModel/ListUEs", opts...)
	if err != nil {
		return nil, err
	}
	x := &uEModelListUEsClient{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 UEModel_ListUEsClient interface {
	Recv() (*ListUEsResponse, error)
	grpc.ClientStream
}

type uEModelListUEsClient struct {
	grpc.ClientStream
}

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

func (c *uEModelClient) GetUECount(ctx context.Context, in *GetUECountRequest, opts ...grpc.CallOption) (*GetUECountResponse, error) {
	out := new(GetUECountResponse)
	err := c.cc.Invoke(ctx, "/onos.ransim.model.UEModel/GetUECount", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *uEModelClient) SetUECount(ctx context.Context, in *SetUECountRequest, opts ...grpc.CallOption) (*SetUECountResponse, error) {
	out := new(SetUECountResponse)
	err := c.cc.Invoke(ctx, "/onos.ransim.model.UEModel/SetUECount", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// UEModelServer is the server API for UEModel service.
type UEModelServer interface {
	GetUE(context.Context, *GetUERequest) (*GetUEResponse, error)
	MoveToCell(context.Context, *MoveToCellRequest) (*MoveToCellResponse, error)
	MoveToLocation(context.Context, *MoveToLocationRequest) (*MoveToLocationResponse, error)
	DeleteUE(context.Context, *DeleteUERequest) (*DeleteUEResponse, error)
	WatchUEs(*WatchUEsRequest, UEModel_WatchUEsServer) error
	ListUEs(*ListUEsRequest, UEModel_ListUEsServer) error
	GetUECount(context.Context, *GetUECountRequest) (*GetUECountResponse, error)
	SetUECount(context.Context, *SetUECountRequest) (*SetUECountResponse, error)
}

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

func (*UnimplementedUEModelServer) GetUE(ctx context.Context, req *GetUERequest) (*GetUEResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetUE not implemented")
}
func (*UnimplementedUEModelServer) MoveToCell(ctx context.Context, req *MoveToCellRequest) (*MoveToCellResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method MoveToCell not implemented")
}
func (*UnimplementedUEModelServer) MoveToLocation(ctx context.Context, req *MoveToLocationRequest) (*MoveToLocationResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method MoveToLocation not implemented")
}
func (*UnimplementedUEModelServer) DeleteUE(ctx context.Context, req *DeleteUERequest) (*DeleteUEResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteUE not implemented")
}
func (*UnimplementedUEModelServer) WatchUEs(req *WatchUEsRequest, srv UEModel_WatchUEsServer) error {
	return status.Errorf(codes.Unimplemented, "method WatchUEs not implemented")
}
func (*UnimplementedUEModelServer) ListUEs(req *ListUEsRequest, srv UEModel_ListUEsServer) error {
	return status.Errorf(codes.Unimplemented, "method ListUEs not implemented")
}
func (*UnimplementedUEModelServer) GetUECount(ctx context.Context, req *GetUECountRequest) (*GetUECountResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetUECount not implemented")
}
func (*UnimplementedUEModelServer) SetUECount(ctx context.Context, req *SetUECountRequest) (*SetUECountResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SetUECount not implemented")
}

func RegisterUEModelServer(s *grpc.Server, srv UEModelServer) {
	s.RegisterService(&_UEModel_serviceDesc, srv)
}

func _UEModel_GetUE_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetUERequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(UEModelServer).GetUE(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/onos.ransim.model.UEModel/GetUE",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(UEModelServer).GetUE(ctx, req.(*GetUERequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _UEModel_MoveToCell_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MoveToCellRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(UEModelServer).MoveToCell(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/onos.ransim.model.UEModel/MoveToCell",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(UEModelServer).MoveToCell(ctx, req.(*MoveToCellRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _UEModel_MoveToLocation_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MoveToLocationRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(UEModelServer).MoveToLocation(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/onos.ransim.model.UEModel/MoveToLocation",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(UEModelServer).MoveToLocation(ctx, req.(*MoveToLocationRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _UEModel_DeleteUE_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteUERequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(UEModelServer).DeleteUE(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/onos.ransim.model.UEModel/DeleteUE",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(UEModelServer).DeleteUE(ctx, req.(*DeleteUERequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _UEModel_WatchUEs_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(WatchUEsRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(UEModelServer).WatchUEs(m, &uEModelWatchUEsServer{stream})
}

type UEModel_WatchUEsServer interface {
	Send(*WatchUEsResponse) error
	grpc.ServerStream
}

type uEModelWatchUEsServer struct {
	grpc.ServerStream
}

func (x *uEModelWatchUEsServer) Send(m *WatchUEsResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _UEModel_ListUEs_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(ListUEsRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(UEModelServer).ListUEs(m, &uEModelListUEsServer{stream})
}

type UEModel_ListUEsServer interface {
	Send(*ListUEsResponse) error
	grpc.ServerStream
}

type uEModelListUEsServer struct {
	grpc.ServerStream
}

func (x *uEModelListUEsServer) Send(m *ListUEsResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _UEModel_GetUECount_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetUECountRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(UEModelServer).GetUECount(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/onos.ransim.model.UEModel/GetUECount",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(UEModelServer).GetUECount(ctx, req.(*GetUECountRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _UEModel_SetUECount_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SetUECountRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(UEModelServer).SetUECount(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/onos.ransim.model.UEModel/SetUECount",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(UEModelServer).SetUECount(ctx, req.(*SetUECountRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _UEModel_serviceDesc = grpc.ServiceDesc{
	ServiceName: "onos.ransim.model.UEModel",
	HandlerType: (*UEModelServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetUE",
			Handler:    _UEModel_GetUE_Handler,
		},
		{
			MethodName: "MoveToCell",
			Handler:    _UEModel_MoveToCell_Handler,
		},
		{
			MethodName: "MoveToLocation",
			Handler:    _UEModel_MoveToLocation_Handler,
		},
		{
			MethodName: "DeleteUE",
			Handler:    _UEModel_DeleteUE_Handler,
		},
		{
			MethodName: "GetUECount",
			Handler:    _UEModel_GetUECount_Handler,
		},
		{
			MethodName: "SetUECount",
			Handler:    _UEModel_SetUECount_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "WatchUEs",
			Handler:       _UEModel_WatchUEs_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "ListUEs",
			Handler:       _UEModel_ListUEs_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "onos/ransim/model/model.proto",
}

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

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

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

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

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

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

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

func (m *ClearRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Resume {
		i--
		if m.Resume {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

func (m *PlmnIDResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.PlmnID != 0 {
		i = encodeVarintModel(dAtA, i, uint64(m.PlmnID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

func (m *GetNodeRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.GnbID != 0 {
		i = encodeVarintModel(dAtA, i, uint64(m.GnbID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

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

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

func (m *DeleteNodeRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.GnbID != 0 {
		i = encodeVarintModel(dAtA, i, uint64(m.GnbID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

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

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

func (m *WatchNodesRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.NoSubscribe {
		i--
		if m.NoSubscribe {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x10
	}
	if m.NoReplay {
		i--
		if m.NoReplay {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *WatchNodesResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Type != 0 {
		i = encodeVarintModel(dAtA, i, uint64(m.Type))
		i--
		dAtA[i] = 0x10
	}
	if m.Node != nil {
		{
			size, err := m.Node.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintModel(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *AgentControlRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Args) > 0 {
		for iNdEx := len(m.Args) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Args[iNdEx])
			copy(dAtA[i:], m.Args[iNdEx])
			i = encodeVarintModel(dAtA, i, uint64(len(m.Args[iNdEx])))
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.Command) > 0 {
		i -= len(m.Command)
		copy(dAtA[i:], m.Command)
		i = encodeVarintModel(dAtA, i, uint64(len(m.Command)))
		i--
		dAtA[i] = 0x12
	}
	if m.GnbID != 0 {
		i = encodeVarintModel(dAtA, i, uint64(m.GnbID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

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

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

func (m *GetCellRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.NCGI != 0 {
		i = encodeVarintModel(dAtA, i, uint64(m.NCGI))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

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

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

func (m *DeleteCellRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.NCGI != 0 {
		i = encodeVarintModel(dAtA, i, uint64(m.NCGI))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *WatchCellsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.NoSubscribe {
		i--
		if m.NoSubscribe {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x10
	}
	if m.NoReplay {
		i--
		if m.NoReplay {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *WatchCellsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Type != 0 {
		i = encodeVarintModel(dAtA, i, uint64(m.Type))
		i--
		dAtA[i] = 0x10
	}
	if m.Cell != nil {
		{
			size, err := m.Cell.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintModel(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

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

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

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

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

func (m *GetRouteRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.IMSI != 0 {
		i = encodeVarintModel(dAtA, i, uint64(m.IMSI))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *DeleteRouteRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.IMSI != 0 {
		i = encodeVarintModel(dAtA, i, uint64(m.IMSI))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *WatchRoutesRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.NoSubscribe {
		i--
		if m.NoSubscribe {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x10
	}
	if m.NoReplay {
		i--
		if m.NoReplay {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *WatchRoutesResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Type != 0 {
		i = encodeVarintModel(dAtA, i, uint64(m.Type))
		i--
		dAtA[i] = 0x10
	}
	if m.Route != nil {
		{
			size, err := m.Route.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintModel(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

func (m *GetUERequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.IMSI != 0 {
		i = encodeVarintModel(dAtA, i, uint64(m.IMSI))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *MoveToCellRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.NCGI != 0 {
		i = encodeVarintModel(dAtA, i, uint64(m.NCGI))
		i--
		dAtA[i] = 0x10
	}
	if m.IMSI != 0 {
		i = encodeVarintModel(dAtA, i, uint64(m.IMSI))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *MoveToLocationRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Heading != 0 {
		i = encodeVarintModel(dAtA, i, uint64(m.Heading))
		i--
		dAtA[i] = 0x18
	}
	if m.Location != nil {
		{
			size, err := m.Location.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintModel(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.IMSI != 0 {
		i = encodeVarintModel(dAtA, i, uint64(m.IMSI))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *DeleteUERequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.IMSI != 0 {
		i = encodeVarintModel(dAtA, i, uint64(m.IMSI))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *WatchUEsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.NoSubscribe {
		i--
		if m.NoSubscribe {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x10
	}
	if m.NoReplay {
		i--
		if m.NoReplay {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *WatchUEsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Type != 0 {
		i = encodeVarintModel(dAtA, i, uint64(m.Type))
		i--
		dAtA[i] = 0x10
	}
	if m.Ue != nil {
		{
			size, err := m.Ue.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintModel(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

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

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

func (m *GetUECountResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Count != 0 {
		i = encodeVarintModel(dAtA, i, uint64(m.Count))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *SetUECountRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Count != 0 {
		i = encodeVarintModel(dAtA, i, uint64(m.Count))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *LoadRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.DataSet) > 0 {
		for _, e := range m.DataSet {
			l = e.Size()
			n += 1 + l + sovModel(uint64(l))
		}
	}
	if m.Resume {
		n += 2
	}
	return n
}

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

func (m *ClearRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Resume {
		n += 2
	}
	return n
}

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

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

func (m *PlmnIDResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.PlmnID != 0 {
		n += 1 + sovModel(uint64(m.PlmnID))
	}
	return n
}

func (m *CreateNodeRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Node != nil {
		l = m.Node.Size()
		n += 1 + l + sovModel(uint64(l))
	}
	return n
}

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

func (m *GetNodeRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.GnbID != 0 {
		n += 1 + sovModel(uint64(m.GnbID))
	}
	return n
}

func (m *GetNodeResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Node != nil {
		l = m.Node.Size()
		n += 1 + l + sovModel(uint64(l))
	}
	return n
}

func (m *UpdateNodeRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Node != nil {
		l = m.Node.Size()
		n += 1 + l + sovModel(uint64(l))
	}
	return n
}

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

func (m *DeleteNodeRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.GnbID != 0 {
		n += 1 + sovModel(uint64(m.GnbID))
	}
	return n
}

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

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

func (m *ListNodesResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Node != nil {
		l = m.Node.Size()
		n += 1 + l + sovModel(uint64(l))
	}
	return n
}

func (m *WatchNodesRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.NoReplay {
		n += 2
	}
	if m.NoSubscribe {
		n += 2
	}
	return n
}

func (m *WatchNodesResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Node != nil {
		l = m.Node.Size()
		n += 1 + l + sovModel(uint64(l))
	}
	if m.Type != 0 {
		n += 1 + sovModel(uint64(m.Type))
	}
	return n
}

func (m *AgentControlRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.GnbID != 0 {
		n += 1 + sovModel(uint64(m.GnbID))
	}
	l = len(m.Command)
	if l > 0 {
		n += 1 + l + sovModel(uint64(l))
	}
	if len(m.Args) > 0 {
		for _, s := range m.Args {
			l = len(s)
			n += 1 + l + sovModel(uint64(l))
		}
	}
	return n
}

func (m *AgentControlResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Node != nil {
		l = m.Node.Size()
		n += 1 + l + sovModel(uint64(l))
	}
	return n
}

func (m *CreateCellRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Cell != nil {
		l = m.Cell.Size()
		n += 1 + l + sovModel(uint64(l))
	}
	return n
}

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

func (m *GetCellRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.NCGI != 0 {
		n += 1 + sovModel(uint64(m.NCGI))
	}
	return n
}

func (m *GetCellResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Cell != nil {
		l = m.Cell.Size()
		n += 1 + l + sovModel(uint64(l))
	}
	return n
}

func (m *UpdateCellRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Cell != nil {
		l = m.Cell.Size()
		n += 1 + l + sovModel(uint64(l))
	}
	return n
}

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

func (m *DeleteCellRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.NCGI != 0 {
		n += 1 + sovModel(uint64(m.NCGI))
	}
	return n
}

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

func (m *WatchCellsRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.NoReplay {
		n += 2
	}
	if m.NoSubscribe {
		n += 2
	}
	return n
}

func (m *WatchCellsResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Cell != nil {
		l = m.Cell.Size()
		n += 1 + l + sovModel(uint64(l))
	}
	if m.Type != 0 {
		n += 1 + sovModel(uint64(m.Type))
	}
	return n
}

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

func (m *ListCellsResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Cell != nil {
		l = m.Cell.Size()
		n += 1 + l + sovModel(uint64(l))
	}
	return n
}

func (m *CreateRouteRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Route != nil {
		l = m.Route.Size()
		n += 1 + l + sovModel(uint64(l))
	}
	return n
}

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

func (m *GetRouteRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.IMSI != 0 {
		n += 1 + sovModel(uint64(m.IMSI))
	}
	return n
}

func (m *GetRouteResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Route != nil {
		l = m.Route.Size()
		n += 1 + l + sovModel(uint64(l))
	}
	return n
}

func (m *DeleteRouteRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.IMSI != 0 {
		n += 1 + sovModel(uint64(m.IMSI))
	}
	return n
}

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

func (m *WatchRoutesRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.NoReplay {
		n += 2
	}
	if m.NoSubscribe {
		n += 2
	}
	return n
}

func (m *WatchRoutesResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Route != nil {
		l = m.Route.Size()
		n += 1 + l + sovModel(uint64(l))
	}
	if m.Type != 0 {
		n += 1 + sovModel(uint64(m.Type))
	}
	return n
}

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

func (m *ListRoutesResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Route != nil {
		l = m.Route.Size()
		n += 1 + l + sovModel(uint64(l))
	}
	return n
}

func (m *GetUERequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.IMSI != 0 {
		n += 1 + sovModel(uint64(m.IMSI))
	}
	return n
}

func (m *GetUEResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Ue != nil {
		l = m.Ue.Size()
		n += 1 + l + sovModel(uint64(l))
	}
	return n
}

func (m *MoveToCellRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.IMSI != 0 {
		n += 1 + sovModel(uint64(m.IMSI))
	}
	if m.NCGI != 0 {
		n += 1 + sovModel(uint64(m.NCGI))
	}
	return n
}

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

func (m *MoveToLocationRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.IMSI != 0 {
		n += 1 + sovModel(uint64(m.IMSI))
	}
	if m.Location != nil {
		l = m.Location.Size()
		n += 1 + l + sovModel(uint64(l))
	}
	if m.Heading != 0 {
		n += 1 + sovModel(uint64(m.Heading))
	}
	return n
}

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

func (m *DeleteUERequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.IMSI != 0 {
		n += 1 + sovModel(uint64(m.IMSI))
	}
	return n
}

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

func (m *WatchUEsRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.NoReplay {
		n += 2
	}
	if m.NoSubscribe {
		n += 2
	}
	return n
}

func (m *WatchUEsResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Ue != nil {
		l = m.Ue.Size()
		n += 1 + l + sovModel(uint64(l))
	}
	if m.Type != 0 {
		n += 1 + sovModel(uint64(m.Type))
	}
	return n
}

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

func (m *ListUEsResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Ue != nil {
		l = m.Ue.Size()
		n += 1 + l + sovModel(uint64(l))
	}
	return n
}

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

func (m *GetUECountResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Count != 0 {
		n += 1 + sovModel(uint64(m.Count))
	}
	return n
}

func (m *SetUECountRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Count != 0 {
		n += 1 + sovModel(uint64(m.Count))
	}
	return n
}

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

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

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ClearRequest) 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 ErrIntOverflowModel
			}
			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: ClearRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ClearRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Resume", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModel
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Resume = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipModel(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModel
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *PlmnIDResponse) 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 ErrIntOverflowModel
			}
			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: PlmnIDResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PlmnIDResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PlmnID", wireType)
			}
			m.PlmnID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModel
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PlmnID |= github_com_onosproject_onos_api_go_onos_ransim_types.PlmnID(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipModel(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModel
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GetNodeRequest) 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 ErrIntOverflowModel
			}
			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: GetNodeRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetNodeRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field GnbID", wireType)
			}
			m.GnbID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModel
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.GnbID |= github_com_onosproject_onos_api_go_onos_ransim_types.GnbID(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipModel(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModel
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DeleteNodeRequest) 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 ErrIntOverflowModel
			}
			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: DeleteNodeRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DeleteNodeRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field GnbID", wireType)
			}
			m.GnbID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModel
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.GnbID |= github_com_onosproject_onos_api_go_onos_ransim_types.GnbID(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipModel(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModel
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

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

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

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

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

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

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GetCellRequest) 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 ErrIntOverflowModel
			}
			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: GetCellRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetCellRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NCGI", wireType)
			}
			m.NCGI = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModel
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.NCGI |= github_com_onosproject_onos_api_go_onos_ransim_types.NCGI(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipModel(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModel
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DeleteCellRequest) 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 ErrIntOverflowModel
			}
			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: DeleteCellRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DeleteCellRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NCGI", wireType)
			}
			m.NCGI = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModel
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.NCGI |= github_com_onosproject_onos_api_go_onos_ransim_types.NCGI(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipModel(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModel
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

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

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

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

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GetRouteRequest) 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 ErrIntOverflowModel
			}
			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: GetRouteRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetRouteRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IMSI", wireType)
			}
			m.IMSI = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModel
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.IMSI |= github_com_onosproject_onos_api_go_onos_ransim_types.IMSI(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipModel(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModel
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DeleteRouteRequest) 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 ErrIntOverflowModel
			}
			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: DeleteRouteRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DeleteRouteRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IMSI", wireType)
			}
			m.IMSI = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModel
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.IMSI |= github_com_onosproject_onos_api_go_onos_ransim_types.IMSI(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipModel(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModel
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

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

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GetUERequest) 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 ErrIntOverflowModel
			}
			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: GetUERequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetUERequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IMSI", wireType)
			}
			m.IMSI = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModel
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.IMSI |= github_com_onosproject_onos_api_go_onos_ransim_types.IMSI(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipModel(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModel
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MoveToCellRequest) 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 ErrIntOverflowModel
			}
			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: MoveToCellRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MoveToCellRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IMSI", wireType)
			}
			m.IMSI = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModel
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.IMSI |= github_com_onosproject_onos_api_go_onos_ransim_types.IMSI(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NCGI", wireType)
			}
			m.NCGI = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModel
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.NCGI |= github_com_onosproject_onos_api_go_onos_ransim_types.NCGI(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipModel(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModel
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MoveToLocationRequest) 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 ErrIntOverflowModel
			}
			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: MoveToLocationRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MoveToLocationRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IMSI", wireType)
			}
			m.IMSI = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModel
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.IMSI |= github_com_onosproject_onos_api_go_onos_ransim_types.IMSI(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Location", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModel
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModel
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModel
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Location == nil {
				m.Location = &types.Point{}
			}
			if err := m.Location.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Heading", wireType)
			}
			m.Heading = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModel
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Heading |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipModel(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModel
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DeleteUERequest) 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 ErrIntOverflowModel
			}
			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: DeleteUERequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DeleteUERequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IMSI", wireType)
			}
			m.IMSI = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModel
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.IMSI |= github_com_onosproject_onos_api_go_onos_ransim_types.IMSI(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipModel(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModel
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

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

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

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GetUECountResponse) 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 ErrIntOverflowModel
			}
			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: GetUECountResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetUECountResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Count", wireType)
			}
			m.Count = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModel
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Count |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipModel(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModel
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SetUECountRequest) 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 ErrIntOverflowModel
			}
			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: SetUECountRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SetUECountRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Count", wireType)
			}
			m.Count = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModel
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Count |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipModel(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModel
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

var (
	ErrInvalidLengthModel        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowModel          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupModel = fmt.Errorf("proto: unexpected end of group")
)