rpc.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: api/v2rpc/rpc.proto

package v2rpc

import (
	context "context"
	fmt "fmt"
	_ "github.com/gogo/googleapis/google/api"
	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	golang_proto "github.com/golang/protobuf/proto"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	math "math"
	math_bits "math/bits"
)

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

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

type RangeFilter_Hash int32

const (
	RangeFilter_MD5  RangeFilter_Hash = 0
	RangeFilter_SHA1 RangeFilter_Hash = 1
)

var RangeFilter_Hash_name = map[int32]string{
	0: "MD5",
	1: "SHA1",
}

var RangeFilter_Hash_value = map[string]int32{
	"MD5":  0,
	"SHA1": 1,
}

func (x RangeFilter_Hash) String() string {
	return proto.EnumName(RangeFilter_Hash_name, int32(x))
}

func (RangeFilter_Hash) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_4fd62e805becb3ae, []int{4, 0}
}

type Event_EventType int32

const (
	Event_CREATE Event_EventType = 0
	Event_PUT    Event_EventType = 1
	Event_DELETE Event_EventType = 2
)

var Event_EventType_name = map[int32]string{
	0: "CREATE",
	1: "PUT",
	2: "DELETE",
}

var Event_EventType_value = map[string]int32{
	"CREATE": 0,
	"PUT":    1,
	"DELETE": 2,
}

func (x Event_EventType) String() string {
	return proto.EnumName(Event_EventType_name, int32(x))
}

func (Event_EventType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_4fd62e805becb3ae, []int{12, 0}
}

type ResponseHeader struct {
	// revision is tso which increases monotonically.
	Revision             uint64   `protobuf:"varint,1,opt,name=revision,proto3" json:"revision,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ResponseHeader) Reset()         { *m = ResponseHeader{} }
func (m *ResponseHeader) String() string { return proto.CompactTextString(m) }
func (*ResponseHeader) ProtoMessage()    {}
func (*ResponseHeader) Descriptor() ([]byte, []int) {
	return fileDescriptor_4fd62e805becb3ae, []int{0}
}
func (m *ResponseHeader) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ResponseHeader.Unmarshal(m, b)
}
func (m *ResponseHeader) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ResponseHeader.Marshal(b, m, deterministic)
}
func (m *ResponseHeader) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ResponseHeader.Merge(m, src)
}
func (m *ResponseHeader) XXX_Size() int {
	return xxx_messageInfo_ResponseHeader.Size(m)
}
func (m *ResponseHeader) XXX_DiscardUnknown() {
	xxx_messageInfo_ResponseHeader.DiscardUnknown(m)
}

var xxx_messageInfo_ResponseHeader proto.InternalMessageInfo

func (m *ResponseHeader) GetRevision() uint64 {
	if m != nil {
		return m.Revision
	}
	return 0
}

func (*ResponseHeader) XXX_MessageName() string {
	return "ResponseHeader"
}

type KeyValue struct {
	// key is the identifier in bytes. An empty key is not allowed.
	Key []byte `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	// revision is the revision of latest modification on this key.
	Revision uint64 `protobuf:"varint,2,opt,name=revision,proto3" json:"revision,omitempty"`
	// value is the value held by the key, in bytes.
	Value                []byte   `protobuf:"bytes,3,opt,name=value,proto3" json:"value,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *KeyValue) Reset()         { *m = KeyValue{} }
func (m *KeyValue) String() string { return proto.CompactTextString(m) }
func (*KeyValue) ProtoMessage()    {}
func (*KeyValue) Descriptor() ([]byte, []int) {
	return fileDescriptor_4fd62e805becb3ae, []int{1}
}
func (m *KeyValue) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_KeyValue.Unmarshal(m, b)
}
func (m *KeyValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_KeyValue.Marshal(b, m, deterministic)
}
func (m *KeyValue) XXX_Merge(src proto.Message) {
	xxx_messageInfo_KeyValue.Merge(m, src)
}
func (m *KeyValue) XXX_Size() int {
	return xxx_messageInfo_KeyValue.Size(m)
}
func (m *KeyValue) XXX_DiscardUnknown() {
	xxx_messageInfo_KeyValue.DiscardUnknown(m)
}

var xxx_messageInfo_KeyValue proto.InternalMessageInfo

func (m *KeyValue) GetKey() []byte {
	if m != nil {
		return m.Key
	}
	return nil
}

func (m *KeyValue) GetRevision() uint64 {
	if m != nil {
		return m.Revision
	}
	return 0
}

func (m *KeyValue) GetValue() []byte {
	if m != nil {
		return m.Value
	}
	return nil
}

func (*KeyValue) XXX_MessageName() string {
	return "KeyValue"
}

type GetRequest struct {
	// key is the identifier in bytes. An empty key is not allowed.
	Key []byte `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	// revision is the point-in-time of the key-value store to use for the get.
	// If revision is less or equal to zero, the range is over the newest key-value store.
	// If the revision has been compacted, ErrCompacted is returned as a response.
	Revision             uint64   `protobuf:"varint,2,opt,name=revision,proto3" json:"revision,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *GetRequest) Reset()         { *m = GetRequest{} }
func (m *GetRequest) String() string { return proto.CompactTextString(m) }
func (*GetRequest) ProtoMessage()    {}
func (*GetRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_4fd62e805becb3ae, []int{2}
}
func (m *GetRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GetRequest.Unmarshal(m, b)
}
func (m *GetRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GetRequest.Marshal(b, m, deterministic)
}
func (m *GetRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetRequest.Merge(m, src)
}
func (m *GetRequest) XXX_Size() int {
	return xxx_messageInfo_GetRequest.Size(m)
}
func (m *GetRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_GetRequest.DiscardUnknown(m)
}

var xxx_messageInfo_GetRequest proto.InternalMessageInfo

func (m *GetRequest) GetKey() []byte {
	if m != nil {
		return m.Key
	}
	return nil
}

func (m *GetRequest) GetRevision() uint64 {
	if m != nil {
		return m.Revision
	}
	return 0
}

func (*GetRequest) XXX_MessageName() string {
	return "GetRequest"
}

type GetResponse struct {
	Header *ResponseHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"`
	// kv is the key-value pair by the get request.
	Kv                   *KeyValue `protobuf:"bytes,2,opt,name=kv,proto3" json:"kv,omitempty"`
	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
	XXX_unrecognized     []byte    `json:"-"`
	XXX_sizecache        int32     `json:"-"`
}

func (m *GetResponse) Reset()         { *m = GetResponse{} }
func (m *GetResponse) String() string { return proto.CompactTextString(m) }
func (*GetResponse) ProtoMessage()    {}
func (*GetResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_4fd62e805becb3ae, []int{3}
}
func (m *GetResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GetResponse.Unmarshal(m, b)
}
func (m *GetResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GetResponse.Marshal(b, m, deterministic)
}
func (m *GetResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetResponse.Merge(m, src)
}
func (m *GetResponse) XXX_Size() int {
	return xxx_messageInfo_GetResponse.Size(m)
}
func (m *GetResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_GetResponse.DiscardUnknown(m)
}

var xxx_messageInfo_GetResponse proto.InternalMessageInfo

func (m *GetResponse) GetHeader() *ResponseHeader {
	if m != nil {
		return m.Header
	}
	return nil
}

func (m *GetResponse) GetKv() *KeyValue {
	if m != nil {
		return m.Kv
	}
	return nil
}

func (*GetResponse) XXX_MessageName() string {
	return "GetResponse"
}

type RangeFilter struct {
	// hash(key) % shard_num = shard_index
	Hash RangeFilter_Hash `protobuf:"varint,1,opt,name=hash,proto3,enum=RangeFilter_Hash" json:"hash,omitempty"`
	// trim prefix before hash
	TrimPrefix []byte `protobuf:"bytes,2,opt,name=trim_prefix,json=trimPrefix,proto3" json:"trim_prefix,omitempty"`
	// total shard number
	ShardCount int64 `protobuf:"varint,3,opt,name=shard_count,json=shardCount,proto3" json:"shard_count,omitempty"`
	// shard id to filter
	ShardIndex           int64    `protobuf:"varint,4,opt,name=shard_index,json=shardIndex,proto3" json:"shard_index,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *RangeFilter) Reset()         { *m = RangeFilter{} }
func (m *RangeFilter) String() string { return proto.CompactTextString(m) }
func (*RangeFilter) ProtoMessage()    {}
func (*RangeFilter) Descriptor() ([]byte, []int) {
	return fileDescriptor_4fd62e805becb3ae, []int{4}
}
func (m *RangeFilter) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_RangeFilter.Unmarshal(m, b)
}
func (m *RangeFilter) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_RangeFilter.Marshal(b, m, deterministic)
}
func (m *RangeFilter) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RangeFilter.Merge(m, src)
}
func (m *RangeFilter) XXX_Size() int {
	return xxx_messageInfo_RangeFilter.Size(m)
}
func (m *RangeFilter) XXX_DiscardUnknown() {
	xxx_messageInfo_RangeFilter.DiscardUnknown(m)
}

var xxx_messageInfo_RangeFilter proto.InternalMessageInfo

func (m *RangeFilter) GetHash() RangeFilter_Hash {
	if m != nil {
		return m.Hash
	}
	return RangeFilter_MD5
}

func (m *RangeFilter) GetTrimPrefix() []byte {
	if m != nil {
		return m.TrimPrefix
	}
	return nil
}

func (m *RangeFilter) GetShardCount() int64 {
	if m != nil {
		return m.ShardCount
	}
	return 0
}

func (m *RangeFilter) GetShardIndex() int64 {
	if m != nil {
		return m.ShardIndex
	}
	return 0
}

func (*RangeFilter) XXX_MessageName() string {
	return "RangeFilter"
}

type RangeRequest struct {
	// key is the first key for the range.
	Key []byte `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	// end is the upper bound on the requested range [key, end).
	End []byte `protobuf:"bytes,2,opt,name=end,proto3" json:"end,omitempty"`
	// limit is a limit on the number of keys returned for the request. When limit is set to 0,
	// it is treated as no limit.
	Limit int64 `protobuf:"varint,3,opt,name=limit,proto3" json:"limit,omitempty"`
	// revision is the point-in-time of the key-value store to use for the range.
	// If revision is less or equal to zero, the range is over the newest key-value store.
	// If the revision has been compacted, ErrCompacted is returned as a response.
	Revision uint64 `protobuf:"varint,4,opt,name=revision,proto3" json:"revision,omitempty"`
	// filter when range, only key satisfying filter condition will be returned
	Filter               *RangeFilter `protobuf:"bytes,5,opt,name=filter,proto3" json:"filter,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

func (m *RangeRequest) Reset()         { *m = RangeRequest{} }
func (m *RangeRequest) String() string { return proto.CompactTextString(m) }
func (*RangeRequest) ProtoMessage()    {}
func (*RangeRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_4fd62e805becb3ae, []int{5}
}
func (m *RangeRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_RangeRequest.Unmarshal(m, b)
}
func (m *RangeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_RangeRequest.Marshal(b, m, deterministic)
}
func (m *RangeRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RangeRequest.Merge(m, src)
}
func (m *RangeRequest) XXX_Size() int {
	return xxx_messageInfo_RangeRequest.Size(m)
}
func (m *RangeRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RangeRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RangeRequest proto.InternalMessageInfo

func (m *RangeRequest) GetKey() []byte {
	if m != nil {
		return m.Key
	}
	return nil
}

func (m *RangeRequest) GetEnd() []byte {
	if m != nil {
		return m.End
	}
	return nil
}

func (m *RangeRequest) GetLimit() int64 {
	if m != nil {
		return m.Limit
	}
	return 0
}

func (m *RangeRequest) GetRevision() uint64 {
	if m != nil {
		return m.Revision
	}
	return 0
}

func (m *RangeRequest) GetFilter() *RangeFilter {
	if m != nil {
		return m.Filter
	}
	return nil
}

func (*RangeRequest) XXX_MessageName() string {
	return "RangeRequest"
}

type RangeResponse struct {
	Header *ResponseHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"`
	// kvs is the list of key-value pairs matched by the range request.
	Kvs []*KeyValue `protobuf:"bytes,2,rep,name=kvs,proto3" json:"kvs,omitempty"`
	// more indicates if there are more keys to return in the requested range.
	More                 bool     `protobuf:"varint,3,opt,name=more,proto3" json:"more,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *RangeResponse) Reset()         { *m = RangeResponse{} }
func (m *RangeResponse) String() string { return proto.CompactTextString(m) }
func (*RangeResponse) ProtoMessage()    {}
func (*RangeResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_4fd62e805becb3ae, []int{6}
}
func (m *RangeResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_RangeResponse.Unmarshal(m, b)
}
func (m *RangeResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_RangeResponse.Marshal(b, m, deterministic)
}
func (m *RangeResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RangeResponse.Merge(m, src)
}
func (m *RangeResponse) XXX_Size() int {
	return xxx_messageInfo_RangeResponse.Size(m)
}
func (m *RangeResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RangeResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RangeResponse proto.InternalMessageInfo

func (m *RangeResponse) GetHeader() *ResponseHeader {
	if m != nil {
		return m.Header
	}
	return nil
}

func (m *RangeResponse) GetKvs() []*KeyValue {
	if m != nil {
		return m.Kvs
	}
	return nil
}

func (m *RangeResponse) GetMore() bool {
	if m != nil {
		return m.More
	}
	return false
}

func (*RangeResponse) XXX_MessageName() string {
	return "RangeResponse"
}

type StreamRangeResponse struct {
	RangeResponse        *RangeResponse `protobuf:"bytes,1,opt,name=range_response,json=rangeResponse,proto3" json:"range_response,omitempty"`
	Err                  string         `protobuf:"bytes,2,opt,name=err,proto3" json:"err,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

func (m *StreamRangeResponse) Reset()         { *m = StreamRangeResponse{} }
func (m *StreamRangeResponse) String() string { return proto.CompactTextString(m) }
func (*StreamRangeResponse) ProtoMessage()    {}
func (*StreamRangeResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_4fd62e805becb3ae, []int{7}
}
func (m *StreamRangeResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_StreamRangeResponse.Unmarshal(m, b)
}
func (m *StreamRangeResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_StreamRangeResponse.Marshal(b, m, deterministic)
}
func (m *StreamRangeResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StreamRangeResponse.Merge(m, src)
}
func (m *StreamRangeResponse) XXX_Size() int {
	return xxx_messageInfo_StreamRangeResponse.Size(m)
}
func (m *StreamRangeResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_StreamRangeResponse.DiscardUnknown(m)
}

var xxx_messageInfo_StreamRangeResponse proto.InternalMessageInfo

func (m *StreamRangeResponse) GetRangeResponse() *RangeResponse {
	if m != nil {
		return m.RangeResponse
	}
	return nil
}

func (m *StreamRangeResponse) GetErr() string {
	if m != nil {
		return m.Err
	}
	return ""
}

func (*StreamRangeResponse) XXX_MessageName() string {
	return "StreamRangeResponse"
}

type CountRequest struct {
	// key is the first key for the count.
	Key []byte `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	// end is the upper bound on the requested count [key, end).
	End []byte `protobuf:"bytes,2,opt,name=end,proto3" json:"end,omitempty"`
	// filter when count, only keys which satisfy filter condition requirement will be counted
	Filter               *RangeFilter `protobuf:"bytes,3,opt,name=filter,proto3" json:"filter,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

func (m *CountRequest) Reset()         { *m = CountRequest{} }
func (m *CountRequest) String() string { return proto.CompactTextString(m) }
func (*CountRequest) ProtoMessage()    {}
func (*CountRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_4fd62e805becb3ae, []int{8}
}
func (m *CountRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CountRequest.Unmarshal(m, b)
}
func (m *CountRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CountRequest.Marshal(b, m, deterministic)
}
func (m *CountRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CountRequest.Merge(m, src)
}
func (m *CountRequest) XXX_Size() int {
	return xxx_messageInfo_CountRequest.Size(m)
}
func (m *CountRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_CountRequest.DiscardUnknown(m)
}

var xxx_messageInfo_CountRequest proto.InternalMessageInfo

func (m *CountRequest) GetKey() []byte {
	if m != nil {
		return m.Key
	}
	return nil
}

func (m *CountRequest) GetEnd() []byte {
	if m != nil {
		return m.End
	}
	return nil
}

func (m *CountRequest) GetFilter() *RangeFilter {
	if m != nil {
		return m.Filter
	}
	return nil
}

func (*CountRequest) XXX_MessageName() string {
	return "CountRequest"
}

type CountResponse struct {
	Header *ResponseHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"`
	// count is set to the number of keys within the range when requested.
	Count                uint64   `protobuf:"varint,2,opt,name=count,proto3" json:"count,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *CountResponse) Reset()         { *m = CountResponse{} }
func (m *CountResponse) String() string { return proto.CompactTextString(m) }
func (*CountResponse) ProtoMessage()    {}
func (*CountResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_4fd62e805becb3ae, []int{9}
}
func (m *CountResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CountResponse.Unmarshal(m, b)
}
func (m *CountResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CountResponse.Marshal(b, m, deterministic)
}
func (m *CountResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CountResponse.Merge(m, src)
}
func (m *CountResponse) XXX_Size() int {
	return xxx_messageInfo_CountResponse.Size(m)
}
func (m *CountResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_CountResponse.DiscardUnknown(m)
}

var xxx_messageInfo_CountResponse proto.InternalMessageInfo

func (m *CountResponse) GetHeader() *ResponseHeader {
	if m != nil {
		return m.Header
	}
	return nil
}

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

func (*CountResponse) XXX_MessageName() string {
	return "CountResponse"
}

type ListPartitionRequest struct {
	// key is the first key for partition list.
	Key []byte `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	// end is the upper bound on the requested partition list [key, end).
	End                  []byte   `protobuf:"bytes,2,opt,name=end,proto3" json:"end,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ListPartitionRequest) Reset()         { *m = ListPartitionRequest{} }
func (m *ListPartitionRequest) String() string { return proto.CompactTextString(m) }
func (*ListPartitionRequest) ProtoMessage()    {}
func (*ListPartitionRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_4fd62e805becb3ae, []int{10}
}
func (m *ListPartitionRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ListPartitionRequest.Unmarshal(m, b)
}
func (m *ListPartitionRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ListPartitionRequest.Marshal(b, m, deterministic)
}
func (m *ListPartitionRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ListPartitionRequest.Merge(m, src)
}
func (m *ListPartitionRequest) XXX_Size() int {
	return xxx_messageInfo_ListPartitionRequest.Size(m)
}
func (m *ListPartitionRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_ListPartitionRequest.DiscardUnknown(m)
}

var xxx_messageInfo_ListPartitionRequest proto.InternalMessageInfo

func (m *ListPartitionRequest) GetKey() []byte {
	if m != nil {
		return m.Key
	}
	return nil
}

func (m *ListPartitionRequest) GetEnd() []byte {
	if m != nil {
		return m.End
	}
	return nil
}

func (*ListPartitionRequest) XXX_MessageName() string {
	return "ListPartitionRequest"
}

type ListPartitionResponse struct {
	Header *ResponseHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"`
	// partition_num is the number of partitions .
	PartitionNum int64 `protobuf:"varint,2,opt,name=partition_num,json=partitionNum,proto3" json:"partition_num,omitempty"`
	// partition_keys, format is [ key, partition_split keys ..., end ]
	PartitionKeys        [][]byte `protobuf:"bytes,3,rep,name=partition_keys,json=partitionKeys,proto3" json:"partition_keys,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ListPartitionResponse) Reset()         { *m = ListPartitionResponse{} }
func (m *ListPartitionResponse) String() string { return proto.CompactTextString(m) }
func (*ListPartitionResponse) ProtoMessage()    {}
func (*ListPartitionResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_4fd62e805becb3ae, []int{11}
}
func (m *ListPartitionResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ListPartitionResponse.Unmarshal(m, b)
}
func (m *ListPartitionResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ListPartitionResponse.Marshal(b, m, deterministic)
}
func (m *ListPartitionResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ListPartitionResponse.Merge(m, src)
}
func (m *ListPartitionResponse) XXX_Size() int {
	return xxx_messageInfo_ListPartitionResponse.Size(m)
}
func (m *ListPartitionResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_ListPartitionResponse.DiscardUnknown(m)
}

var xxx_messageInfo_ListPartitionResponse proto.InternalMessageInfo

func (m *ListPartitionResponse) GetHeader() *ResponseHeader {
	if m != nil {
		return m.Header
	}
	return nil
}

func (m *ListPartitionResponse) GetPartitionNum() int64 {
	if m != nil {
		return m.PartitionNum
	}
	return 0
}

func (m *ListPartitionResponse) GetPartitionKeys() [][]byte {
	if m != nil {
		return m.PartitionKeys
	}
	return nil
}

func (*ListPartitionResponse) XXX_MessageName() string {
	return "ListPartitionResponse"
}

type Event struct {
	// type is the kind of event. If type is a CREATE or PUT, it indicates
	// new data has been stored to the key. If type is a DELETE,
	// it indicates the key was deleted.
	Type Event_EventType `protobuf:"varint,1,opt,name=type,proto3,enum=Event_EventType" json:"type,omitempty"`
	// kv holds the KeyValue for the event.
	// A CREATE event indicates the creation of a key.
	// A PUT event contains current kv pair.
	// A DELETE/EXPIRE event contains the deleted key with
	// its modification revision set to the revision of deletion.
	Kv *KeyValue `protobuf:"bytes,2,opt,name=kv,proto3" json:"kv,omitempty"`
	// revision is tso which increases monotonically.
	Revision             uint64   `protobuf:"varint,3,opt,name=revision,proto3" json:"revision,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Event) Reset()         { *m = Event{} }
func (m *Event) String() string { return proto.CompactTextString(m) }
func (*Event) ProtoMessage()    {}
func (*Event) Descriptor() ([]byte, []int) {
	return fileDescriptor_4fd62e805becb3ae, []int{12}
}
func (m *Event) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Event.Unmarshal(m, b)
}
func (m *Event) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Event.Marshal(b, m, deterministic)
}
func (m *Event) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Event.Merge(m, src)
}
func (m *Event) XXX_Size() int {
	return xxx_messageInfo_Event.Size(m)
}
func (m *Event) XXX_DiscardUnknown() {
	xxx_messageInfo_Event.DiscardUnknown(m)
}

var xxx_messageInfo_Event proto.InternalMessageInfo

func (m *Event) GetType() Event_EventType {
	if m != nil {
		return m.Type
	}
	return Event_CREATE
}

func (m *Event) GetKv() *KeyValue {
	if m != nil {
		return m.Kv
	}
	return nil
}

func (m *Event) GetRevision() uint64 {
	if m != nil {
		return m.Revision
	}
	return 0
}

func (*Event) XXX_MessageName() string {
	return "Event"
}

type WatchRequest struct {
	// key is the first key for the range.
	Key []byte `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	// end is the upper bound on the requested range [key, end).
	End []byte `protobuf:"bytes,2,opt,name=end,proto3" json:"end,omitempty"`
	// revision is an optional revision to watch from (inclusive). No start_revision is "now".
	Revision uint64 `protobuf:"varint,4,opt,name=revision,proto3" json:"revision,omitempty"`
	// filter when watch, only events which satisfy filter condition requirement will be send to subscriber
	Filter               *RangeFilter `protobuf:"bytes,3,opt,name=filter,proto3" json:"filter,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

func (m *WatchRequest) Reset()         { *m = WatchRequest{} }
func (m *WatchRequest) String() string { return proto.CompactTextString(m) }
func (*WatchRequest) ProtoMessage()    {}
func (*WatchRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_4fd62e805becb3ae, []int{13}
}
func (m *WatchRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_WatchRequest.Unmarshal(m, b)
}
func (m *WatchRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_WatchRequest.Marshal(b, m, deterministic)
}
func (m *WatchRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_WatchRequest.Merge(m, src)
}
func (m *WatchRequest) XXX_Size() int {
	return xxx_messageInfo_WatchRequest.Size(m)
}
func (m *WatchRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_WatchRequest.DiscardUnknown(m)
}

var xxx_messageInfo_WatchRequest proto.InternalMessageInfo

func (m *WatchRequest) GetKey() []byte {
	if m != nil {
		return m.Key
	}
	return nil
}

func (m *WatchRequest) GetEnd() []byte {
	if m != nil {
		return m.End
	}
	return nil
}

func (m *WatchRequest) GetRevision() uint64 {
	if m != nil {
		return m.Revision
	}
	return 0
}

func (m *WatchRequest) GetFilter() *RangeFilter {
	if m != nil {
		return m.Filter
	}
	return nil
}

func (*WatchRequest) XXX_MessageName() string {
	return "WatchRequest"
}

type WatchResponse struct {
	Header *ResponseHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"`
	// events is the list of events matched by the watch request.
	Events []*Event `protobuf:"bytes,2,rep,name=events,proto3" json:"events,omitempty"`
	// err indicates internal err occurs.
	Err                  string   `protobuf:"bytes,5,opt,name=err,proto3" json:"err,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *WatchResponse) Reset()         { *m = WatchResponse{} }
func (m *WatchResponse) String() string { return proto.CompactTextString(m) }
func (*WatchResponse) ProtoMessage()    {}
func (*WatchResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_4fd62e805becb3ae, []int{14}
}
func (m *WatchResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_WatchResponse.Unmarshal(m, b)
}
func (m *WatchResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_WatchResponse.Marshal(b, m, deterministic)
}
func (m *WatchResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_WatchResponse.Merge(m, src)
}
func (m *WatchResponse) XXX_Size() int {
	return xxx_messageInfo_WatchResponse.Size(m)
}
func (m *WatchResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_WatchResponse.DiscardUnknown(m)
}

var xxx_messageInfo_WatchResponse proto.InternalMessageInfo

func (m *WatchResponse) GetHeader() *ResponseHeader {
	if m != nil {
		return m.Header
	}
	return nil
}

func (m *WatchResponse) GetEvents() []*Event {
	if m != nil {
		return m.Events
	}
	return nil
}

func (m *WatchResponse) GetErr() string {
	if m != nil {
		return m.Err
	}
	return ""
}

func (*WatchResponse) XXX_MessageName() string {
	return "WatchResponse"
}

type CreateRequest struct {
	// key is the subject key for the comparison operation.
	Key []byte `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	// value is the value of the given key, in bytes.
	Value []byte `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
	// lease is the lease ttl seconds of the given key.
	Lease                int64    `protobuf:"varint,3,opt,name=lease,proto3" json:"lease,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *CreateRequest) Reset()         { *m = CreateRequest{} }
func (m *CreateRequest) String() string { return proto.CompactTextString(m) }
func (*CreateRequest) ProtoMessage()    {}
func (*CreateRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_4fd62e805becb3ae, []int{15}
}
func (m *CreateRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CreateRequest.Unmarshal(m, b)
}
func (m *CreateRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CreateRequest.Marshal(b, m, deterministic)
}
func (m *CreateRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CreateRequest.Merge(m, src)
}
func (m *CreateRequest) XXX_Size() int {
	return xxx_messageInfo_CreateRequest.Size(m)
}
func (m *CreateRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_CreateRequest.DiscardUnknown(m)
}

var xxx_messageInfo_CreateRequest proto.InternalMessageInfo

func (m *CreateRequest) GetKey() []byte {
	if m != nil {
		return m.Key
	}
	return nil
}

func (m *CreateRequest) GetValue() []byte {
	if m != nil {
		return m.Value
	}
	return nil
}

func (m *CreateRequest) GetLease() int64 {
	if m != nil {
		return m.Lease
	}
	return 0
}

func (*CreateRequest) XXX_MessageName() string {
	return "CreateRequest"
}

type CreateResponse struct {
	Header *ResponseHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"`
	// succeeded is set to true if the compare evaluated to true or false otherwise.
	Succeeded            bool     `protobuf:"varint,2,opt,name=succeeded,proto3" json:"succeeded,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *CreateResponse) Reset()         { *m = CreateResponse{} }
func (m *CreateResponse) String() string { return proto.CompactTextString(m) }
func (*CreateResponse) ProtoMessage()    {}
func (*CreateResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_4fd62e805becb3ae, []int{16}
}
func (m *CreateResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CreateResponse.Unmarshal(m, b)
}
func (m *CreateResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CreateResponse.Marshal(b, m, deterministic)
}
func (m *CreateResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CreateResponse.Merge(m, src)
}
func (m *CreateResponse) XXX_Size() int {
	return xxx_messageInfo_CreateResponse.Size(m)
}
func (m *CreateResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_CreateResponse.DiscardUnknown(m)
}

var xxx_messageInfo_CreateResponse proto.InternalMessageInfo

func (m *CreateResponse) GetHeader() *ResponseHeader {
	if m != nil {
		return m.Header
	}
	return nil
}

func (m *CreateResponse) GetSucceeded() bool {
	if m != nil {
		return m.Succeeded
	}
	return false
}

func (*CreateResponse) XXX_MessageName() string {
	return "CreateResponse"
}

type UpdateRequest struct {
	Kv *KeyValue `protobuf:"bytes,1,opt,name=kv,proto3" json:"kv,omitempty"`
	// lease is the lease ttl seconds of the given key.
	Lease                int64    `protobuf:"varint,2,opt,name=lease,proto3" json:"lease,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *UpdateRequest) Reset()         { *m = UpdateRequest{} }
func (m *UpdateRequest) String() string { return proto.CompactTextString(m) }
func (*UpdateRequest) ProtoMessage()    {}
func (*UpdateRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_4fd62e805becb3ae, []int{17}
}
func (m *UpdateRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_UpdateRequest.Unmarshal(m, b)
}
func (m *UpdateRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_UpdateRequest.Marshal(b, m, deterministic)
}
func (m *UpdateRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_UpdateRequest.Merge(m, src)
}
func (m *UpdateRequest) XXX_Size() int {
	return xxx_messageInfo_UpdateRequest.Size(m)
}
func (m *UpdateRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_UpdateRequest.DiscardUnknown(m)
}

var xxx_messageInfo_UpdateRequest proto.InternalMessageInfo

func (m *UpdateRequest) GetKv() *KeyValue {
	if m != nil {
		return m.Kv
	}
	return nil
}

func (m *UpdateRequest) GetLease() int64 {
	if m != nil {
		return m.Lease
	}
	return 0
}

func (*UpdateRequest) XXX_MessageName() string {
	return "UpdateRequest"
}

type UpdateResponse struct {
	Header *ResponseHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"`
	// succeeded is set to true if the compare evaluated to true or false otherwise.
	Succeeded bool `protobuf:"varint,2,opt,name=succeeded,proto3" json:"succeeded,omitempty"`
	// kv is set to the key-value which is deleted, when the succeeded is false.
	Kv                   *KeyValue `protobuf:"bytes,3,opt,name=kv,proto3" json:"kv,omitempty"`
	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
	XXX_unrecognized     []byte    `json:"-"`
	XXX_sizecache        int32     `json:"-"`
}

func (m *UpdateResponse) Reset()         { *m = UpdateResponse{} }
func (m *UpdateResponse) String() string { return proto.CompactTextString(m) }
func (*UpdateResponse) ProtoMessage()    {}
func (*UpdateResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_4fd62e805becb3ae, []int{18}
}
func (m *UpdateResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_UpdateResponse.Unmarshal(m, b)
}
func (m *UpdateResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_UpdateResponse.Marshal(b, m, deterministic)
}
func (m *UpdateResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_UpdateResponse.Merge(m, src)
}
func (m *UpdateResponse) XXX_Size() int {
	return xxx_messageInfo_UpdateResponse.Size(m)
}
func (m *UpdateResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_UpdateResponse.DiscardUnknown(m)
}

var xxx_messageInfo_UpdateResponse proto.InternalMessageInfo

func (m *UpdateResponse) GetHeader() *ResponseHeader {
	if m != nil {
		return m.Header
	}
	return nil
}

func (m *UpdateResponse) GetSucceeded() bool {
	if m != nil {
		return m.Succeeded
	}
	return false
}

func (m *UpdateResponse) GetKv() *KeyValue {
	if m != nil {
		return m.Kv
	}
	return nil
}

func (*UpdateResponse) XXX_MessageName() string {
	return "UpdateResponse"
}

type DeleteRequest struct {
	// key is the subject key for the comparison operation.
	Key []byte `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	// revison is the revision of the given key, used to compare the revision and delete the value
	Revision             uint64   `protobuf:"varint,2,opt,name=revision,proto3" json:"revision,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *DeleteRequest) Reset()         { *m = DeleteRequest{} }
func (m *DeleteRequest) String() string { return proto.CompactTextString(m) }
func (*DeleteRequest) ProtoMessage()    {}
func (*DeleteRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_4fd62e805becb3ae, []int{19}
}
func (m *DeleteRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_DeleteRequest.Unmarshal(m, b)
}
func (m *DeleteRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_DeleteRequest.Marshal(b, m, deterministic)
}
func (m *DeleteRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DeleteRequest.Merge(m, src)
}
func (m *DeleteRequest) XXX_Size() int {
	return xxx_messageInfo_DeleteRequest.Size(m)
}
func (m *DeleteRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_DeleteRequest.DiscardUnknown(m)
}

var xxx_messageInfo_DeleteRequest proto.InternalMessageInfo

func (m *DeleteRequest) GetKey() []byte {
	if m != nil {
		return m.Key
	}
	return nil
}

func (m *DeleteRequest) GetRevision() uint64 {
	if m != nil {
		return m.Revision
	}
	return 0
}

func (*DeleteRequest) XXX_MessageName() string {
	return "DeleteRequest"
}

type DeleteResponse struct {
	Header *ResponseHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"`
	// succeeded is set to true if the compare evaluated to true or false otherwise.
	Succeeded bool `protobuf:"varint,2,opt,name=succeeded,proto3" json:"succeeded,omitempty"`
	// kv is set to the key-value which is deleted, when the succeeded is false.
	Kv                   *KeyValue `protobuf:"bytes,3,opt,name=kv,proto3" json:"kv,omitempty"`
	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
	XXX_unrecognized     []byte    `json:"-"`
	XXX_sizecache        int32     `json:"-"`
}

func (m *DeleteResponse) Reset()         { *m = DeleteResponse{} }
func (m *DeleteResponse) String() string { return proto.CompactTextString(m) }
func (*DeleteResponse) ProtoMessage()    {}
func (*DeleteResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_4fd62e805becb3ae, []int{20}
}
func (m *DeleteResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_DeleteResponse.Unmarshal(m, b)
}
func (m *DeleteResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_DeleteResponse.Marshal(b, m, deterministic)
}
func (m *DeleteResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DeleteResponse.Merge(m, src)
}
func (m *DeleteResponse) XXX_Size() int {
	return xxx_messageInfo_DeleteResponse.Size(m)
}
func (m *DeleteResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_DeleteResponse.DiscardUnknown(m)
}

var xxx_messageInfo_DeleteResponse proto.InternalMessageInfo

func (m *DeleteResponse) GetHeader() *ResponseHeader {
	if m != nil {
		return m.Header
	}
	return nil
}

func (m *DeleteResponse) GetSucceeded() bool {
	if m != nil {
		return m.Succeeded
	}
	return false
}

func (m *DeleteResponse) GetKv() *KeyValue {
	if m != nil {
		return m.Kv
	}
	return nil
}

func (*DeleteResponse) XXX_MessageName() string {
	return "DeleteResponse"
}

// CompactRequest compacts the key-value store up to a given revision. All superseded keys
// with a revision less than the compaction revision will be removed.
type CompactRequest struct {
	// revision is the key-value store revision for the compaction operation.
	Revision uint64 `protobuf:"varint,1,opt,name=revision,proto3" json:"revision,omitempty"`
	// physical is set so the RPC will wait until the compaction is physically
	// applied to the local database such that compacted entries are totally
	// removed from the backend database.
	Physical             bool     `protobuf:"varint,2,opt,name=physical,proto3" json:"physical,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *CompactRequest) Reset()         { *m = CompactRequest{} }
func (m *CompactRequest) String() string { return proto.CompactTextString(m) }
func (*CompactRequest) ProtoMessage()    {}
func (*CompactRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_4fd62e805becb3ae, []int{21}
}
func (m *CompactRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CompactRequest.Unmarshal(m, b)
}
func (m *CompactRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CompactRequest.Marshal(b, m, deterministic)
}
func (m *CompactRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CompactRequest.Merge(m, src)
}
func (m *CompactRequest) XXX_Size() int {
	return xxx_messageInfo_CompactRequest.Size(m)
}
func (m *CompactRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_CompactRequest.DiscardUnknown(m)
}

var xxx_messageInfo_CompactRequest proto.InternalMessageInfo

func (m *CompactRequest) GetRevision() uint64 {
	if m != nil {
		return m.Revision
	}
	return 0
}

func (m *CompactRequest) GetPhysical() bool {
	if m != nil {
		return m.Physical
	}
	return false
}

func (*CompactRequest) XXX_MessageName() string {
	return "CompactRequest"
}

type CompactResponse struct {
	Header               *ResponseHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

func (m *CompactResponse) Reset()         { *m = CompactResponse{} }
func (m *CompactResponse) String() string { return proto.CompactTextString(m) }
func (*CompactResponse) ProtoMessage()    {}
func (*CompactResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_4fd62e805becb3ae, []int{22}
}
func (m *CompactResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CompactResponse.Unmarshal(m, b)
}
func (m *CompactResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CompactResponse.Marshal(b, m, deterministic)
}
func (m *CompactResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CompactResponse.Merge(m, src)
}
func (m *CompactResponse) XXX_Size() int {
	return xxx_messageInfo_CompactResponse.Size(m)
}
func (m *CompactResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_CompactResponse.DiscardUnknown(m)
}

var xxx_messageInfo_CompactResponse proto.InternalMessageInfo

func (m *CompactResponse) GetHeader() *ResponseHeader {
	if m != nil {
		return m.Header
	}
	return nil
}

func (*CompactResponse) XXX_MessageName() string {
	return "CompactResponse"
}
func init() {
	proto.RegisterEnum("RangeFilter_Hash", RangeFilter_Hash_name, RangeFilter_Hash_value)
	golang_proto.RegisterEnum("RangeFilter_Hash", RangeFilter_Hash_name, RangeFilter_Hash_value)
	proto.RegisterEnum("Event_EventType", Event_EventType_name, Event_EventType_value)
	golang_proto.RegisterEnum("Event_EventType", Event_EventType_name, Event_EventType_value)
	proto.RegisterType((*ResponseHeader)(nil), "ResponseHeader")
	golang_proto.RegisterType((*ResponseHeader)(nil), "ResponseHeader")
	proto.RegisterType((*KeyValue)(nil), "KeyValue")
	golang_proto.RegisterType((*KeyValue)(nil), "KeyValue")
	proto.RegisterType((*GetRequest)(nil), "GetRequest")
	golang_proto.RegisterType((*GetRequest)(nil), "GetRequest")
	proto.RegisterType((*GetResponse)(nil), "GetResponse")
	golang_proto.RegisterType((*GetResponse)(nil), "GetResponse")
	proto.RegisterType((*RangeFilter)(nil), "RangeFilter")
	golang_proto.RegisterType((*RangeFilter)(nil), "RangeFilter")
	proto.RegisterType((*RangeRequest)(nil), "RangeRequest")
	golang_proto.RegisterType((*RangeRequest)(nil), "RangeRequest")
	proto.RegisterType((*RangeResponse)(nil), "RangeResponse")
	golang_proto.RegisterType((*RangeResponse)(nil), "RangeResponse")
	proto.RegisterType((*StreamRangeResponse)(nil), "StreamRangeResponse")
	golang_proto.RegisterType((*StreamRangeResponse)(nil), "StreamRangeResponse")
	proto.RegisterType((*CountRequest)(nil), "CountRequest")
	golang_proto.RegisterType((*CountRequest)(nil), "CountRequest")
	proto.RegisterType((*CountResponse)(nil), "CountResponse")
	golang_proto.RegisterType((*CountResponse)(nil), "CountResponse")
	proto.RegisterType((*ListPartitionRequest)(nil), "ListPartitionRequest")
	golang_proto.RegisterType((*ListPartitionRequest)(nil), "ListPartitionRequest")
	proto.RegisterType((*ListPartitionResponse)(nil), "ListPartitionResponse")
	golang_proto.RegisterType((*ListPartitionResponse)(nil), "ListPartitionResponse")
	proto.RegisterType((*Event)(nil), "Event")
	golang_proto.RegisterType((*Event)(nil), "Event")
	proto.RegisterType((*WatchRequest)(nil), "WatchRequest")
	golang_proto.RegisterType((*WatchRequest)(nil), "WatchRequest")
	proto.RegisterType((*WatchResponse)(nil), "WatchResponse")
	golang_proto.RegisterType((*WatchResponse)(nil), "WatchResponse")
	proto.RegisterType((*CreateRequest)(nil), "CreateRequest")
	golang_proto.RegisterType((*CreateRequest)(nil), "CreateRequest")
	proto.RegisterType((*CreateResponse)(nil), "CreateResponse")
	golang_proto.RegisterType((*CreateResponse)(nil), "CreateResponse")
	proto.RegisterType((*UpdateRequest)(nil), "UpdateRequest")
	golang_proto.RegisterType((*UpdateRequest)(nil), "UpdateRequest")
	proto.RegisterType((*UpdateResponse)(nil), "UpdateResponse")
	golang_proto.RegisterType((*UpdateResponse)(nil), "UpdateResponse")
	proto.RegisterType((*DeleteRequest)(nil), "DeleteRequest")
	golang_proto.RegisterType((*DeleteRequest)(nil), "DeleteRequest")
	proto.RegisterType((*DeleteResponse)(nil), "DeleteResponse")
	golang_proto.RegisterType((*DeleteResponse)(nil), "DeleteResponse")
	proto.RegisterType((*CompactRequest)(nil), "CompactRequest")
	golang_proto.RegisterType((*CompactRequest)(nil), "CompactRequest")
	proto.RegisterType((*CompactResponse)(nil), "CompactResponse")
	golang_proto.RegisterType((*CompactResponse)(nil), "CompactResponse")
}

func init() { proto.RegisterFile("api/v2rpc/rpc.proto", fileDescriptor_4fd62e805becb3ae) }
func init() { golang_proto.RegisterFile("api/v2rpc/rpc.proto", fileDescriptor_4fd62e805becb3ae) }

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

// ReadClient is the client API for Read service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type ReadClient interface {
	// get single key
	Get(ctx context.Context, in *GetRequest, opts ...grpc.CallOption) (*GetResponse, error)
	// range keys from key to end
	Range(ctx context.Context, in *RangeRequest, opts ...grpc.CallOption) (*RangeResponse, error)
	// rane keys in stream mode
	RangeStream(ctx context.Context, in *RangeRequest, opts ...grpc.CallOption) (Read_RangeStreamClient, error)
	// count keys from key to end
	Count(ctx context.Context, in *CountRequest, opts ...grpc.CallOption) (*CountResponse, error)
	// list partitions for keys from key to end
	ListPartition(ctx context.Context, in *ListPartitionRequest, opts ...grpc.CallOption) (*ListPartitionResponse, error)
}

type readClient struct {
	cc *grpc.ClientConn
}

func NewReadClient(cc *grpc.ClientConn) ReadClient {
	return &readClient{cc}
}

func (c *readClient) Get(ctx context.Context, in *GetRequest, opts ...grpc.CallOption) (*GetResponse, error) {
	out := new(GetResponse)
	err := c.cc.Invoke(ctx, "/Read/Get", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *readClient) Range(ctx context.Context, in *RangeRequest, opts ...grpc.CallOption) (*RangeResponse, error) {
	out := new(RangeResponse)
	err := c.cc.Invoke(ctx, "/Read/Range", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *readClient) RangeStream(ctx context.Context, in *RangeRequest, opts ...grpc.CallOption) (Read_RangeStreamClient, error) {
	stream, err := c.cc.NewStream(ctx, &_Read_serviceDesc.Streams[0], "/Read/RangeStream", opts...)
	if err != nil {
		return nil, err
	}
	x := &readRangeStreamClient{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 Read_RangeStreamClient interface {
	Recv() (*StreamRangeResponse, error)
	grpc.ClientStream
}

type readRangeStreamClient struct {
	grpc.ClientStream
}

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

func (c *readClient) Count(ctx context.Context, in *CountRequest, opts ...grpc.CallOption) (*CountResponse, error) {
	out := new(CountResponse)
	err := c.cc.Invoke(ctx, "/Read/Count", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *readClient) ListPartition(ctx context.Context, in *ListPartitionRequest, opts ...grpc.CallOption) (*ListPartitionResponse, error) {
	out := new(ListPartitionResponse)
	err := c.cc.Invoke(ctx, "/Read/ListPartition", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// ReadServer is the server API for Read service.
type ReadServer interface {
	// get single key
	Get(context.Context, *GetRequest) (*GetResponse, error)
	// range keys from key to end
	Range(context.Context, *RangeRequest) (*RangeResponse, error)
	// rane keys in stream mode
	RangeStream(*RangeRequest, Read_RangeStreamServer) error
	// count keys from key to end
	Count(context.Context, *CountRequest) (*CountResponse, error)
	// list partitions for keys from key to end
	ListPartition(context.Context, *ListPartitionRequest) (*ListPartitionResponse, error)
}

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

func (*UnimplementedReadServer) Get(ctx context.Context, req *GetRequest) (*GetResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Get not implemented")
}
func (*UnimplementedReadServer) Range(ctx context.Context, req *RangeRequest) (*RangeResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Range not implemented")
}
func (*UnimplementedReadServer) RangeStream(req *RangeRequest, srv Read_RangeStreamServer) error {
	return status.Errorf(codes.Unimplemented, "method RangeStream not implemented")
}
func (*UnimplementedReadServer) Count(ctx context.Context, req *CountRequest) (*CountResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Count not implemented")
}
func (*UnimplementedReadServer) ListPartition(ctx context.Context, req *ListPartitionRequest) (*ListPartitionResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListPartition not implemented")
}

func RegisterReadServer(s *grpc.Server, srv ReadServer) {
	s.RegisterService(&_Read_serviceDesc, srv)
}

func _Read_Get_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ReadServer).Get(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/Read/Get",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ReadServer).Get(ctx, req.(*GetRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Read_Range_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RangeRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ReadServer).Range(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/Read/Range",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ReadServer).Range(ctx, req.(*RangeRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Read_RangeStream_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(RangeRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ReadServer).RangeStream(m, &readRangeStreamServer{stream})
}

type Read_RangeStreamServer interface {
	Send(*StreamRangeResponse) error
	grpc.ServerStream
}

type readRangeStreamServer struct {
	grpc.ServerStream
}

func (x *readRangeStreamServer) Send(m *StreamRangeResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _Read_Count_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CountRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ReadServer).Count(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/Read/Count",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ReadServer).Count(ctx, req.(*CountRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Read_ListPartition_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListPartitionRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ReadServer).ListPartition(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/Read/ListPartition",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ReadServer).ListPartition(ctx, req.(*ListPartitionRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _Read_serviceDesc = grpc.ServiceDesc{
	ServiceName: "Read",
	HandlerType: (*ReadServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Get",
			Handler:    _Read_Get_Handler,
		},
		{
			MethodName: "Range",
			Handler:    _Read_Range_Handler,
		},
		{
			MethodName: "Count",
			Handler:    _Read_Count_Handler,
		},
		{
			MethodName: "ListPartition",
			Handler:    _Read_ListPartition_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "RangeStream",
			Handler:       _Read_RangeStream_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "api/v2rpc/rpc.proto",
}

// WatchClient is the client API for Watch service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type WatchClient interface {
	// Watch watches for events happening or that have happened. Both input and output
	// are streams; the input stream is for creating and canceling watchers and the output
	// stream sends events. One watch RPC can watch on multiple key ranges, streaming events
	// for several watches at once. The entire event history can be watched starting from the
	// last compaction revision.
	Watch(ctx context.Context, in *WatchRequest, opts ...grpc.CallOption) (Watch_WatchClient, error)
}

type watchClient struct {
	cc *grpc.ClientConn
}

func NewWatchClient(cc *grpc.ClientConn) WatchClient {
	return &watchClient{cc}
}

func (c *watchClient) Watch(ctx context.Context, in *WatchRequest, opts ...grpc.CallOption) (Watch_WatchClient, error) {
	stream, err := c.cc.NewStream(ctx, &_Watch_serviceDesc.Streams[0], "/Watch/Watch", opts...)
	if err != nil {
		return nil, err
	}
	x := &watchWatchClient{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 Watch_WatchClient interface {
	Recv() (*WatchResponse, error)
	grpc.ClientStream
}

type watchWatchClient struct {
	grpc.ClientStream
}

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

// WatchServer is the server API for Watch service.
type WatchServer interface {
	// Watch watches for events happening or that have happened. Both input and output
	// are streams; the input stream is for creating and canceling watchers and the output
	// stream sends events. One watch RPC can watch on multiple key ranges, streaming events
	// for several watches at once. The entire event history can be watched starting from the
	// last compaction revision.
	Watch(*WatchRequest, Watch_WatchServer) error
}

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

func (*UnimplementedWatchServer) Watch(req *WatchRequest, srv Watch_WatchServer) error {
	return status.Errorf(codes.Unimplemented, "method Watch not implemented")
}

func RegisterWatchServer(s *grpc.Server, srv WatchServer) {
	s.RegisterService(&_Watch_serviceDesc, srv)
}

func _Watch_Watch_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(WatchRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(WatchServer).Watch(m, &watchWatchServer{stream})
}

type Watch_WatchServer interface {
	Send(*WatchResponse) error
	grpc.ServerStream
}

type watchWatchServer struct {
	grpc.ServerStream
}

func (x *watchWatchServer) Send(m *WatchResponse) error {
	return x.ServerStream.SendMsg(m)
}

var _Watch_serviceDesc = grpc.ServiceDesc{
	ServiceName: "Watch",
	HandlerType: (*WatchServer)(nil),
	Methods:     []grpc.MethodDesc{},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "Watch",
			Handler:       _Watch_Watch_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "api/v2rpc/rpc.proto",
}

// WriteClient is the client API for Write service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type WriteClient interface {
	Create(ctx context.Context, in *CreateRequest, opts ...grpc.CallOption) (*CreateResponse, error)
	Update(ctx context.Context, in *UpdateRequest, opts ...grpc.CallOption) (*UpdateResponse, error)
	Delete(ctx context.Context, in *DeleteRequest, opts ...grpc.CallOption) (*DeleteResponse, error)
	Compact(ctx context.Context, in *CompactRequest, opts ...grpc.CallOption) (*CompactResponse, error)
}

type writeClient struct {
	cc *grpc.ClientConn
}

func NewWriteClient(cc *grpc.ClientConn) WriteClient {
	return &writeClient{cc}
}

func (c *writeClient) Create(ctx context.Context, in *CreateRequest, opts ...grpc.CallOption) (*CreateResponse, error) {
	out := new(CreateResponse)
	err := c.cc.Invoke(ctx, "/Write/Create", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *writeClient) Update(ctx context.Context, in *UpdateRequest, opts ...grpc.CallOption) (*UpdateResponse, error) {
	out := new(UpdateResponse)
	err := c.cc.Invoke(ctx, "/Write/Update", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *writeClient) Delete(ctx context.Context, in *DeleteRequest, opts ...grpc.CallOption) (*DeleteResponse, error) {
	out := new(DeleteResponse)
	err := c.cc.Invoke(ctx, "/Write/Delete", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *writeClient) Compact(ctx context.Context, in *CompactRequest, opts ...grpc.CallOption) (*CompactResponse, error) {
	out := new(CompactResponse)
	err := c.cc.Invoke(ctx, "/Write/Compact", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// WriteServer is the server API for Write service.
type WriteServer interface {
	Create(context.Context, *CreateRequest) (*CreateResponse, error)
	Update(context.Context, *UpdateRequest) (*UpdateResponse, error)
	Delete(context.Context, *DeleteRequest) (*DeleteResponse, error)
	Compact(context.Context, *CompactRequest) (*CompactResponse, error)
}

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

func (*UnimplementedWriteServer) Create(ctx context.Context, req *CreateRequest) (*CreateResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Create not implemented")
}
func (*UnimplementedWriteServer) Update(ctx context.Context, req *UpdateRequest) (*UpdateResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Update not implemented")
}
func (*UnimplementedWriteServer) Delete(ctx context.Context, req *DeleteRequest) (*DeleteResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Delete not implemented")
}
func (*UnimplementedWriteServer) Compact(ctx context.Context, req *CompactRequest) (*CompactResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Compact not implemented")
}

func RegisterWriteServer(s *grpc.Server, srv WriteServer) {
	s.RegisterService(&_Write_serviceDesc, srv)
}

func _Write_Create_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WriteServer).Create(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/Write/Create",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WriteServer).Create(ctx, req.(*CreateRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Write_Update_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WriteServer).Update(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/Write/Update",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WriteServer).Update(ctx, req.(*UpdateRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Write_Delete_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WriteServer).Delete(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/Write/Delete",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WriteServer).Delete(ctx, req.(*DeleteRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Write_Compact_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CompactRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WriteServer).Compact(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/Write/Compact",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WriteServer).Compact(ctx, req.(*CompactRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _Write_serviceDesc = grpc.ServiceDesc{
	ServiceName: "Write",
	HandlerType: (*WriteServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Create",
			Handler:    _Write_Create_Handler,
		},
		{
			MethodName: "Update",
			Handler:    _Write_Update_Handler,
		},
		{
			MethodName: "Delete",
			Handler:    _Write_Delete_Handler,
		},
		{
			MethodName: "Compact",
			Handler:    _Write_Compact_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "api/v2rpc/rpc.proto",
}

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

func (m *KeyValue) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Key)
	if l > 0 {
		n += 1 + l + sovRpc(uint64(l))
	}
	if m.Revision != 0 {
		n += 1 + sovRpc(uint64(m.Revision))
	}
	l = len(m.Value)
	if l > 0 {
		n += 1 + l + sovRpc(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *GetRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Key)
	if l > 0 {
		n += 1 + l + sovRpc(uint64(l))
	}
	if m.Revision != 0 {
		n += 1 + sovRpc(uint64(m.Revision))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *GetResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Header != nil {
		l = m.Header.Size()
		n += 1 + l + sovRpc(uint64(l))
	}
	if m.Kv != nil {
		l = m.Kv.Size()
		n += 1 + l + sovRpc(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *RangeFilter) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Hash != 0 {
		n += 1 + sovRpc(uint64(m.Hash))
	}
	l = len(m.TrimPrefix)
	if l > 0 {
		n += 1 + l + sovRpc(uint64(l))
	}
	if m.ShardCount != 0 {
		n += 1 + sovRpc(uint64(m.ShardCount))
	}
	if m.ShardIndex != 0 {
		n += 1 + sovRpc(uint64(m.ShardIndex))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *RangeRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Key)
	if l > 0 {
		n += 1 + l + sovRpc(uint64(l))
	}
	l = len(m.End)
	if l > 0 {
		n += 1 + l + sovRpc(uint64(l))
	}
	if m.Limit != 0 {
		n += 1 + sovRpc(uint64(m.Limit))
	}
	if m.Revision != 0 {
		n += 1 + sovRpc(uint64(m.Revision))
	}
	if m.Filter != nil {
		l = m.Filter.Size()
		n += 1 + l + sovRpc(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *RangeResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Header != nil {
		l = m.Header.Size()
		n += 1 + l + sovRpc(uint64(l))
	}
	if len(m.Kvs) > 0 {
		for _, e := range m.Kvs {
			l = e.Size()
			n += 1 + l + sovRpc(uint64(l))
		}
	}
	if m.More {
		n += 2
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *StreamRangeResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.RangeResponse != nil {
		l = m.RangeResponse.Size()
		n += 1 + l + sovRpc(uint64(l))
	}
	l = len(m.Err)
	if l > 0 {
		n += 1 + l + sovRpc(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *CountRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Key)
	if l > 0 {
		n += 1 + l + sovRpc(uint64(l))
	}
	l = len(m.End)
	if l > 0 {
		n += 1 + l + sovRpc(uint64(l))
	}
	if m.Filter != nil {
		l = m.Filter.Size()
		n += 1 + l + sovRpc(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *CountResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Header != nil {
		l = m.Header.Size()
		n += 1 + l + sovRpc(uint64(l))
	}
	if m.Count != 0 {
		n += 1 + sovRpc(uint64(m.Count))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ListPartitionRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Key)
	if l > 0 {
		n += 1 + l + sovRpc(uint64(l))
	}
	l = len(m.End)
	if l > 0 {
		n += 1 + l + sovRpc(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ListPartitionResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Header != nil {
		l = m.Header.Size()
		n += 1 + l + sovRpc(uint64(l))
	}
	if m.PartitionNum != 0 {
		n += 1 + sovRpc(uint64(m.PartitionNum))
	}
	if len(m.PartitionKeys) > 0 {
		for _, b := range m.PartitionKeys {
			l = len(b)
			n += 1 + l + sovRpc(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *Event) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Type != 0 {
		n += 1 + sovRpc(uint64(m.Type))
	}
	if m.Kv != nil {
		l = m.Kv.Size()
		n += 1 + l + sovRpc(uint64(l))
	}
	if m.Revision != 0 {
		n += 1 + sovRpc(uint64(m.Revision))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *WatchRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Key)
	if l > 0 {
		n += 1 + l + sovRpc(uint64(l))
	}
	l = len(m.End)
	if l > 0 {
		n += 1 + l + sovRpc(uint64(l))
	}
	if m.Revision != 0 {
		n += 1 + sovRpc(uint64(m.Revision))
	}
	if m.Filter != nil {
		l = m.Filter.Size()
		n += 1 + l + sovRpc(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *WatchResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Header != nil {
		l = m.Header.Size()
		n += 1 + l + sovRpc(uint64(l))
	}
	if len(m.Events) > 0 {
		for _, e := range m.Events {
			l = e.Size()
			n += 1 + l + sovRpc(uint64(l))
		}
	}
	l = len(m.Err)
	if l > 0 {
		n += 1 + l + sovRpc(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *CreateRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Key)
	if l > 0 {
		n += 1 + l + sovRpc(uint64(l))
	}
	l = len(m.Value)
	if l > 0 {
		n += 1 + l + sovRpc(uint64(l))
	}
	if m.Lease != 0 {
		n += 1 + sovRpc(uint64(m.Lease))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *CreateResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Header != nil {
		l = m.Header.Size()
		n += 1 + l + sovRpc(uint64(l))
	}
	if m.Succeeded {
		n += 2
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *UpdateRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Kv != nil {
		l = m.Kv.Size()
		n += 1 + l + sovRpc(uint64(l))
	}
	if m.Lease != 0 {
		n += 1 + sovRpc(uint64(m.Lease))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *UpdateResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Header != nil {
		l = m.Header.Size()
		n += 1 + l + sovRpc(uint64(l))
	}
	if m.Succeeded {
		n += 2
	}
	if m.Kv != nil {
		l = m.Kv.Size()
		n += 1 + l + sovRpc(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *DeleteRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Key)
	if l > 0 {
		n += 1 + l + sovRpc(uint64(l))
	}
	if m.Revision != 0 {
		n += 1 + sovRpc(uint64(m.Revision))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *DeleteResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Header != nil {
		l = m.Header.Size()
		n += 1 + l + sovRpc(uint64(l))
	}
	if m.Succeeded {
		n += 2
	}
	if m.Kv != nil {
		l = m.Kv.Size()
		n += 1 + l + sovRpc(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *CompactRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Revision != 0 {
		n += 1 + sovRpc(uint64(m.Revision))
	}
	if m.Physical {
		n += 2
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

func sovRpc(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozRpc(x uint64) (n int) {
	return sovRpc(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}