diff --git a/Gopkg.lock b/Gopkg.lock
index 85b2e80bfb92e..4215542250993 100644
--- a/Gopkg.lock
+++ b/Gopkg.lock
@@ -210,7 +210,7 @@
     "pkg/raft_serverpb",
     "pkg/tikvpb"
   ]
-  revision = "187ef904091a0381594224b321d284b0cee3a4f4"
+  revision = "2cf2492c337c4d0281d8ead8686d47764f1df6c4"
 
 [[projects]]
   name = "github.com/pingcap/pd"
diff --git a/store/mockstore/mocktikv/mvcc.go b/store/mockstore/mocktikv/mvcc.go
index 8428395c59ca8..7389bc77c0f1e 100644
--- a/store/mockstore/mocktikv/mvcc.go
+++ b/store/mockstore/mocktikv/mvcc.go
@@ -364,16 +364,16 @@ func (e *mvccEntry) containsStartTS(startTS uint64) bool {
 func (e *mvccEntry) dumpMvccInfo() *kvrpcpb.MvccInfo {
 	info := &kvrpcpb.MvccInfo{}
 	if e.lock != nil {
-		info.Lock = &kvrpcpb.LockInfo{
-			Key:         e.key,
-			PrimaryLock: e.lock.primary,
-			LockVersion: e.lock.startTS,
-			LockTtl:     e.lock.ttl,
+		info.Lock = &kvrpcpb.MvccLock{
+			Type:       e.lock.op,
+			StartTs:    e.lock.startTS,
+			Primary:    e.lock.primary,
+			ShortValue: e.lock.value,
 		}
 	}
 
-	info.Writes = make([]*kvrpcpb.WriteInfo, len(e.values))
-	info.Values = make([]*kvrpcpb.ValueInfo, len(e.values))
+	info.Writes = make([]*kvrpcpb.MvccWrite, len(e.values))
+	info.Values = make([]*kvrpcpb.MvccValue, len(e.values))
 
 	for id, item := range e.values {
 		var tp kvrpcpb.Op
@@ -385,15 +385,15 @@ func (e *mvccEntry) dumpMvccInfo() *kvrpcpb.MvccInfo {
 		case typeRollback:
 			tp = kvrpcpb.Op_Rollback
 		}
-		info.Writes[id] = &kvrpcpb.WriteInfo{
-			StartTs:  item.startTS,
+		info.Writes[id] = &kvrpcpb.MvccWrite{
 			Type:     tp,
+			StartTs:  item.startTS,
 			CommitTs: item.commitTS,
 		}
 
-		info.Values[id] = &kvrpcpb.ValueInfo{
-			Value: item.value,
-			Ts:    item.startTS,
+		info.Values[id] = &kvrpcpb.MvccValue{
+			Value:   item.value,
+			StartTs: item.startTS,
 		}
 	}
 	return info
diff --git a/store/tikv/region_request_test.go b/store/tikv/region_request_test.go
index f663ada863770..d929ca9470cd7 100644
--- a/store/tikv/region_request_test.go
+++ b/store/tikv/region_request_test.go
@@ -196,22 +196,33 @@ func (s *mockTikvGrpcServer) KvGC(context.Context, *kvrpcpb.GCRequest) (*kvrpcpb
 func (s *mockTikvGrpcServer) KvDeleteRange(context.Context, *kvrpcpb.DeleteRangeRequest) (*kvrpcpb.DeleteRangeResponse, error) {
 	return nil, errors.New("unreachable")
 }
-
 func (s *mockTikvGrpcServer) RawGet(context.Context, *kvrpcpb.RawGetRequest) (*kvrpcpb.RawGetResponse, error) {
 	return nil, errors.New("unreachable")
 }
+func (s *mockTikvGrpcServer) RawBatchGet(context.Context, *kvrpcpb.RawBatchGetRequest) (*kvrpcpb.RawBatchGetResponse, error) {
+	return nil, errors.New("unreachable")
+}
 func (s *mockTikvGrpcServer) RawPut(context.Context, *kvrpcpb.RawPutRequest) (*kvrpcpb.RawPutResponse, error) {
 	return nil, errors.New("unreachable")
 }
+func (s *mockTikvGrpcServer) RawBatchPut(context.Context, *kvrpcpb.RawBatchPutRequest) (*kvrpcpb.RawBatchPutResponse, error) {
+	return nil, errors.New("unreachable")
+}
 func (s *mockTikvGrpcServer) RawDelete(context.Context, *kvrpcpb.RawDeleteRequest) (*kvrpcpb.RawDeleteResponse, error) {
 	return nil, errors.New("unreachable")
 }
-func (s *mockTikvGrpcServer) RawDeleteRange(context.Context, *kvrpcpb.RawDeleteRangeRequest) (*kvrpcpb.RawDeleteRangeResponse, error) {
+func (s *mockTikvGrpcServer) RawBatchDelete(context.Context, *kvrpcpb.RawBatchDeleteRequest) (*kvrpcpb.RawBatchDeleteResponse, error) {
 	return nil, errors.New("unreachable")
 }
 func (s *mockTikvGrpcServer) RawScan(context.Context, *kvrpcpb.RawScanRequest) (*kvrpcpb.RawScanResponse, error) {
 	return nil, errors.New("unreachable")
 }
+func (s *mockTikvGrpcServer) RawDeleteRange(context.Context, *kvrpcpb.RawDeleteRangeRequest) (*kvrpcpb.RawDeleteRangeResponse, error) {
+	return nil, errors.New("unreachable")
+}
+func (s *mockTikvGrpcServer) RawBatchScan(context.Context, *kvrpcpb.RawBatchScanRequest) (*kvrpcpb.RawBatchScanResponse, error) {
+	return nil, errors.New("unreachable")
+}
 func (s *mockTikvGrpcServer) Coprocessor(context.Context, *coprocessor.Request) (*coprocessor.Response, error) {
 	return nil, errors.New("unreachable")
 }
diff --git a/vendor/github.com/pingcap/kvproto/pkg/coprocessor/coprocessor.pb.go b/vendor/github.com/pingcap/kvproto/pkg/coprocessor/coprocessor.pb.go
index 1109103555ee0..03a1644d7f451 100644
--- a/vendor/github.com/pingcap/kvproto/pkg/coprocessor/coprocessor.pb.go
+++ b/vendor/github.com/pingcap/kvproto/pkg/coprocessor/coprocessor.pb.go
@@ -1042,32 +1042,32 @@ var (
 func init() { proto.RegisterFile("coprocessor.proto", fileDescriptorCoprocessor) }
 
 var fileDescriptorCoprocessor = []byte{
-	// 419 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x74, 0x52, 0xcd, 0x6e, 0xd3, 0x40,
-	0x10, 0xae, 0xe3, 0xc4, 0x2d, 0xe3, 0xb4, 0x6a, 0x57, 0x41, 0xb2, 0x7a, 0x68, 0xaa, 0x9c, 0xa0,
-	0x08, 0x5b, 0x98, 0x43, 0xef, 0x81, 0x1e, 0x50, 0x39, 0x2d, 0x0f, 0x50, 0xf9, 0x67, 0x70, 0xac,
-	0x14, 0xef, 0xb2, 0xbb, 0xad, 0x92, 0x37, 0xe0, 0x11, 0x78, 0x18, 0x1e, 0x20, 0x47, 0xce, 0x1c,
-	0x22, 0x04, 0x2f, 0xc2, 0x7a, 0xd6, 0x0e, 0xb9, 0xf4, 0x60, 0xed, 0x37, 0xdf, 0x7c, 0xfb, 0xed,
-	0xcc, 0x27, 0xc3, 0x59, 0x21, 0xa4, 0x12, 0x05, 0x6a, 0x2d, 0x54, 0x6c, 0x91, 0x11, 0x2c, 0xdc,
-	0xa3, 0xce, 0x8f, 0x51, 0x29, 0xa1, 0x64, 0xee, 0x7a, 0xe7, 0xc7, 0xcb, 0x47, 0x25, 0x8b, 0x5d,
-	0x39, 0xa9, 0x44, 0x25, 0x08, 0x26, 0x2d, 0x72, 0xec, 0x2c, 0x85, 0xa3, 0x5b, 0x5c, 0xf3, 0xac,
-	0xa9, 0x90, 0x4d, 0x60, 0xa4, 0x4d, 0xa6, 0x4c, 0xe4, 0x5d, 0x7a, 0x2f, 0xc6, 0xdc, 0x15, 0xec,
-	0x14, 0x7c, 0x6c, 0xca, 0x68, 0x40, 0x5c, 0x0b, 0x67, 0xdf, 0x3c, 0x38, 0xe4, 0xf8, 0xf5, 0x01,
-	0xb5, 0x61, 0x57, 0x70, 0x58, 0x88, 0xc6, 0xe0, 0xca, 0xdd, 0x0a, 0xd3, 0xd3, 0xb8, 0x7f, 0xf6,
-	0x9d, 0xe3, 0x79, 0x2f, 0x60, 0x27, 0x30, 0x30, 0x92, 0x8c, 0x7c, 0x6e, 0x11, 0x63, 0x30, 0x2c,
-	0x33, 0x93, 0x45, 0x3e, 0x59, 0x13, 0x66, 0xaf, 0x21, 0x50, 0xed, 0x30, 0x3a, 0x1a, 0x5e, 0xfa,
-	0xd6, 0xee, 0x79, 0xbc, 0xbf, 0x74, 0x3f, 0x2a, 0xef, 0x44, 0xb3, 0x1f, 0x03, 0x38, 0xe2, 0xa8,
-	0xa5, 0x68, 0x34, 0xb2, 0xdb, 0xce, 0x8f, 0xc6, 0x9f, 0x5f, 0x6f, 0xb6, 0xd3, 0x83, 0x5f, 0xdb,
-	0x69, 0x52, 0xd5, 0x66, 0xf1, 0x90, 0x5b, 0x9f, 0x2f, 0x89, 0xac, 0x9b, 0xaa, 0xc8, 0x64, 0x62,
-	0x6a, 0x99, 0x27, 0x7a, 0x91, 0x29, 0x2c, 0xf3, 0xb5, 0x41, 0x1d, 0x7f, 0x22, 0x3c, 0x6f, 0x71,
-	0x37, 0xc8, 0x1b, 0x18, 0x2b, 0xac, 0x6a, 0xd1, 0xdc, 0x51, 0xaa, 0x34, 0x76, 0x98, 0x9e, 0xc4,
-	0x7d, 0xc6, 0x37, 0xed, 0xc9, 0x43, 0xa7, 0xa1, 0x82, 0xbd, 0x84, 0xe0, 0x5e, 0x14, 0x4b, 0x2c,
-	0x69, 0xa3, 0x30, 0x3d, 0xdb, 0x45, 0xf1, 0xd1, 0xd2, 0x1f, 0x9a, 0xcf, 0x82, 0x77, 0x02, 0x36,
-	0x85, 0x50, 0x98, 0x05, 0xaa, 0xce, 0x7c, 0x68, 0xf5, 0xcf, 0x38, 0x10, 0xe5, 0xbc, 0x5e, 0xc1,
-	0x88, 0x56, 0x8c, 0x46, 0x64, 0xf5, 0x44, 0x0c, 0x4e, 0xc3, 0xae, 0x61, 0x8c, 0x2b, 0x2c, 0xee,
-	0x4a, 0x34, 0x59, 0x7d, 0xaf, 0xa3, 0x80, 0xee, 0x4c, 0x76, 0xcf, 0xdf, 0xd8, 0xe6, 0x7b, 0xd7,
-	0xe3, 0x21, 0xfe, 0x2f, 0xe6, 0x57, 0x9b, 0x3f, 0x17, 0xde, 0x4f, 0xfb, 0xfd, 0xb6, 0xdf, 0xf7,
-	0xbf, 0x17, 0x07, 0x10, 0xd9, 0x98, 0xe2, 0x2e, 0xa6, 0xd8, 0xd4, 0xcb, 0x47, 0x6b, 0x42, 0x7f,
-	0x4a, 0x1e, 0xd0, 0xf1, 0xf6, 0x5f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x12, 0x5b, 0x89, 0x3d, 0x86,
-	0x02, 0x00, 0x00,
+	// 424 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x52, 0x4b, 0x6e, 0xdb, 0x30,
+	0x14, 0x8c, 0xfc, 0x4b, 0x4a, 0x39, 0x41, 0x42, 0xb8, 0x80, 0x90, 0x85, 0x6d, 0x78, 0xe5, 0xa6,
+	0x28, 0x85, 0xaa, 0x8b, 0xec, 0xdd, 0x66, 0x51, 0xa4, 0x2b, 0xf6, 0x00, 0x81, 0x44, 0xbd, 0xca,
+	0x82, 0x12, 0x3d, 0x96, 0x64, 0x0c, 0xe7, 0x06, 0x3d, 0x42, 0x0f, 0xd3, 0x03, 0x64, 0xd9, 0x75,
+	0x17, 0x41, 0xe1, 0x5e, 0xa4, 0xd0, 0xa3, 0xe4, 0x66, 0xd3, 0x95, 0xe6, 0x0d, 0x87, 0xc3, 0x79,
+	0x03, 0xb1, 0x33, 0x85, 0xda, 0xa0, 0x02, 0x6b, 0xd1, 0x08, 0x6d, 0xd0, 0x21, 0x0f, 0x9f, 0x51,
+	0xe7, 0xc7, 0x60, 0x0c, 0x1a, 0x9d, 0xf9, 0xb3, 0xf3, 0xe3, 0x6a, 0x63, 0xb4, 0xda, 0x8f, 0x93,
+	0x02, 0x0b, 0x24, 0x18, 0x37, 0xc8, 0xb3, 0x8b, 0x84, 0x1d, 0x5d, 0xc3, 0x83, 0x4c, 0xeb, 0x02,
+	0xf8, 0x84, 0x0d, 0xad, 0x4b, 0x8d, 0x8b, 0x82, 0x79, 0xb0, 0x1c, 0x4b, 0x3f, 0xf0, 0x53, 0xd6,
+	0x87, 0x3a, 0x8f, 0x7a, 0xc4, 0x35, 0x70, 0xf1, 0x2d, 0x60, 0x87, 0x12, 0xbe, 0xde, 0x83, 0x75,
+	0xfc, 0x82, 0x1d, 0x2a, 0xac, 0x1d, 0x6c, 0xfd, 0xad, 0x30, 0x39, 0x15, 0xdd, 0xb3, 0xef, 0x3d,
+	0x2f, 0x3b, 0x01, 0x3f, 0x61, 0x3d, 0xa7, 0xc9, 0xa8, 0x2f, 0x7b, 0x4e, 0x73, 0xce, 0x06, 0x79,
+	0xea, 0xd2, 0xa8, 0x4f, 0xd6, 0x84, 0xf9, 0x1b, 0x36, 0x32, 0x4d, 0x18, 0x1b, 0x0d, 0xe6, 0xfd,
+	0x65, 0x98, 0xbc, 0x14, 0xcf, 0x97, 0xee, 0xa2, 0xca, 0x56, 0xb4, 0xf8, 0xd1, 0x63, 0x47, 0x12,
+	0xac, 0xc6, 0xda, 0x02, 0xbf, 0x6e, 0xfd, 0x28, 0xfe, 0xea, 0xf2, 0xf1, 0x69, 0x76, 0xf0, 0xeb,
+	0x69, 0x16, 0x17, 0xa5, 0x5b, 0xdf, 0x67, 0x42, 0xe1, 0x5d, 0xac, 0xcb, 0xba, 0x50, 0xa9, 0x8e,
+	0x5d, 0xa9, 0xb3, 0xd8, 0xae, 0x53, 0x03, 0x79, 0xf6, 0xe0, 0xc0, 0x8a, 0xcf, 0x84, 0x57, 0x0d,
+	0x6e, 0x83, 0xbc, 0x65, 0x63, 0x03, 0x45, 0x89, 0xf5, 0x0d, 0xb5, 0x4a, 0xb1, 0xc3, 0xe4, 0x44,
+	0x74, 0x1d, 0x5f, 0x35, 0x5f, 0x19, 0x7a, 0x0d, 0x0d, 0xfc, 0x15, 0x1b, 0xdd, 0xa2, 0xaa, 0x20,
+	0xa7, 0x8d, 0xc2, 0xe4, 0x6c, 0x5f, 0xc5, 0x27, 0x54, 0xd5, 0xc7, 0xfa, 0x0b, 0xca, 0x56, 0xc0,
+	0x67, 0x2c, 0x44, 0xb7, 0x06, 0xd3, 0x9a, 0x0f, 0xe6, 0xc1, 0xf2, 0x85, 0x64, 0x44, 0x79, 0xaf,
+	0xd7, 0x6c, 0x48, 0x2b, 0x46, 0x43, 0xb2, 0xfa, 0x4f, 0x0d, 0x5e, 0xc3, 0x2f, 0xd9, 0x18, 0xb6,
+	0xa0, 0x6e, 0x72, 0x70, 0x69, 0x79, 0x6b, 0xa3, 0x11, 0xdd, 0x99, 0xec, 0x9f, 0xbf, 0xda, 0x82,
+	0xfa, 0xe0, 0xcf, 0x64, 0x08, 0xff, 0x86, 0xd5, 0xc5, 0xe3, 0x6e, 0x1a, 0xfc, 0xdc, 0x4d, 0x83,
+	0xdf, 0xbb, 0x69, 0xf0, 0xfd, 0xcf, 0xf4, 0x80, 0x45, 0x0a, 0xef, 0x44, 0x5b, 0x93, 0x70, 0x65,
+	0xb5, 0x11, 0xd5, 0x86, 0xfe, 0x94, 0x6c, 0x44, 0x9f, 0x77, 0x7f, 0x03, 0x00, 0x00, 0xff, 0xff,
+	0x12, 0x5b, 0x89, 0x3d, 0x86, 0x02, 0x00, 0x00,
 }
diff --git a/vendor/github.com/pingcap/kvproto/pkg/eraftpb/eraftpb.pb.go b/vendor/github.com/pingcap/kvproto/pkg/eraftpb/eraftpb.pb.go
index c02ee1105d931..f3876fc9e1c5b 100644
--- a/vendor/github.com/pingcap/kvproto/pkg/eraftpb/eraftpb.pb.go
+++ b/vendor/github.com/pingcap/kvproto/pkg/eraftpb/eraftpb.pb.go
@@ -2242,55 +2242,56 @@ var (
 func init() { proto.RegisterFile("eraftpb.proto", fileDescriptorEraftpb) }
 
 var fileDescriptorEraftpb = []byte{
-	// 798 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x64, 0x55, 0xcd, 0x4e, 0xdc, 0x48,
-	0x10, 0xc6, 0xf3, 0xe7, 0x71, 0x79, 0x66, 0xe8, 0xe9, 0x65, 0xc1, 0xac, 0xb4, 0x2c, 0x9a, 0x13,
-	0x42, 0x5a, 0x56, 0xb0, 0x5a, 0x69, 0x2f, 0x7b, 0x80, 0xd1, 0x4a, 0xa0, 0x00, 0x22, 0x66, 0xc8,
-	0x75, 0xe4, 0xb1, 0x7b, 0x7e, 0x12, 0xec, 0x76, 0xda, 0x3d, 0x04, 0x1e, 0x21, 0x52, 0x6e, 0xb9,
-	0xe4, 0x91, 0x72, 0xcc, 0x23, 0x44, 0xc9, 0x21, 0xaf, 0x91, 0xea, 0x76, 0xdb, 0x78, 0xe0, 0x30,
-	0x52, 0xd5, 0xd7, 0xd5, 0xd5, 0x5f, 0x7d, 0x5f, 0x59, 0x03, 0x5d, 0x26, 0x82, 0xa9, 0x4c, 0x27,
-	0x07, 0xa9, 0xe0, 0x92, 0x53, 0xdb, 0xa4, 0x83, 0x8f, 0x16, 0x34, 0xff, 0x4f, 0xa4, 0x78, 0xa0,
-	0x87, 0x00, 0x4c, 0x05, 0x63, 0xf9, 0x90, 0x32, 0xcf, 0xda, 0xb5, 0xf6, 0x7a, 0x47, 0xf4, 0xa0,
-	0xb8, 0xa6, 0x6b, 0x46, 0x78, 0xe2, 0x3b, 0xac, 0x08, 0x29, 0x85, 0x86, 0x64, 0x22, 0xf6, 0x6a,
-	0x58, 0xdc, 0xf0, 0x75, 0x4c, 0x37, 0xa0, 0xb9, 0x48, 0x22, 0x76, 0xef, 0xd5, 0x35, 0x98, 0x27,
-	0xaa, 0x32, 0x0a, 0x64, 0xe0, 0x35, 0x10, 0xec, 0xf8, 0x3a, 0xa6, 0xdb, 0xd0, 0xce, 0x1e, 0x92,
-	0x70, 0x7c, 0xcb, 0x67, 0x5e, 0x13, 0xf1, 0xb6, 0x6f, 0xab, 0xfc, 0x9c, 0xcf, 0x06, 0x1c, 0xc8,
-	0x75, 0x12, 0xa4, 0xd9, 0x9c, 0xcb, 0x0b, 0x26, 0x03, 0x5d, 0x8e, 0xfc, 0x42, 0x9e, 0x4c, 0xc7,
-	0x99, 0x0c, 0x64, 0xce, 0xcf, 0xad, 0xf0, 0x1b, 0xe2, 0xd1, 0xb5, 0x3a, 0xf1, 0x9d, 0xb0, 0x08,
-	0x1f, 0xb9, 0xd4, 0x9e, 0x70, 0xd1, 0xac, 0xeb, 0x8f, 0xac, 0x07, 0x37, 0xd0, 0x2e, 0x1e, 0x2c,
-	0xb9, 0x5a, 0x15, 0xae, 0xff, 0x40, 0x3b, 0x36, 0x44, 0x74, 0x33, 0xf7, 0x68, 0xbb, 0x7c, 0xfa,
-	0x29, 0x53, 0xbf, 0x2c, 0x1d, 0xfc, 0xa8, 0x81, 0x7d, 0xc1, 0xb2, 0x2c, 0x98, 0x31, 0xfa, 0x17,
-	0xb6, 0xc8, 0x66, 0x55, 0x75, 0x37, 0xca, 0x16, 0xa6, 0x46, 0xeb, 0x6b, 0x63, 0x95, 0x56, 0xb7,
-	0x07, 0x35, 0xc9, 0x0d, 0x75, 0x8c, 0x14, 0xaf, 0xa9, 0xe0, 0x25, 0x6f, 0x15, 0x97, 0xb3, 0x34,
-	0x2a, 0x0e, 0xa0, 0xae, 0x28, 0xe9, 0x58, 0xe3, 0x4d, 0x8d, 0xdb, 0x98, 0x8f, 0x56, 0xcc, 0x69,
-	0x55, 0x05, 0xd9, 0x03, 0x5b, 0x79, 0xba, 0x60, 0x99, 0x67, 0xef, 0xd6, 0x71, 0xb6, 0xde, 0xaa,
-	0xed, 0x7e, 0x71, 0x4c, 0x37, 0xa1, 0x15, 0xf2, 0x38, 0x5e, 0x48, 0xaf, 0xad, 0x1b, 0x98, 0x8c,
-	0xfe, 0x89, 0x56, 0x1a, 0x15, 0x3c, 0x47, 0xcb, 0xd3, 0x7f, 0x26, 0x8f, 0x5f, 0x96, 0xa8, 0x36,
-	0x82, 0xbd, 0x66, 0xa1, 0xf4, 0x40, 0xfb, 0x6e, 0x32, 0xfa, 0x07, 0xb8, 0x79, 0x34, 0x9e, 0x2f,
-	0x12, 0xe9, 0xb9, 0xfa, 0x0d, 0xc8, 0xa1, 0x53, 0x44, 0xa8, 0x07, 0x36, 0xba, 0x2b, 0xd9, 0xbd,
-	0xf4, 0x3a, 0xda, 0x9d, 0x22, 0x1d, 0xbc, 0x00, 0xe7, 0x34, 0x10, 0x51, 0xee, 0x7b, 0xa1, 0x8a,
-	0x55, 0x51, 0x05, 0xb1, 0x3b, 0x8e, 0x8b, 0x63, 0x76, 0x55, 0xc5, 0x95, 0x71, 0xea, 0xd5, 0x71,
-	0x06, 0xff, 0x81, 0x33, 0xac, 0x2e, 0x51, 0xc2, 0x23, 0xd4, 0xc6, 0x42, 0x6d, 0x50, 0x33, 0x9d,
-	0xd0, 0xdf, 0x50, 0x64, 0x16, 0x88, 0x84, 0x89, 0x0c, 0x5b, 0xaa, 0x83, 0x32, 0x1f, 0xbc, 0xb7,
-	0x00, 0xd4, 0xfd, 0xe1, 0x3c, 0x48, 0x66, 0xda, 0xc7, 0x45, 0x64, 0xb8, 0x60, 0x44, 0xff, 0x05,
-	0x37, 0xd4, 0x27, 0xf9, 0x2e, 0xd4, 0xf4, 0x2e, 0x6c, 0xad, 0x6c, 0x72, 0x7e, 0x53, 0xaf, 0x03,
-	0x84, 0x65, 0x4c, 0xb7, 0xc0, 0x56, 0xaf, 0x8f, 0xb1, 0x9d, 0x21, 0xac, 0xd2, 0xb3, 0xa8, 0xaa,
-	0x4b, 0x63, 0x45, 0x97, 0xfd, 0x43, 0x70, 0xca, 0x4f, 0x97, 0xae, 0x83, 0xab, 0x93, 0x4b, 0x2e,
-	0xe2, 0xe0, 0x96, 0xac, 0xd1, 0x5f, 0x60, 0x5d, 0x03, 0x8f, 0x6f, 0x12, 0x6b, 0xff, 0x43, 0x1d,
-	0xdc, 0xca, 0x42, 0x52, 0x80, 0xd6, 0x45, 0x36, 0x3b, 0x5d, 0xa6, 0x78, 0xc1, 0xc5, 0x7d, 0xce,
-	0x66, 0x27, 0x2c, 0x90, 0xc4, 0xc2, 0xc1, 0x00, 0x93, 0x2b, 0xc1, 0x53, 0x9e, 0x31, 0x52, 0xa3,
-	0x5d, 0x70, 0x30, 0x3f, 0x4e, 0x53, 0x96, 0x44, 0xa4, 0x4e, 0x7f, 0x85, 0x7e, 0x99, 0xfa, 0x2c,
-	0x4b, 0x79, 0x82, 0x55, 0x0d, 0x34, 0xa2, 0x87, 0xb0, 0xcf, 0xde, 0x2e, 0x59, 0x26, 0x5f, 0xa1,
-	0x0d, 0xa4, 0x89, 0x6a, 0x6e, 0xae, 0x62, 0x65, 0x7d, 0x4b, 0x91, 0xc6, 0xb3, 0x62, 0x8b, 0x88,
-	0x4d, 0x09, 0x74, 0x14, 0x1f, 0x54, 0x5b, 0x4e, 0x14, 0x91, 0x36, 0x8e, 0xbf, 0x51, 0x45, 0xca,
-	0xcb, 0x8e, 0x79, 0xec, 0x26, 0x11, 0x2c, 0x40, 0x1d, 0x27, 0xb7, 0x8c, 0x00, 0xed, 0x43, 0xd7,
-	0x34, 0x54, 0x06, 0x2f, 0x33, 0xe2, 0x9a, 0xb2, 0xe1, 0x9c, 0x85, 0x6f, 0x5e, 0x2e, 0xb9, 0x58,
-	0xc6, 0xa4, 0x63, 0xe8, 0x8f, 0x44, 0x90, 0x64, 0x53, 0x26, 0xce, 0x59, 0x10, 0x31, 0x41, 0xba,
-	0xe6, 0xf6, 0x68, 0x11, 0x33, 0xbe, 0x94, 0x97, 0xfc, 0x1d, 0xe9, 0x19, 0x42, 0x3e, 0x56, 0x9c,
-	0xa9, 0xef, 0x89, 0xac, 0xe3, 0xce, 0x90, 0x2a, 0xa2, 0x08, 0x11, 0x62, 0x3a, 0x9a, 0x29, 0xaf,
-	0x04, 0xd3, 0xc3, 0xf7, 0xe9, 0xef, 0xb0, 0xfd, 0x0c, 0x2e, 0x47, 0xa0, 0xfb, 0xc7, 0xd0, 0x5b,
-	0x5d, 0x09, 0x65, 0xc2, 0x71, 0x14, 0x5d, 0xa2, 0xf5, 0xe8, 0x08, 0x9a, 0xe0, 0xb3, 0x98, 0xdf,
-	0x31, 0x9d, 0x5b, 0x6a, 0x14, 0x3c, 0x3c, 0xcf, 0x77, 0x51, 0x63, 0xb5, 0x13, 0xf2, 0xf9, 0xdb,
-	0x8e, 0xf5, 0x05, 0x7f, 0x5f, 0xf1, 0xf7, 0xe9, 0xfb, 0xce, 0xda, 0xa4, 0xa5, 0xff, 0x06, 0xfe,
-	0xfe, 0x19, 0x00, 0x00, 0xff, 0xff, 0xf4, 0xcf, 0x7f, 0x2b, 0x17, 0x06, 0x00, 0x00,
+	// 815 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x64, 0x55, 0xcd, 0x6e, 0xe4, 0x44,
+	0x10, 0x8e, 0x3d, 0x3f, 0xf6, 0x94, 0x93, 0x49, 0xa7, 0x08, 0xbb, 0xce, 0x4a, 0x84, 0xd1, 0x9c,
+	0x46, 0x91, 0x58, 0x94, 0x20, 0x24, 0x2e, 0x1c, 0xb2, 0x11, 0x52, 0x56, 0x64, 0xa2, 0xc5, 0x9b,
+	0xe5, 0x3a, 0xea, 0xd8, 0x35, 0x1e, 0xc3, 0xd8, 0x6d, 0xba, 0x7b, 0x96, 0x9d, 0x47, 0x40, 0xe2,
+	0xc6, 0x85, 0x47, 0xe2, 0xc8, 0x23, 0xa0, 0x70, 0xe0, 0x35, 0x50, 0xb7, 0x7f, 0xe2, 0xd9, 0xdc,
+	0xea, 0xab, 0xae, 0xee, 0xfa, 0xea, 0xfb, 0xca, 0x32, 0x1c, 0x90, 0xe4, 0x4b, 0x5d, 0xde, 0xbf,
+	0x2c, 0xa5, 0xd0, 0x02, 0xbd, 0x1a, 0x4e, 0xff, 0x70, 0x60, 0xf0, 0x5d, 0xa1, 0xe5, 0x16, 0xcf,
+	0x01, 0xc8, 0x04, 0x0b, 0xbd, 0x2d, 0x29, 0x74, 0x26, 0xce, 0x6c, 0x7c, 0x81, 0x2f, 0x9b, 0x6b,
+	0xb6, 0xe6, 0x6e, 0x5b, 0x52, 0x34, 0xa2, 0x26, 0x44, 0x84, 0xbe, 0x26, 0x99, 0x87, 0xee, 0xc4,
+	0x99, 0xf5, 0x23, 0x1b, 0xe3, 0x31, 0x0c, 0xb2, 0x22, 0xa1, 0x0f, 0x61, 0xcf, 0x26, 0x2b, 0x60,
+	0x2a, 0x13, 0xae, 0x79, 0xd8, 0x9f, 0x38, 0xb3, 0xfd, 0xc8, 0xc6, 0x78, 0x02, 0xbe, 0xda, 0x16,
+	0xf1, 0x62, 0x2d, 0xd2, 0x70, 0x30, 0x71, 0x66, 0x7e, 0xe4, 0x19, 0x7c, 0x23, 0xd2, 0xa9, 0x00,
+	0xf6, 0xb6, 0xe0, 0xa5, 0x5a, 0x09, 0x3d, 0x27, 0xcd, 0x6d, 0xf9, 0x39, 0x40, 0x2c, 0x8a, 0xe5,
+	0x42, 0x69, 0xae, 0x2b, 0x7e, 0x41, 0x87, 0xdf, 0x95, 0x28, 0x96, 0x6f, 0xcd, 0x49, 0x34, 0x8a,
+	0x9b, 0xf0, 0x91, 0x8b, 0xfb, 0x11, 0x17, 0xcb, 0xba, 0xf7, 0xc8, 0x7a, 0xfa, 0x0e, 0xfc, 0xa6,
+	0x61, 0xcb, 0xd5, 0xe9, 0x70, 0xfd, 0x1a, 0xfc, 0xbc, 0x26, 0x62, 0x1f, 0x0b, 0x2e, 0x4e, 0xda,
+	0xd6, 0x1f, 0x33, 0x8d, 0xda, 0xd2, 0xe9, 0x7f, 0x2e, 0x78, 0x73, 0x52, 0x8a, 0xa7, 0x84, 0x5f,
+	0x82, 0x9f, 0xab, 0xb4, 0xab, 0xee, 0x71, 0xfb, 0x44, 0x5d, 0x63, 0xf5, 0xf5, 0x72, 0x95, 0x5a,
+	0x75, 0xc7, 0xe0, 0x6a, 0x51, 0x53, 0x77, 0xb5, 0x30, 0xbc, 0x96, 0x52, 0xb4, 0xbc, 0x4d, 0xdc,
+	0xce, 0xd2, 0xef, 0x38, 0x70, 0x02, 0xfe, 0x5a, 0xa4, 0x0b, 0x9b, 0x1f, 0xd8, 0xbc, 0xb7, 0x16,
+	0xe9, 0xdd, 0x8e, 0x39, 0xc3, 0xae, 0x20, 0x33, 0xf0, 0x8c, 0xa7, 0x19, 0xa9, 0xd0, 0x9b, 0xf4,
+	0x66, 0xc1, 0xc5, 0x78, 0xd7, 0xf6, 0xa8, 0x39, 0xc6, 0x67, 0x30, 0x8c, 0x45, 0x9e, 0x67, 0x3a,
+	0xf4, 0xed, 0x03, 0x35, 0xc2, 0x2f, 0xc0, 0x57, 0xb5, 0x0a, 0xe1, 0xc8, 0xca, 0x73, 0xf4, 0x44,
+	0x9e, 0xa8, 0x2d, 0x31, 0xcf, 0x48, 0xfa, 0x89, 0x62, 0x1d, 0x82, 0xf5, 0xbd, 0x46, 0xf8, 0x39,
+	0x04, 0x55, 0xb4, 0x58, 0x65, 0x85, 0x0e, 0x03, 0xdb, 0x03, 0xaa, 0xd4, 0x75, 0x56, 0x68, 0x0c,
+	0xc1, 0x8b, 0x45, 0xa1, 0xe9, 0x83, 0x0e, 0xf7, 0xad, 0x3b, 0x0d, 0x9c, 0x7e, 0x0f, 0xa3, 0x6b,
+	0x2e, 0x93, 0xca, 0xf7, 0x46, 0x15, 0xa7, 0xa3, 0x0a, 0x42, 0xff, 0xbd, 0xd0, 0xd4, 0xec, 0xaa,
+	0x89, 0x3b, 0xe3, 0xf4, 0xba, 0xe3, 0x4c, 0xbf, 0x85, 0xd1, 0x55, 0x77, 0x89, 0x0a, 0x91, 0x90,
+	0x0a, 0x9d, 0x49, 0xcf, 0x68, 0x66, 0x01, 0xbe, 0x00, 0x7f, 0x4d, 0x5c, 0x16, 0x24, 0x55, 0xe8,
+	0xda, 0x83, 0x16, 0x4f, 0x7f, 0x73, 0x00, 0xcc, 0xfd, 0xab, 0x15, 0x2f, 0x52, 0xeb, 0x63, 0x96,
+	0xd4, 0x5c, 0xdc, 0x2c, 0xc1, 0x6f, 0x20, 0x88, 0xed, 0x49, 0xb5, 0x0b, 0xae, 0xdd, 0x85, 0xe7,
+	0x3b, 0x9b, 0x5c, 0xdd, 0xb4, 0xeb, 0x00, 0x71, 0x1b, 0xe3, 0x73, 0xf0, 0x4c, 0xf7, 0x45, 0x96,
+	0x34, 0x84, 0x0d, 0x7c, 0x9d, 0x74, 0x75, 0xe9, 0xef, 0xe8, 0x72, 0x76, 0x0e, 0xa3, 0xf6, 0xd3,
+	0xc5, 0x43, 0x08, 0x2c, 0xb8, 0x15, 0x32, 0xe7, 0x6b, 0xb6, 0x87, 0x9f, 0xc0, 0xa1, 0x4d, 0x3c,
+	0xf6, 0x64, 0xce, 0xd9, 0xef, 0x3d, 0x08, 0x3a, 0x0b, 0x89, 0x00, 0xc3, 0xb9, 0x4a, 0xaf, 0x37,
+	0x25, 0xdb, 0xc3, 0x00, 0xbc, 0xb9, 0x4a, 0x5f, 0x11, 0xd7, 0xcc, 0xc1, 0x31, 0xc0, 0x5c, 0xa5,
+	0x6f, 0xa4, 0x28, 0x85, 0x22, 0xe6, 0xe2, 0x01, 0x8c, 0xe6, 0x2a, 0xbd, 0x2c, 0x4b, 0x2a, 0x12,
+	0xd6, 0xc3, 0x4f, 0xe1, 0xa8, 0x85, 0x11, 0xa9, 0x52, 0x14, 0x8a, 0x58, 0x1f, 0x11, 0xc6, 0x73,
+	0x95, 0x46, 0xf4, 0xcb, 0x86, 0x94, 0xfe, 0x51, 0x68, 0x62, 0x03, 0x7c, 0x01, 0xcf, 0x76, 0x73,
+	0x6d, 0xfd, 0xd0, 0x90, 0x9e, 0xab, 0xb4, 0xd9, 0x22, 0xe6, 0x21, 0x83, 0x7d, 0xc3, 0x87, 0xb8,
+	0xd4, 0xf7, 0x86, 0x88, 0x8f, 0x21, 0x1c, 0x77, 0x33, 0xed, 0xe5, 0x51, 0xdd, 0xec, 0x5d, 0x21,
+	0x89, 0xc7, 0x2b, 0x7e, 0xbf, 0x26, 0x06, 0x78, 0x04, 0x07, 0xf5, 0x83, 0xc6, 0xe0, 0x8d, 0x62,
+	0x41, 0x5d, 0x76, 0xb5, 0xa2, 0xf8, 0xe7, 0x1f, 0x36, 0x42, 0x6e, 0x72, 0xb6, 0x5f, 0xd3, 0xbf,
+	0x93, 0xbc, 0x50, 0x4b, 0x92, 0x37, 0xc4, 0x13, 0x92, 0xec, 0xa0, 0xbe, 0x7d, 0x97, 0xe5, 0x24,
+	0x36, 0xfa, 0x56, 0xfc, 0xca, 0xc6, 0x35, 0xa1, 0x88, 0x78, 0xf2, 0xda, 0x7c, 0x4f, 0xec, 0x10,
+	0x8f, 0x81, 0x75, 0x33, 0x86, 0x10, 0x63, 0xf5, 0x8b, 0xf5, 0x94, 0x6f, 0x24, 0xd9, 0xe1, 0x8f,
+	0xf0, 0x33, 0x38, 0x79, 0x92, 0x6e, 0x47, 0xc0, 0xb3, 0x4b, 0x18, 0xef, 0xae, 0x84, 0x31, 0xe1,
+	0x32, 0x49, 0x6e, 0x45, 0x42, 0x6c, 0xcf, 0x98, 0x10, 0x51, 0x2e, 0xde, 0x93, 0xc5, 0x8e, 0x19,
+	0xe5, 0x32, 0x49, 0x6e, 0xaa, 0x5d, 0xb4, 0x39, 0xf7, 0x15, 0xfb, 0xeb, 0xe1, 0xd4, 0xf9, 0xfb,
+	0xe1, 0xd4, 0xf9, 0xe7, 0xe1, 0xd4, 0xf9, 0xf3, 0xdf, 0xd3, 0xbd, 0xfb, 0xa1, 0xfd, 0x0d, 0x7c,
+	0xf5, 0x7f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xf4, 0xcf, 0x7f, 0x2b, 0x17, 0x06, 0x00, 0x00,
 }
diff --git a/vendor/github.com/pingcap/kvproto/pkg/errorpb/errorpb.pb.go b/vendor/github.com/pingcap/kvproto/pkg/errorpb/errorpb.pb.go
index e32f260594085..4e18d72fb9f74 100644
--- a/vendor/github.com/pingcap/kvproto/pkg/errorpb/errorpb.pb.go
+++ b/vendor/github.com/pingcap/kvproto/pkg/errorpb/errorpb.pb.go
@@ -1942,43 +1942,43 @@ var (
 func init() { proto.RegisterFile("errorpb.proto", fileDescriptorErrorpb) }
 
 var fileDescriptorErrorpb = []byte{
-	// 594 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x7c, 0x54, 0xdf, 0x8e, 0x12, 0x3f,
-	0x14, 0xfe, 0xb1, 0xb0, 0xc0, 0x1c, 0x60, 0x76, 0xe9, 0x6f, 0xdd, 0x9d, 0x60, 0xdc, 0x98, 0x89,
-	0x17, 0xc6, 0xc4, 0xd9, 0xb8, 0x7a, 0xa5, 0xd1, 0x44, 0x0c, 0x26, 0x64, 0xff, 0x68, 0x8a, 0xf7,
-	0x93, 0xc2, 0x94, 0xd9, 0x09, 0x4c, 0x4b, 0xda, 0x82, 0xc1, 0x17, 0xd1, 0x47, 0xf2, 0xd2, 0x47,
-	0x30, 0xfa, 0x22, 0xb6, 0x9d, 0x01, 0x66, 0xb8, 0xd8, 0x8b, 0x09, 0x3d, 0xe7, 0xf4, 0xfb, 0xce,
-	0x69, 0xbf, 0xaf, 0x40, 0x87, 0x0a, 0xc1, 0xc5, 0x62, 0x1c, 0x2c, 0x04, 0x57, 0x1c, 0x35, 0xf2,
-	0xb0, 0xd7, 0x4e, 0xa9, 0x22, 0x9b, 0x74, 0xef, 0x24, 0xe6, 0x31, 0xb7, 0xcb, 0x0b, 0xb3, 0xca,
-	0xb2, 0xfe, 0x2d, 0x38, 0xb7, 0x5c, 0x5d, 0x53, 0x12, 0x51, 0x81, 0x1e, 0x82, 0x23, 0x68, 0x9c,
-	0x70, 0x16, 0x26, 0x91, 0x57, 0x79, 0x5c, 0x79, 0x5a, 0xc3, 0xcd, 0x2c, 0x31, 0x8c, 0xd0, 0x13,
-	0xa8, 0xcf, 0xed, 0x36, 0xef, 0x40, 0x57, 0x5a, 0x97, 0xed, 0x20, 0xa7, 0xff, 0x4c, 0xa9, 0xc0,
-	0x79, 0xcd, 0x3f, 0x82, 0xce, 0x48, 0x71, 0x41, 0x35, 0xe9, 0x0d, 0x51, 0x93, 0x3b, 0xff, 0x39,
-	0xb8, 0xd8, 0x52, 0xe8, 0xcc, 0x47, 0xbe, 0x64, 0xd1, 0xbd, 0x5d, 0xfc, 0x25, 0xb8, 0x57, 0x74,
-	0xad, 0xf7, 0x0e, 0x59, 0x06, 0x43, 0xc7, 0x50, 0x9d, 0xd1, 0xb5, 0xdd, 0xd8, 0xc6, 0x66, 0x59,
-	0x26, 0x38, 0xd8, 0x1b, 0x53, 0x17, 0xa5, 0x22, 0x42, 0x85, 0x06, 0x54, 0xb5, 0xa0, 0xa6, 0x4d,
-	0x68, 0x5a, 0x74, 0x06, 0x0d, 0xca, 0x22, 0x5b, 0xaa, 0xd9, 0x52, 0x5d, 0x87, 0xba, 0xe0, 0xbf,
-	0x05, 0x18, 0x29, 0x32, 0xa7, 0x83, 0x05, 0x9f, 0xdc, 0xa1, 0x0b, 0x68, 0x31, 0xfa, 0x35, 0xcc,
-	0x38, 0xa5, 0x6e, 0x5d, 0xd5, 0xe7, 0x75, 0x37, 0xe7, 0xcd, 0xe6, 0xc2, 0xa0, 0xb7, 0x64, 0x4b,
-	0xe9, 0x0f, 0xa0, 0x3d, 0xa2, 0x62, 0x45, 0xc5, 0x50, 0xf6, 0x97, 0x72, 0x8d, 0x4e, 0xa1, 0x2e,
-	0x28, 0x91, 0x9c, 0xd9, 0xb1, 0x1d, 0x9c, 0x47, 0xe8, 0x11, 0xc0, 0x98, 0x4c, 0x66, 0x7c, 0x3a,
-	0x0d, 0x53, 0x99, 0x8f, 0xee, 0xe4, 0x99, 0x1b, 0xe9, 0xbb, 0x9a, 0xc6, 0x4c, 0xf1, 0x81, 0xa7,
-	0x29, 0x61, 0x91, 0xff, 0x09, 0xba, 0x98, 0x4c, 0xd5, 0x80, 0x29, 0xb1, 0xfe, 0xc2, 0xf9, 0x35,
-	0x11, 0x31, 0xbd, 0x5f, 0x24, 0xdd, 0x80, 0x9a, 0xdd, 0xa1, 0x4c, 0xbe, 0xd1, 0x4d, 0x03, 0x9b,
-	0x19, 0xe9, 0x84, 0xff, 0xbd, 0x06, 0x87, 0x03, 0xe3, 0x0e, 0xe4, 0x41, 0x23, 0xa5, 0x52, 0x92,
-	0x98, 0xe6, 0x23, 0x6e, 0x42, 0xf4, 0x02, 0x80, 0x71, 0x15, 0x96, 0xb4, 0x46, 0xc1, 0xc6, 0x62,
-	0x5b, 0xb3, 0x60, 0x87, 0x6d, 0x7d, 0xf3, 0x1e, 0x8e, 0xf3, 0x91, 0x0c, 0x72, 0x6a, 0x54, 0xb6,
-	0x57, 0xdf, 0xba, 0x3c, 0xdb, 0x02, 0xcb, 0x26, 0xc0, 0xae, 0x28, 0x9b, 0xa2, 0x0f, 0x5d, 0xad,
-	0x8a, 0xc5, 0x27, 0x2c, 0xbf, 0x79, 0xab, 0x51, 0x91, 0xa3, 0xec, 0x0c, 0xec, 0xce, 0xca, 0x4e,
-	0x79, 0x05, 0x2d, 0x69, 0xae, 0x2f, 0xa4, 0x46, 0x45, 0xef, 0xd0, 0xa2, 0xff, 0xdf, 0xa2, 0x77,
-	0x02, 0x63, 0x90, 0x3b, 0xb1, 0xdf, 0x80, 0x2b, 0xad, 0x76, 0x61, 0x22, 0xc3, 0xb1, 0x56, 0xcf,
-	0xab, 0x5b, 0xe0, 0x83, 0x1d, 0xb0, 0x20, 0x2d, 0x6e, 0xcb, 0xa2, 0xd0, 0xaf, 0xa1, 0x93, 0xb5,
-	0x9c, 0x64, 0x92, 0x79, 0x8d, 0x7d, 0x6c, 0x41, 0x4f, 0x8d, 0x2d, 0x44, 0xe8, 0x1d, 0x1c, 0x49,
-	0xf3, 0x54, 0xec, 0xa1, 0x53, 0xf3, 0x58, 0xbc, 0xa6, 0x45, 0x9f, 0x16, 0xd0, 0x85, 0xa7, 0x84,
-	0x3b, 0xb2, 0x18, 0xa2, 0x2b, 0x38, 0x11, 0xda, 0x1d, 0x61, 0x26, 0xb8, 0xe2, 0x3c, 0x9c, 0x1b,
-	0x83, 0x78, 0x8e, 0x25, 0xe9, 0xed, 0x6e, 0x7e, 0xdf, 0x42, 0xb8, 0x2b, 0xf6, 0x53, 0xfd, 0x67,
-	0x3f, 0xff, 0x9c, 0x57, 0x7e, 0xe9, 0xef, 0xb7, 0xfe, 0x7e, 0xfc, 0x3d, 0xff, 0x0f, 0x3c, 0x7d,
-	0xa4, 0x60, 0x91, 0xb0, 0x78, 0x42, 0x16, 0x81, 0x4a, 0x66, 0xab, 0x60, 0xb6, 0xb2, 0xff, 0x19,
-	0xe3, 0xba, 0xfd, 0x79, 0xf9, 0x2f, 0x00, 0x00, 0xff, 0xff, 0x6f, 0xa9, 0xa3, 0xe6, 0x78, 0x04,
-	0x00, 0x00,
+	// 604 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x54, 0xdd, 0x6e, 0xd3, 0x30,
+	0x14, 0x26, 0xfb, 0x69, 0x97, 0xd3, 0x34, 0xdb, 0xcc, 0xd8, 0xa2, 0x4d, 0xab, 0xa6, 0x88, 0x8b,
+	0x09, 0x89, 0x4e, 0x0c, 0xae, 0x40, 0x20, 0x31, 0x54, 0xa4, 0xa9, 0x5b, 0x41, 0x2e, 0xf7, 0x91,
+	0xdb, 0x9c, 0x76, 0x51, 0x17, 0xbb, 0xb2, 0xdd, 0x4d, 0xd9, 0x8b, 0xc0, 0x23, 0x71, 0xc9, 0x23,
+	0xa0, 0xf1, 0x22, 0xc8, 0x4e, 0xda, 0x26, 0xbd, 0xd8, 0x55, 0xce, 0x39, 0xf6, 0x77, 0xfc, 0xf9,
+	0x7c, 0x9f, 0x03, 0x4d, 0x94, 0x52, 0xc8, 0xe9, 0xa0, 0x3d, 0x95, 0x42, 0x0b, 0x52, 0x2f, 0xd2,
+	0x43, 0x2f, 0x45, 0xcd, 0xe6, 0xe5, 0xc3, 0xbd, 0xb1, 0x18, 0x0b, 0x1b, 0x9e, 0x99, 0x28, 0xaf,
+	0x86, 0x3d, 0x70, 0x7b, 0x42, 0x5f, 0x21, 0x8b, 0x51, 0x92, 0x23, 0x70, 0x25, 0x8e, 0x13, 0xc1,
+	0xa3, 0x24, 0x0e, 0x9c, 0x13, 0xe7, 0x74, 0x83, 0x6e, 0xe5, 0x85, 0xcb, 0x98, 0xbc, 0x84, 0xda,
+	0xad, 0xdd, 0x16, 0xac, 0x9d, 0x38, 0xa7, 0x8d, 0x73, 0xaf, 0x5d, 0xb4, 0xff, 0x8e, 0x28, 0x69,
+	0xb1, 0x16, 0x6e, 0x43, 0xb3, 0xaf, 0x85, 0xc4, 0x9e, 0xd0, 0xd7, 0x4c, 0x0f, 0x6f, 0xc2, 0xd7,
+	0xe0, 0x53, 0xdb, 0xa2, 0x27, 0xf4, 0x57, 0x31, 0xe3, 0xf1, 0x93, 0xa7, 0x84, 0x33, 0xf0, 0xbb,
+	0x98, 0xf5, 0x84, 0xbe, 0xe4, 0x39, 0x8c, 0xec, 0xc0, 0xfa, 0x04, 0x33, 0xbb, 0xd1, 0xa3, 0x26,
+	0xac, 0x36, 0x58, 0x5b, 0xa1, 0x79, 0x04, 0xae, 0xd2, 0x4c, 0xea, 0xc8, 0x80, 0xd6, 0x2d, 0x68,
+	0xcb, 0x16, 0xba, 0x98, 0x91, 0x03, 0xa8, 0x23, 0x8f, 0xed, 0xd2, 0x86, 0x5d, 0xaa, 0x21, 0x8f,
+	0xbb, 0x98, 0x85, 0x1f, 0x01, 0xfa, 0x9a, 0xdd, 0x62, 0x67, 0x2a, 0x86, 0x37, 0xe4, 0x0c, 0x1a,
+	0x1c, 0xef, 0xa3, 0xbc, 0xa7, 0x0a, 0x9c, 0x93, 0xf5, 0xd3, 0xc6, 0xb9, 0x3f, 0xbf, 0x6f, 0xce,
+	0x8b, 0x02, 0xc7, 0xfb, 0x3c, 0x54, 0x61, 0x07, 0xbc, 0x3e, 0xca, 0x3b, 0x94, 0x97, 0xea, 0x62,
+	0xa6, 0x32, 0xb2, 0x0f, 0x35, 0x89, 0x4c, 0x09, 0x6e, 0x69, 0xbb, 0xb4, 0xc8, 0xc8, 0x31, 0xc0,
+	0x80, 0x0d, 0x27, 0x62, 0x34, 0x8a, 0x52, 0x55, 0x50, 0x77, 0x8b, 0xca, 0xb5, 0x0a, 0x7d, 0xf0,
+	0x2c, 0x8b, 0x2f, 0x22, 0x4d, 0x19, 0x8f, 0xc3, 0x6f, 0xb0, 0x4b, 0xd9, 0x48, 0x77, 0xb8, 0x96,
+	0xd9, 0x0f, 0x21, 0xae, 0x98, 0x1c, 0xe3, 0xd3, 0x22, 0x1d, 0x03, 0xa0, 0xd9, 0x1d, 0xa9, 0xe4,
+	0x01, 0xe7, 0x07, 0xd8, 0x4a, 0x3f, 0x79, 0xc0, 0xf0, 0xe7, 0x06, 0x6c, 0x76, 0x8c, 0x3b, 0x48,
+	0x00, 0xf5, 0x14, 0x95, 0x62, 0x63, 0x2c, 0x28, 0xce, 0x53, 0xf2, 0x06, 0x80, 0x0b, 0x1d, 0x55,
+	0xb4, 0x26, 0xed, 0xb9, 0xc5, 0x16, 0x66, 0xa1, 0x2e, 0x5f, 0xf8, 0xe6, 0x33, 0xec, 0x14, 0x94,
+	0x0c, 0x72, 0x64, 0x54, 0xb6, 0xa3, 0x6f, 0x9c, 0x1f, 0x2c, 0x80, 0x55, 0x13, 0x50, 0x5f, 0x56,
+	0x4d, 0x71, 0x01, 0xbb, 0x13, 0xcc, 0x2c, 0x3e, 0xe1, 0xc5, 0xe4, 0xad, 0x46, 0xe5, 0x1e, 0x55,
+	0x67, 0x50, 0x7f, 0x52, 0x75, 0xca, 0x3b, 0x68, 0x28, 0x33, 0xbe, 0x08, 0x8d, 0x8a, 0xc1, 0xa6,
+	0x45, 0x3f, 0x5f, 0xa0, 0x97, 0x02, 0x53, 0x50, 0x4b, 0xb1, 0x3f, 0x80, 0xaf, 0xac, 0x76, 0x51,
+	0xa2, 0xa2, 0xc1, 0x4c, 0x65, 0x41, 0xcd, 0x02, 0x5f, 0x2c, 0x81, 0x25, 0x69, 0xa9, 0xa7, 0xca,
+	0x42, 0xbf, 0x87, 0x66, 0x7e, 0xe4, 0x30, 0x97, 0x2c, 0xa8, 0xaf, 0x62, 0x4b, 0x7a, 0x52, 0x4f,
+	0x95, 0x32, 0xf2, 0x09, 0xb6, 0x95, 0x79, 0x2a, 0xf6, 0xd2, 0xa9, 0x79, 0x2c, 0xc1, 0x96, 0x45,
+	0xef, 0x97, 0xd0, 0xa5, 0xa7, 0x44, 0x9b, 0xaa, 0x9c, 0x92, 0x2e, 0xec, 0x49, 0x36, 0xd2, 0x51,
+	0x2e, 0xb8, 0x16, 0x22, 0xba, 0x35, 0x06, 0x09, 0x5c, 0xdb, 0xe4, 0x70, 0x39, 0xf9, 0x55, 0x0b,
+	0xd1, 0x5d, 0xb9, 0x5a, 0xba, 0x78, 0xf5, 0xfb, 0xb1, 0xe5, 0xfc, 0x79, 0x6c, 0x39, 0x7f, 0x1f,
+	0x5b, 0xce, 0xaf, 0x7f, 0xad, 0x67, 0x10, 0x0c, 0x45, 0xda, 0x9e, 0x26, 0x7c, 0x3c, 0x64, 0xd3,
+	0xb6, 0x4e, 0x26, 0x77, 0xed, 0xc9, 0x9d, 0xfd, 0x67, 0x0c, 0x6a, 0xf6, 0xf3, 0xf6, 0x7f, 0x00,
+	0x00, 0x00, 0xff, 0xff, 0x6f, 0xa9, 0xa3, 0xe6, 0x78, 0x04, 0x00, 0x00,
 }
diff --git a/vendor/github.com/pingcap/kvproto/pkg/kvrpcpb/kvrpcpb.pb.go b/vendor/github.com/pingcap/kvproto/pkg/kvrpcpb/kvrpcpb.pb.go
index 39e92c50cd869..2bb6984dde512 100644
--- a/vendor/github.com/pingcap/kvproto/pkg/kvrpcpb/kvrpcpb.pb.go
+++ b/vendor/github.com/pingcap/kvproto/pkg/kvrpcpb/kvrpcpb.pb.go
@@ -45,16 +45,26 @@
 		RawGetResponse
 		RawPutRequest
 		RawPutResponse
+		RawBatchPutRequest
+		RawBatchPutResponse
+		RawBatchGetRequest
+		RawBatchGetResponse
 		RawDeleteRequest
 		RawDeleteResponse
+		RawBatchDeleteRequest
+		RawBatchDeleteResponse
 		DeleteRangeRequest
 		DeleteRangeResponse
 		RawDeleteRangeRequest
 		RawDeleteRangeResponse
 		RawScanRequest
 		RawScanResponse
-		WriteInfo
-		ValueInfo
+		KeyRange
+		RawBatchScanRequest
+		RawBatchScanResponse
+		MvccWrite
+		MvccValue
+		MvccLock
 		MvccInfo
 		MvccGetByKeyRequest
 		MvccGetByKeyResponse
@@ -1314,6 +1324,102 @@ func (m *RawPutResponse) GetError() string {
 	return ""
 }
 
+type RawBatchPutRequest struct {
+	Context *Context  `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"`
+	Pairs   []*KvPair `protobuf:"bytes,2,rep,name=pairs" json:"pairs,omitempty"`
+}
+
+func (m *RawBatchPutRequest) Reset()                    { *m = RawBatchPutRequest{} }
+func (m *RawBatchPutRequest) String() string            { return proto.CompactTextString(m) }
+func (*RawBatchPutRequest) ProtoMessage()               {}
+func (*RawBatchPutRequest) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{36} }
+
+func (m *RawBatchPutRequest) GetContext() *Context {
+	if m != nil {
+		return m.Context
+	}
+	return nil
+}
+
+func (m *RawBatchPutRequest) GetPairs() []*KvPair {
+	if m != nil {
+		return m.Pairs
+	}
+	return nil
+}
+
+type RawBatchPutResponse struct {
+	RegionError *errorpb.Error `protobuf:"bytes,1,opt,name=region_error,json=regionError" json:"region_error,omitempty"`
+	Error       string         `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"`
+}
+
+func (m *RawBatchPutResponse) Reset()                    { *m = RawBatchPutResponse{} }
+func (m *RawBatchPutResponse) String() string            { return proto.CompactTextString(m) }
+func (*RawBatchPutResponse) ProtoMessage()               {}
+func (*RawBatchPutResponse) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{37} }
+
+func (m *RawBatchPutResponse) GetRegionError() *errorpb.Error {
+	if m != nil {
+		return m.RegionError
+	}
+	return nil
+}
+
+func (m *RawBatchPutResponse) GetError() string {
+	if m != nil {
+		return m.Error
+	}
+	return ""
+}
+
+type RawBatchGetRequest struct {
+	Context *Context `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"`
+	Keys    [][]byte `protobuf:"bytes,2,rep,name=keys" json:"keys,omitempty"`
+}
+
+func (m *RawBatchGetRequest) Reset()                    { *m = RawBatchGetRequest{} }
+func (m *RawBatchGetRequest) String() string            { return proto.CompactTextString(m) }
+func (*RawBatchGetRequest) ProtoMessage()               {}
+func (*RawBatchGetRequest) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{38} }
+
+func (m *RawBatchGetRequest) GetContext() *Context {
+	if m != nil {
+		return m.Context
+	}
+	return nil
+}
+
+func (m *RawBatchGetRequest) GetKeys() [][]byte {
+	if m != nil {
+		return m.Keys
+	}
+	return nil
+}
+
+type RawBatchGetResponse struct {
+	RegionError *errorpb.Error `protobuf:"bytes,1,opt,name=region_error,json=regionError" json:"region_error,omitempty"`
+	Pairs       []*KvPair      `protobuf:"bytes,2,rep,name=pairs" json:"pairs,omitempty"`
+}
+
+func (m *RawBatchGetResponse) Reset()                    { *m = RawBatchGetResponse{} }
+func (m *RawBatchGetResponse) String() string            { return proto.CompactTextString(m) }
+func (*RawBatchGetResponse) ProtoMessage()               {}
+func (*RawBatchGetResponse) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{39} }
+
+func (m *RawBatchGetResponse) GetRegionError() *errorpb.Error {
+	if m != nil {
+		return m.RegionError
+	}
+	return nil
+}
+
+func (m *RawBatchGetResponse) GetPairs() []*KvPair {
+	if m != nil {
+		return m.Pairs
+	}
+	return nil
+}
+
 type RawDeleteRequest struct {
 	Context *Context `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"`
 	Key     []byte   `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"`
@@ -1322,7 +1428,7 @@ type RawDeleteRequest struct {
 func (m *RawDeleteRequest) Reset()                    { *m = RawDeleteRequest{} }
 func (m *RawDeleteRequest) String() string            { return proto.CompactTextString(m) }
 func (*RawDeleteRequest) ProtoMessage()               {}
-func (*RawDeleteRequest) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{36} }
+func (*RawDeleteRequest) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{40} }
 
 func (m *RawDeleteRequest) GetContext() *Context {
 	if m != nil {
@@ -1346,7 +1452,7 @@ type RawDeleteResponse struct {
 func (m *RawDeleteResponse) Reset()                    { *m = RawDeleteResponse{} }
 func (m *RawDeleteResponse) String() string            { return proto.CompactTextString(m) }
 func (*RawDeleteResponse) ProtoMessage()               {}
-func (*RawDeleteResponse) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{37} }
+func (*RawDeleteResponse) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{41} }
 
 func (m *RawDeleteResponse) GetRegionError() *errorpb.Error {
 	if m != nil {
@@ -1362,6 +1468,54 @@ func (m *RawDeleteResponse) GetError() string {
 	return ""
 }
 
+type RawBatchDeleteRequest struct {
+	Context *Context `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"`
+	Keys    [][]byte `protobuf:"bytes,2,rep,name=keys" json:"keys,omitempty"`
+}
+
+func (m *RawBatchDeleteRequest) Reset()                    { *m = RawBatchDeleteRequest{} }
+func (m *RawBatchDeleteRequest) String() string            { return proto.CompactTextString(m) }
+func (*RawBatchDeleteRequest) ProtoMessage()               {}
+func (*RawBatchDeleteRequest) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{42} }
+
+func (m *RawBatchDeleteRequest) GetContext() *Context {
+	if m != nil {
+		return m.Context
+	}
+	return nil
+}
+
+func (m *RawBatchDeleteRequest) GetKeys() [][]byte {
+	if m != nil {
+		return m.Keys
+	}
+	return nil
+}
+
+type RawBatchDeleteResponse struct {
+	RegionError *errorpb.Error `protobuf:"bytes,1,opt,name=region_error,json=regionError" json:"region_error,omitempty"`
+	Error       string         `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"`
+}
+
+func (m *RawBatchDeleteResponse) Reset()                    { *m = RawBatchDeleteResponse{} }
+func (m *RawBatchDeleteResponse) String() string            { return proto.CompactTextString(m) }
+func (*RawBatchDeleteResponse) ProtoMessage()               {}
+func (*RawBatchDeleteResponse) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{43} }
+
+func (m *RawBatchDeleteResponse) GetRegionError() *errorpb.Error {
+	if m != nil {
+		return m.RegionError
+	}
+	return nil
+}
+
+func (m *RawBatchDeleteResponse) GetError() string {
+	if m != nil {
+		return m.Error
+	}
+	return ""
+}
+
 type DeleteRangeRequest struct {
 	Context  *Context `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"`
 	StartKey []byte   `protobuf:"bytes,2,opt,name=start_key,json=startKey,proto3" json:"start_key,omitempty"`
@@ -1371,7 +1525,7 @@ type DeleteRangeRequest struct {
 func (m *DeleteRangeRequest) Reset()                    { *m = DeleteRangeRequest{} }
 func (m *DeleteRangeRequest) String() string            { return proto.CompactTextString(m) }
 func (*DeleteRangeRequest) ProtoMessage()               {}
-func (*DeleteRangeRequest) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{38} }
+func (*DeleteRangeRequest) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{44} }
 
 func (m *DeleteRangeRequest) GetContext() *Context {
 	if m != nil {
@@ -1402,7 +1556,7 @@ type DeleteRangeResponse struct {
 func (m *DeleteRangeResponse) Reset()                    { *m = DeleteRangeResponse{} }
 func (m *DeleteRangeResponse) String() string            { return proto.CompactTextString(m) }
 func (*DeleteRangeResponse) ProtoMessage()               {}
-func (*DeleteRangeResponse) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{39} }
+func (*DeleteRangeResponse) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{45} }
 
 func (m *DeleteRangeResponse) GetRegionError() *errorpb.Error {
 	if m != nil {
@@ -1427,7 +1581,7 @@ type RawDeleteRangeRequest struct {
 func (m *RawDeleteRangeRequest) Reset()                    { *m = RawDeleteRangeRequest{} }
 func (m *RawDeleteRangeRequest) String() string            { return proto.CompactTextString(m) }
 func (*RawDeleteRangeRequest) ProtoMessage()               {}
-func (*RawDeleteRangeRequest) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{40} }
+func (*RawDeleteRangeRequest) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{46} }
 
 func (m *RawDeleteRangeRequest) GetContext() *Context {
 	if m != nil {
@@ -1458,7 +1612,7 @@ type RawDeleteRangeResponse struct {
 func (m *RawDeleteRangeResponse) Reset()                    { *m = RawDeleteRangeResponse{} }
 func (m *RawDeleteRangeResponse) String() string            { return proto.CompactTextString(m) }
 func (*RawDeleteRangeResponse) ProtoMessage()               {}
-func (*RawDeleteRangeResponse) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{41} }
+func (*RawDeleteRangeResponse) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{47} }
 
 func (m *RawDeleteRangeResponse) GetRegionError() *errorpb.Error {
 	if m != nil {
@@ -1478,12 +1632,13 @@ type RawScanRequest struct {
 	Context  *Context `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"`
 	StartKey []byte   `protobuf:"bytes,2,opt,name=start_key,json=startKey,proto3" json:"start_key,omitempty"`
 	Limit    uint32   `protobuf:"varint,3,opt,name=limit,proto3" json:"limit,omitempty"`
+	KeyOnly  bool     `protobuf:"varint,4,opt,name=key_only,json=keyOnly,proto3" json:"key_only,omitempty"`
 }
 
 func (m *RawScanRequest) Reset()                    { *m = RawScanRequest{} }
 func (m *RawScanRequest) String() string            { return proto.CompactTextString(m) }
 func (*RawScanRequest) ProtoMessage()               {}
-func (*RawScanRequest) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{42} }
+func (*RawScanRequest) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{48} }
 
 func (m *RawScanRequest) GetContext() *Context {
 	if m != nil {
@@ -1506,6 +1661,13 @@ func (m *RawScanRequest) GetLimit() uint32 {
 	return 0
 }
 
+func (m *RawScanRequest) GetKeyOnly() bool {
+	if m != nil {
+		return m.KeyOnly
+	}
+	return false
+}
+
 type RawScanResponse struct {
 	RegionError *errorpb.Error `protobuf:"bytes,1,opt,name=region_error,json=regionError" json:"region_error,omitempty"`
 	Kvs         []*KvPair      `protobuf:"bytes,2,rep,name=kvs" json:"kvs,omitempty"`
@@ -1514,7 +1676,7 @@ type RawScanResponse struct {
 func (m *RawScanResponse) Reset()                    { *m = RawScanResponse{} }
 func (m *RawScanResponse) String() string            { return proto.CompactTextString(m) }
 func (*RawScanResponse) ProtoMessage()               {}
-func (*RawScanResponse) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{43} }
+func (*RawScanResponse) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{49} }
 
 func (m *RawScanResponse) GetRegionError() *errorpb.Error {
 	if m != nil {
@@ -1530,96 +1692,224 @@ func (m *RawScanResponse) GetKvs() []*KvPair {
 	return nil
 }
 
-type WriteInfo struct {
-	StartTs  uint64 `protobuf:"varint,1,opt,name=start_ts,json=startTs,proto3" json:"start_ts,omitempty"`
-	Type     Op     `protobuf:"varint,2,opt,name=type,proto3,enum=kvrpcpb.Op" json:"type,omitempty"`
-	CommitTs uint64 `protobuf:"varint,3,opt,name=commit_ts,json=commitTs,proto3" json:"commit_ts,omitempty"`
+type KeyRange struct {
+	StartKey []byte `protobuf:"bytes,1,opt,name=start_key,json=startKey,proto3" json:"start_key,omitempty"`
+	EndKey   []byte `protobuf:"bytes,2,opt,name=end_key,json=endKey,proto3" json:"end_key,omitempty"`
 }
 
-func (m *WriteInfo) Reset()                    { *m = WriteInfo{} }
-func (m *WriteInfo) String() string            { return proto.CompactTextString(m) }
-func (*WriteInfo) ProtoMessage()               {}
-func (*WriteInfo) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{44} }
+func (m *KeyRange) Reset()                    { *m = KeyRange{} }
+func (m *KeyRange) String() string            { return proto.CompactTextString(m) }
+func (*KeyRange) ProtoMessage()               {}
+func (*KeyRange) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{50} }
 
-func (m *WriteInfo) GetStartTs() uint64 {
+func (m *KeyRange) GetStartKey() []byte {
 	if m != nil {
-		return m.StartTs
+		return m.StartKey
+	}
+	return nil
+}
+
+func (m *KeyRange) GetEndKey() []byte {
+	if m != nil {
+		return m.EndKey
+	}
+	return nil
+}
+
+type RawBatchScanRequest struct {
+	Context   *Context    `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"`
+	Ranges    []*KeyRange `protobuf:"bytes,2,rep,name=ranges" json:"ranges,omitempty"`
+	EachLimit uint32      `protobuf:"varint,3,opt,name=each_limit,json=eachLimit,proto3" json:"each_limit,omitempty"`
+	KeyOnly   bool        `protobuf:"varint,4,opt,name=key_only,json=keyOnly,proto3" json:"key_only,omitempty"`
+}
+
+func (m *RawBatchScanRequest) Reset()                    { *m = RawBatchScanRequest{} }
+func (m *RawBatchScanRequest) String() string            { return proto.CompactTextString(m) }
+func (*RawBatchScanRequest) ProtoMessage()               {}
+func (*RawBatchScanRequest) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{51} }
+
+func (m *RawBatchScanRequest) GetContext() *Context {
+	if m != nil {
+		return m.Context
+	}
+	return nil
+}
+
+func (m *RawBatchScanRequest) GetRanges() []*KeyRange {
+	if m != nil {
+		return m.Ranges
+	}
+	return nil
+}
+
+func (m *RawBatchScanRequest) GetEachLimit() uint32 {
+	if m != nil {
+		return m.EachLimit
 	}
 	return 0
 }
 
-func (m *WriteInfo) GetType() Op {
+func (m *RawBatchScanRequest) GetKeyOnly() bool {
+	if m != nil {
+		return m.KeyOnly
+	}
+	return false
+}
+
+type RawBatchScanResponse struct {
+	RegionError *errorpb.Error `protobuf:"bytes,1,opt,name=region_error,json=regionError" json:"region_error,omitempty"`
+	Kvs         []*KvPair      `protobuf:"bytes,2,rep,name=kvs" json:"kvs,omitempty"`
+}
+
+func (m *RawBatchScanResponse) Reset()                    { *m = RawBatchScanResponse{} }
+func (m *RawBatchScanResponse) String() string            { return proto.CompactTextString(m) }
+func (*RawBatchScanResponse) ProtoMessage()               {}
+func (*RawBatchScanResponse) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{52} }
+
+func (m *RawBatchScanResponse) GetRegionError() *errorpb.Error {
+	if m != nil {
+		return m.RegionError
+	}
+	return nil
+}
+
+func (m *RawBatchScanResponse) GetKvs() []*KvPair {
+	if m != nil {
+		return m.Kvs
+	}
+	return nil
+}
+
+type MvccWrite struct {
+	Type       Op     `protobuf:"varint,1,opt,name=type,proto3,enum=kvrpcpb.Op" json:"type,omitempty"`
+	StartTs    uint64 `protobuf:"varint,2,opt,name=start_ts,json=startTs,proto3" json:"start_ts,omitempty"`
+	CommitTs   uint64 `protobuf:"varint,3,opt,name=commit_ts,json=commitTs,proto3" json:"commit_ts,omitempty"`
+	ShortValue []byte `protobuf:"bytes,4,opt,name=short_value,json=shortValue,proto3" json:"short_value,omitempty"`
+}
+
+func (m *MvccWrite) Reset()                    { *m = MvccWrite{} }
+func (m *MvccWrite) String() string            { return proto.CompactTextString(m) }
+func (*MvccWrite) ProtoMessage()               {}
+func (*MvccWrite) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{53} }
+
+func (m *MvccWrite) GetType() Op {
 	if m != nil {
 		return m.Type
 	}
 	return Op_Put
 }
 
-func (m *WriteInfo) GetCommitTs() uint64 {
+func (m *MvccWrite) GetStartTs() uint64 {
+	if m != nil {
+		return m.StartTs
+	}
+	return 0
+}
+
+func (m *MvccWrite) GetCommitTs() uint64 {
 	if m != nil {
 		return m.CommitTs
 	}
 	return 0
 }
 
-type ValueInfo struct {
-	Value        []byte `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
-	Ts           uint64 `protobuf:"varint,2,opt,name=ts,proto3" json:"ts,omitempty"`
-	IsShortValue bool   `protobuf:"varint,3,opt,name=is_short_value,json=isShortValue,proto3" json:"is_short_value,omitempty"`
+func (m *MvccWrite) GetShortValue() []byte {
+	if m != nil {
+		return m.ShortValue
+	}
+	return nil
+}
+
+type MvccValue struct {
+	StartTs uint64 `protobuf:"varint,1,opt,name=start_ts,json=startTs,proto3" json:"start_ts,omitempty"`
+	Value   []byte `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
 }
 
-func (m *ValueInfo) Reset()                    { *m = ValueInfo{} }
-func (m *ValueInfo) String() string            { return proto.CompactTextString(m) }
-func (*ValueInfo) ProtoMessage()               {}
-func (*ValueInfo) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{45} }
+func (m *MvccValue) Reset()                    { *m = MvccValue{} }
+func (m *MvccValue) String() string            { return proto.CompactTextString(m) }
+func (*MvccValue) ProtoMessage()               {}
+func (*MvccValue) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{54} }
+
+func (m *MvccValue) GetStartTs() uint64 {
+	if m != nil {
+		return m.StartTs
+	}
+	return 0
+}
 
-func (m *ValueInfo) GetValue() []byte {
+func (m *MvccValue) GetValue() []byte {
 	if m != nil {
 		return m.Value
 	}
 	return nil
 }
 
-func (m *ValueInfo) GetTs() uint64 {
+type MvccLock struct {
+	Type       Op     `protobuf:"varint,1,opt,name=type,proto3,enum=kvrpcpb.Op" json:"type,omitempty"`
+	StartTs    uint64 `protobuf:"varint,2,opt,name=start_ts,json=startTs,proto3" json:"start_ts,omitempty"`
+	Primary    []byte `protobuf:"bytes,3,opt,name=primary,proto3" json:"primary,omitempty"`
+	ShortValue []byte `protobuf:"bytes,4,opt,name=short_value,json=shortValue,proto3" json:"short_value,omitempty"`
+}
+
+func (m *MvccLock) Reset()                    { *m = MvccLock{} }
+func (m *MvccLock) String() string            { return proto.CompactTextString(m) }
+func (*MvccLock) ProtoMessage()               {}
+func (*MvccLock) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{55} }
+
+func (m *MvccLock) GetType() Op {
+	if m != nil {
+		return m.Type
+	}
+	return Op_Put
+}
+
+func (m *MvccLock) GetStartTs() uint64 {
 	if m != nil {
-		return m.Ts
+		return m.StartTs
 	}
 	return 0
 }
 
-func (m *ValueInfo) GetIsShortValue() bool {
+func (m *MvccLock) GetPrimary() []byte {
 	if m != nil {
-		return m.IsShortValue
+		return m.Primary
 	}
-	return false
+	return nil
+}
+
+func (m *MvccLock) GetShortValue() []byte {
+	if m != nil {
+		return m.ShortValue
+	}
+	return nil
 }
 
 type MvccInfo struct {
-	Lock   *LockInfo    `protobuf:"bytes,1,opt,name=lock" json:"lock,omitempty"`
-	Writes []*WriteInfo `protobuf:"bytes,2,rep,name=writes" json:"writes,omitempty"`
-	Values []*ValueInfo `protobuf:"bytes,3,rep,name=values" json:"values,omitempty"`
+	Lock   *MvccLock    `protobuf:"bytes,1,opt,name=lock" json:"lock,omitempty"`
+	Writes []*MvccWrite `protobuf:"bytes,2,rep,name=writes" json:"writes,omitempty"`
+	Values []*MvccValue `protobuf:"bytes,3,rep,name=values" json:"values,omitempty"`
 }
 
 func (m *MvccInfo) Reset()                    { *m = MvccInfo{} }
 func (m *MvccInfo) String() string            { return proto.CompactTextString(m) }
 func (*MvccInfo) ProtoMessage()               {}
-func (*MvccInfo) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{46} }
+func (*MvccInfo) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{56} }
 
-func (m *MvccInfo) GetLock() *LockInfo {
+func (m *MvccInfo) GetLock() *MvccLock {
 	if m != nil {
 		return m.Lock
 	}
 	return nil
 }
 
-func (m *MvccInfo) GetWrites() []*WriteInfo {
+func (m *MvccInfo) GetWrites() []*MvccWrite {
 	if m != nil {
 		return m.Writes
 	}
 	return nil
 }
 
-func (m *MvccInfo) GetValues() []*ValueInfo {
+func (m *MvccInfo) GetValues() []*MvccValue {
 	if m != nil {
 		return m.Values
 	}
@@ -1634,7 +1924,7 @@ type MvccGetByKeyRequest struct {
 func (m *MvccGetByKeyRequest) Reset()                    { *m = MvccGetByKeyRequest{} }
 func (m *MvccGetByKeyRequest) String() string            { return proto.CompactTextString(m) }
 func (*MvccGetByKeyRequest) ProtoMessage()               {}
-func (*MvccGetByKeyRequest) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{47} }
+func (*MvccGetByKeyRequest) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{57} }
 
 func (m *MvccGetByKeyRequest) GetContext() *Context {
 	if m != nil {
@@ -1659,7 +1949,7 @@ type MvccGetByKeyResponse struct {
 func (m *MvccGetByKeyResponse) Reset()                    { *m = MvccGetByKeyResponse{} }
 func (m *MvccGetByKeyResponse) String() string            { return proto.CompactTextString(m) }
 func (*MvccGetByKeyResponse) ProtoMessage()               {}
-func (*MvccGetByKeyResponse) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{48} }
+func (*MvccGetByKeyResponse) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{58} }
 
 func (m *MvccGetByKeyResponse) GetRegionError() *errorpb.Error {
 	if m != nil {
@@ -1690,7 +1980,7 @@ type MvccGetByStartTsRequest struct {
 func (m *MvccGetByStartTsRequest) Reset()                    { *m = MvccGetByStartTsRequest{} }
 func (m *MvccGetByStartTsRequest) String() string            { return proto.CompactTextString(m) }
 func (*MvccGetByStartTsRequest) ProtoMessage()               {}
-func (*MvccGetByStartTsRequest) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{49} }
+func (*MvccGetByStartTsRequest) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{59} }
 
 func (m *MvccGetByStartTsRequest) GetContext() *Context {
 	if m != nil {
@@ -1716,7 +2006,7 @@ type MvccGetByStartTsResponse struct {
 func (m *MvccGetByStartTsResponse) Reset()                    { *m = MvccGetByStartTsResponse{} }
 func (m *MvccGetByStartTsResponse) String() string            { return proto.CompactTextString(m) }
 func (*MvccGetByStartTsResponse) ProtoMessage()               {}
-func (*MvccGetByStartTsResponse) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{50} }
+func (*MvccGetByStartTsResponse) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{60} }
 
 func (m *MvccGetByStartTsResponse) GetRegionError() *errorpb.Error {
 	if m != nil {
@@ -1754,7 +2044,7 @@ type SplitRegionRequest struct {
 func (m *SplitRegionRequest) Reset()                    { *m = SplitRegionRequest{} }
 func (m *SplitRegionRequest) String() string            { return proto.CompactTextString(m) }
 func (*SplitRegionRequest) ProtoMessage()               {}
-func (*SplitRegionRequest) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{51} }
+func (*SplitRegionRequest) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{61} }
 
 func (m *SplitRegionRequest) GetContext() *Context {
 	if m != nil {
@@ -1779,7 +2069,7 @@ type SplitRegionResponse struct {
 func (m *SplitRegionResponse) Reset()                    { *m = SplitRegionResponse{} }
 func (m *SplitRegionResponse) String() string            { return proto.CompactTextString(m) }
 func (*SplitRegionResponse) ProtoMessage()               {}
-func (*SplitRegionResponse) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{52} }
+func (*SplitRegionResponse) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{62} }
 
 func (m *SplitRegionResponse) GetRegionError() *errorpb.Error {
 	if m != nil {
@@ -1839,16 +2129,26 @@ func init() {
 	proto.RegisterType((*RawGetResponse)(nil), "kvrpcpb.RawGetResponse")
 	proto.RegisterType((*RawPutRequest)(nil), "kvrpcpb.RawPutRequest")
 	proto.RegisterType((*RawPutResponse)(nil), "kvrpcpb.RawPutResponse")
+	proto.RegisterType((*RawBatchPutRequest)(nil), "kvrpcpb.RawBatchPutRequest")
+	proto.RegisterType((*RawBatchPutResponse)(nil), "kvrpcpb.RawBatchPutResponse")
+	proto.RegisterType((*RawBatchGetRequest)(nil), "kvrpcpb.RawBatchGetRequest")
+	proto.RegisterType((*RawBatchGetResponse)(nil), "kvrpcpb.RawBatchGetResponse")
 	proto.RegisterType((*RawDeleteRequest)(nil), "kvrpcpb.RawDeleteRequest")
 	proto.RegisterType((*RawDeleteResponse)(nil), "kvrpcpb.RawDeleteResponse")
+	proto.RegisterType((*RawBatchDeleteRequest)(nil), "kvrpcpb.RawBatchDeleteRequest")
+	proto.RegisterType((*RawBatchDeleteResponse)(nil), "kvrpcpb.RawBatchDeleteResponse")
 	proto.RegisterType((*DeleteRangeRequest)(nil), "kvrpcpb.DeleteRangeRequest")
 	proto.RegisterType((*DeleteRangeResponse)(nil), "kvrpcpb.DeleteRangeResponse")
 	proto.RegisterType((*RawDeleteRangeRequest)(nil), "kvrpcpb.RawDeleteRangeRequest")
 	proto.RegisterType((*RawDeleteRangeResponse)(nil), "kvrpcpb.RawDeleteRangeResponse")
 	proto.RegisterType((*RawScanRequest)(nil), "kvrpcpb.RawScanRequest")
 	proto.RegisterType((*RawScanResponse)(nil), "kvrpcpb.RawScanResponse")
-	proto.RegisterType((*WriteInfo)(nil), "kvrpcpb.WriteInfo")
-	proto.RegisterType((*ValueInfo)(nil), "kvrpcpb.ValueInfo")
+	proto.RegisterType((*KeyRange)(nil), "kvrpcpb.KeyRange")
+	proto.RegisterType((*RawBatchScanRequest)(nil), "kvrpcpb.RawBatchScanRequest")
+	proto.RegisterType((*RawBatchScanResponse)(nil), "kvrpcpb.RawBatchScanResponse")
+	proto.RegisterType((*MvccWrite)(nil), "kvrpcpb.MvccWrite")
+	proto.RegisterType((*MvccValue)(nil), "kvrpcpb.MvccValue")
+	proto.RegisterType((*MvccLock)(nil), "kvrpcpb.MvccLock")
 	proto.RegisterType((*MvccInfo)(nil), "kvrpcpb.MvccInfo")
 	proto.RegisterType((*MvccGetByKeyRequest)(nil), "kvrpcpb.MvccGetByKeyRequest")
 	proto.RegisterType((*MvccGetByKeyResponse)(nil), "kvrpcpb.MvccGetByKeyResponse")
@@ -3362,7 +3662,7 @@ func (m *RawPutResponse) MarshalTo(dAtA []byte) (int, error) {
 	return i, nil
 }
 
-func (m *RawDeleteRequest) Marshal() (dAtA []byte, err error) {
+func (m *RawBatchPutRequest) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalTo(dAtA)
@@ -3372,7 +3672,7 @@ func (m *RawDeleteRequest) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *RawDeleteRequest) MarshalTo(dAtA []byte) (int, error) {
+func (m *RawBatchPutRequest) MarshalTo(dAtA []byte) (int, error) {
 	var i int
 	_ = i
 	var l int
@@ -3387,16 +3687,22 @@ func (m *RawDeleteRequest) MarshalTo(dAtA []byte) (int, error) {
 		}
 		i += n42
 	}
-	if len(m.Key) > 0 {
-		dAtA[i] = 0x12
-		i++
-		i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Key)))
-		i += copy(dAtA[i:], m.Key)
+	if len(m.Pairs) > 0 {
+		for _, msg := range m.Pairs {
+			dAtA[i] = 0x12
+			i++
+			i = encodeVarintKvrpcpb(dAtA, i, uint64(msg.Size()))
+			n, err := msg.MarshalTo(dAtA[i:])
+			if err != nil {
+				return 0, err
+			}
+			i += n
+		}
 	}
 	return i, nil
 }
 
-func (m *RawDeleteResponse) Marshal() (dAtA []byte, err error) {
+func (m *RawBatchPutResponse) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalTo(dAtA)
@@ -3406,7 +3712,7 @@ func (m *RawDeleteResponse) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *RawDeleteResponse) MarshalTo(dAtA []byte) (int, error) {
+func (m *RawBatchPutResponse) MarshalTo(dAtA []byte) (int, error) {
 	var i int
 	_ = i
 	var l int
@@ -3430,7 +3736,7 @@ func (m *RawDeleteResponse) MarshalTo(dAtA []byte) (int, error) {
 	return i, nil
 }
 
-func (m *DeleteRangeRequest) Marshal() (dAtA []byte, err error) {
+func (m *RawBatchGetRequest) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalTo(dAtA)
@@ -3440,7 +3746,7 @@ func (m *DeleteRangeRequest) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *DeleteRangeRequest) MarshalTo(dAtA []byte) (int, error) {
+func (m *RawBatchGetRequest) MarshalTo(dAtA []byte) (int, error) {
 	var i int
 	_ = i
 	var l int
@@ -3455,22 +3761,18 @@ func (m *DeleteRangeRequest) MarshalTo(dAtA []byte) (int, error) {
 		}
 		i += n44
 	}
-	if len(m.StartKey) > 0 {
-		dAtA[i] = 0x12
-		i++
-		i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.StartKey)))
-		i += copy(dAtA[i:], m.StartKey)
-	}
-	if len(m.EndKey) > 0 {
-		dAtA[i] = 0x1a
-		i++
-		i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.EndKey)))
-		i += copy(dAtA[i:], m.EndKey)
+	if len(m.Keys) > 0 {
+		for _, b := range m.Keys {
+			dAtA[i] = 0x12
+			i++
+			i = encodeVarintKvrpcpb(dAtA, i, uint64(len(b)))
+			i += copy(dAtA[i:], b)
+		}
 	}
 	return i, nil
 }
 
-func (m *DeleteRangeResponse) Marshal() (dAtA []byte, err error) {
+func (m *RawBatchGetResponse) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalTo(dAtA)
@@ -3480,7 +3782,7 @@ func (m *DeleteRangeResponse) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *DeleteRangeResponse) MarshalTo(dAtA []byte) (int, error) {
+func (m *RawBatchGetResponse) MarshalTo(dAtA []byte) (int, error) {
 	var i int
 	_ = i
 	var l int
@@ -3495,16 +3797,22 @@ func (m *DeleteRangeResponse) MarshalTo(dAtA []byte) (int, error) {
 		}
 		i += n45
 	}
-	if len(m.Error) > 0 {
-		dAtA[i] = 0x12
-		i++
-		i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Error)))
-		i += copy(dAtA[i:], m.Error)
+	if len(m.Pairs) > 0 {
+		for _, msg := range m.Pairs {
+			dAtA[i] = 0x12
+			i++
+			i = encodeVarintKvrpcpb(dAtA, i, uint64(msg.Size()))
+			n, err := msg.MarshalTo(dAtA[i:])
+			if err != nil {
+				return 0, err
+			}
+			i += n
+		}
 	}
 	return i, nil
 }
 
-func (m *RawDeleteRangeRequest) Marshal() (dAtA []byte, err error) {
+func (m *RawDeleteRequest) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalTo(dAtA)
@@ -3514,7 +3822,7 @@ func (m *RawDeleteRangeRequest) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *RawDeleteRangeRequest) MarshalTo(dAtA []byte) (int, error) {
+func (m *RawDeleteRequest) MarshalTo(dAtA []byte) (int, error) {
 	var i int
 	_ = i
 	var l int
@@ -3529,22 +3837,16 @@ func (m *RawDeleteRangeRequest) MarshalTo(dAtA []byte) (int, error) {
 		}
 		i += n46
 	}
-	if len(m.StartKey) > 0 {
+	if len(m.Key) > 0 {
 		dAtA[i] = 0x12
 		i++
-		i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.StartKey)))
-		i += copy(dAtA[i:], m.StartKey)
-	}
-	if len(m.EndKey) > 0 {
-		dAtA[i] = 0x1a
-		i++
-		i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.EndKey)))
-		i += copy(dAtA[i:], m.EndKey)
+		i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Key)))
+		i += copy(dAtA[i:], m.Key)
 	}
 	return i, nil
 }
 
-func (m *RawDeleteRangeResponse) Marshal() (dAtA []byte, err error) {
+func (m *RawDeleteResponse) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalTo(dAtA)
@@ -3554,7 +3856,7 @@ func (m *RawDeleteRangeResponse) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *RawDeleteRangeResponse) MarshalTo(dAtA []byte) (int, error) {
+func (m *RawDeleteResponse) MarshalTo(dAtA []byte) (int, error) {
 	var i int
 	_ = i
 	var l int
@@ -3578,7 +3880,7 @@ func (m *RawDeleteRangeResponse) MarshalTo(dAtA []byte) (int, error) {
 	return i, nil
 }
 
-func (m *RawScanRequest) Marshal() (dAtA []byte, err error) {
+func (m *RawBatchDeleteRequest) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalTo(dAtA)
@@ -3588,7 +3890,7 @@ func (m *RawScanRequest) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *RawScanRequest) MarshalTo(dAtA []byte) (int, error) {
+func (m *RawBatchDeleteRequest) MarshalTo(dAtA []byte) (int, error) {
 	var i int
 	_ = i
 	var l int
@@ -3603,21 +3905,18 @@ func (m *RawScanRequest) MarshalTo(dAtA []byte) (int, error) {
 		}
 		i += n48
 	}
-	if len(m.StartKey) > 0 {
-		dAtA[i] = 0x12
-		i++
-		i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.StartKey)))
-		i += copy(dAtA[i:], m.StartKey)
-	}
-	if m.Limit != 0 {
-		dAtA[i] = 0x18
-		i++
-		i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Limit))
+	if len(m.Keys) > 0 {
+		for _, b := range m.Keys {
+			dAtA[i] = 0x12
+			i++
+			i = encodeVarintKvrpcpb(dAtA, i, uint64(len(b)))
+			i += copy(dAtA[i:], b)
+		}
 	}
 	return i, nil
 }
 
-func (m *RawScanResponse) Marshal() (dAtA []byte, err error) {
+func (m *RawBatchDeleteResponse) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalTo(dAtA)
@@ -3627,7 +3926,7 @@ func (m *RawScanResponse) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *RawScanResponse) MarshalTo(dAtA []byte) (int, error) {
+func (m *RawBatchDeleteResponse) MarshalTo(dAtA []byte) (int, error) {
 	var i int
 	_ = i
 	var l int
@@ -3642,55 +3941,16 @@ func (m *RawScanResponse) MarshalTo(dAtA []byte) (int, error) {
 		}
 		i += n49
 	}
-	if len(m.Kvs) > 0 {
-		for _, msg := range m.Kvs {
-			dAtA[i] = 0x12
-			i++
-			i = encodeVarintKvrpcpb(dAtA, i, uint64(msg.Size()))
-			n, err := msg.MarshalTo(dAtA[i:])
-			if err != nil {
-				return 0, err
-			}
-			i += n
-		}
-	}
-	return i, nil
-}
-
-func (m *WriteInfo) Marshal() (dAtA []byte, err error) {
-	size := m.Size()
-	dAtA = make([]byte, size)
-	n, err := m.MarshalTo(dAtA)
-	if err != nil {
-		return nil, err
-	}
-	return dAtA[:n], nil
-}
-
-func (m *WriteInfo) MarshalTo(dAtA []byte) (int, error) {
-	var i int
-	_ = i
-	var l int
-	_ = l
-	if m.StartTs != 0 {
-		dAtA[i] = 0x8
-		i++
-		i = encodeVarintKvrpcpb(dAtA, i, uint64(m.StartTs))
-	}
-	if m.Type != 0 {
-		dAtA[i] = 0x10
-		i++
-		i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Type))
-	}
-	if m.CommitTs != 0 {
-		dAtA[i] = 0x18
+	if len(m.Error) > 0 {
+		dAtA[i] = 0x12
 		i++
-		i = encodeVarintKvrpcpb(dAtA, i, uint64(m.CommitTs))
+		i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Error)))
+		i += copy(dAtA[i:], m.Error)
 	}
 	return i, nil
 }
 
-func (m *ValueInfo) Marshal() (dAtA []byte, err error) {
+func (m *DeleteRangeRequest) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalTo(dAtA)
@@ -3700,36 +3960,37 @@ func (m *ValueInfo) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *ValueInfo) MarshalTo(dAtA []byte) (int, error) {
+func (m *DeleteRangeRequest) MarshalTo(dAtA []byte) (int, error) {
 	var i int
 	_ = i
 	var l int
 	_ = l
-	if len(m.Value) > 0 {
+	if m.Context != nil {
 		dAtA[i] = 0xa
 		i++
-		i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Value)))
-		i += copy(dAtA[i:], m.Value)
+		i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Context.Size()))
+		n50, err := m.Context.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n50
 	}
-	if m.Ts != 0 {
-		dAtA[i] = 0x10
+	if len(m.StartKey) > 0 {
+		dAtA[i] = 0x12
 		i++
-		i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Ts))
+		i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.StartKey)))
+		i += copy(dAtA[i:], m.StartKey)
 	}
-	if m.IsShortValue {
-		dAtA[i] = 0x18
-		i++
-		if m.IsShortValue {
-			dAtA[i] = 1
-		} else {
-			dAtA[i] = 0
-		}
+	if len(m.EndKey) > 0 {
+		dAtA[i] = 0x1a
 		i++
+		i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.EndKey)))
+		i += copy(dAtA[i:], m.EndKey)
 	}
 	return i, nil
 }
 
-func (m *MvccInfo) Marshal() (dAtA []byte, err error) {
+func (m *DeleteRangeResponse) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalTo(dAtA)
@@ -3739,49 +4000,31 @@ func (m *MvccInfo) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *MvccInfo) MarshalTo(dAtA []byte) (int, error) {
+func (m *DeleteRangeResponse) MarshalTo(dAtA []byte) (int, error) {
 	var i int
 	_ = i
 	var l int
 	_ = l
-	if m.Lock != nil {
+	if m.RegionError != nil {
 		dAtA[i] = 0xa
 		i++
-		i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Lock.Size()))
-		n50, err := m.Lock.MarshalTo(dAtA[i:])
+		i = encodeVarintKvrpcpb(dAtA, i, uint64(m.RegionError.Size()))
+		n51, err := m.RegionError.MarshalTo(dAtA[i:])
 		if err != nil {
 			return 0, err
 		}
-		i += n50
-	}
-	if len(m.Writes) > 0 {
-		for _, msg := range m.Writes {
-			dAtA[i] = 0x12
-			i++
-			i = encodeVarintKvrpcpb(dAtA, i, uint64(msg.Size()))
-			n, err := msg.MarshalTo(dAtA[i:])
-			if err != nil {
-				return 0, err
-			}
-			i += n
-		}
+		i += n51
 	}
-	if len(m.Values) > 0 {
-		for _, msg := range m.Values {
-			dAtA[i] = 0x1a
-			i++
-			i = encodeVarintKvrpcpb(dAtA, i, uint64(msg.Size()))
-			n, err := msg.MarshalTo(dAtA[i:])
-			if err != nil {
-				return 0, err
-			}
-			i += n
-		}
+	if len(m.Error) > 0 {
+		dAtA[i] = 0x12
+		i++
+		i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Error)))
+		i += copy(dAtA[i:], m.Error)
 	}
 	return i, nil
 }
 
-func (m *MvccGetByKeyRequest) Marshal() (dAtA []byte, err error) {
+func (m *RawDeleteRangeRequest) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalTo(dAtA)
@@ -3791,7 +4034,7 @@ func (m *MvccGetByKeyRequest) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *MvccGetByKeyRequest) MarshalTo(dAtA []byte) (int, error) {
+func (m *RawDeleteRangeRequest) MarshalTo(dAtA []byte) (int, error) {
 	var i int
 	_ = i
 	var l int
@@ -3800,22 +4043,28 @@ func (m *MvccGetByKeyRequest) MarshalTo(dAtA []byte) (int, error) {
 		dAtA[i] = 0xa
 		i++
 		i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Context.Size()))
-		n51, err := m.Context.MarshalTo(dAtA[i:])
+		n52, err := m.Context.MarshalTo(dAtA[i:])
 		if err != nil {
 			return 0, err
 		}
-		i += n51
+		i += n52
 	}
-	if len(m.Key) > 0 {
+	if len(m.StartKey) > 0 {
 		dAtA[i] = 0x12
 		i++
-		i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Key)))
-		i += copy(dAtA[i:], m.Key)
+		i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.StartKey)))
+		i += copy(dAtA[i:], m.StartKey)
+	}
+	if len(m.EndKey) > 0 {
+		dAtA[i] = 0x1a
+		i++
+		i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.EndKey)))
+		i += copy(dAtA[i:], m.EndKey)
 	}
 	return i, nil
 }
 
-func (m *MvccGetByKeyResponse) Marshal() (dAtA []byte, err error) {
+func (m *RawDeleteRangeResponse) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalTo(dAtA)
@@ -3825,7 +4074,7 @@ func (m *MvccGetByKeyResponse) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *MvccGetByKeyResponse) MarshalTo(dAtA []byte) (int, error) {
+func (m *RawDeleteRangeResponse) MarshalTo(dAtA []byte) (int, error) {
 	var i int
 	_ = i
 	var l int
@@ -3834,11 +4083,11 @@ func (m *MvccGetByKeyResponse) MarshalTo(dAtA []byte) (int, error) {
 		dAtA[i] = 0xa
 		i++
 		i = encodeVarintKvrpcpb(dAtA, i, uint64(m.RegionError.Size()))
-		n52, err := m.RegionError.MarshalTo(dAtA[i:])
+		n53, err := m.RegionError.MarshalTo(dAtA[i:])
 		if err != nil {
 			return 0, err
 		}
-		i += n52
+		i += n53
 	}
 	if len(m.Error) > 0 {
 		dAtA[i] = 0x12
@@ -3846,20 +4095,10 @@ func (m *MvccGetByKeyResponse) MarshalTo(dAtA []byte) (int, error) {
 		i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Error)))
 		i += copy(dAtA[i:], m.Error)
 	}
-	if m.Info != nil {
-		dAtA[i] = 0x1a
-		i++
-		i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Info.Size()))
-		n53, err := m.Info.MarshalTo(dAtA[i:])
-		if err != nil {
-			return 0, err
-		}
-		i += n53
-	}
 	return i, nil
 }
 
-func (m *MvccGetByStartTsRequest) Marshal() (dAtA []byte, err error) {
+func (m *RawScanRequest) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalTo(dAtA)
@@ -3869,7 +4108,7 @@ func (m *MvccGetByStartTsRequest) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *MvccGetByStartTsRequest) MarshalTo(dAtA []byte) (int, error) {
+func (m *RawScanRequest) MarshalTo(dAtA []byte) (int, error) {
 	var i int
 	_ = i
 	var l int
@@ -3884,15 +4123,31 @@ func (m *MvccGetByStartTsRequest) MarshalTo(dAtA []byte) (int, error) {
 		}
 		i += n54
 	}
-	if m.StartTs != 0 {
-		dAtA[i] = 0x10
+	if len(m.StartKey) > 0 {
+		dAtA[i] = 0x12
+		i++
+		i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.StartKey)))
+		i += copy(dAtA[i:], m.StartKey)
+	}
+	if m.Limit != 0 {
+		dAtA[i] = 0x18
+		i++
+		i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Limit))
+	}
+	if m.KeyOnly {
+		dAtA[i] = 0x20
+		i++
+		if m.KeyOnly {
+			dAtA[i] = 1
+		} else {
+			dAtA[i] = 0
+		}
 		i++
-		i = encodeVarintKvrpcpb(dAtA, i, uint64(m.StartTs))
 	}
 	return i, nil
 }
 
-func (m *MvccGetByStartTsResponse) Marshal() (dAtA []byte, err error) {
+func (m *RawScanResponse) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalTo(dAtA)
@@ -3902,7 +4157,7 @@ func (m *MvccGetByStartTsResponse) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *MvccGetByStartTsResponse) MarshalTo(dAtA []byte) (int, error) {
+func (m *RawScanResponse) MarshalTo(dAtA []byte) (int, error) {
 	var i int
 	_ = i
 	var l int
@@ -3917,32 +4172,22 @@ func (m *MvccGetByStartTsResponse) MarshalTo(dAtA []byte) (int, error) {
 		}
 		i += n55
 	}
-	if len(m.Error) > 0 {
-		dAtA[i] = 0x12
-		i++
-		i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Error)))
-		i += copy(dAtA[i:], m.Error)
-	}
-	if len(m.Key) > 0 {
-		dAtA[i] = 0x1a
-		i++
-		i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Key)))
-		i += copy(dAtA[i:], m.Key)
-	}
-	if m.Info != nil {
-		dAtA[i] = 0x22
-		i++
-		i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Info.Size()))
-		n56, err := m.Info.MarshalTo(dAtA[i:])
-		if err != nil {
-			return 0, err
+	if len(m.Kvs) > 0 {
+		for _, msg := range m.Kvs {
+			dAtA[i] = 0x12
+			i++
+			i = encodeVarintKvrpcpb(dAtA, i, uint64(msg.Size()))
+			n, err := msg.MarshalTo(dAtA[i:])
+			if err != nil {
+				return 0, err
+			}
+			i += n
 		}
-		i += n56
 	}
 	return i, nil
 }
 
-func (m *SplitRegionRequest) Marshal() (dAtA []byte, err error) {
+func (m *KeyRange) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalTo(dAtA)
@@ -3952,31 +4197,27 @@ func (m *SplitRegionRequest) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *SplitRegionRequest) MarshalTo(dAtA []byte) (int, error) {
+func (m *KeyRange) MarshalTo(dAtA []byte) (int, error) {
 	var i int
 	_ = i
 	var l int
 	_ = l
-	if m.Context != nil {
+	if len(m.StartKey) > 0 {
 		dAtA[i] = 0xa
 		i++
-		i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Context.Size()))
-		n57, err := m.Context.MarshalTo(dAtA[i:])
-		if err != nil {
-			return 0, err
-		}
-		i += n57
+		i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.StartKey)))
+		i += copy(dAtA[i:], m.StartKey)
 	}
-	if len(m.SplitKey) > 0 {
+	if len(m.EndKey) > 0 {
 		dAtA[i] = 0x12
 		i++
-		i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.SplitKey)))
-		i += copy(dAtA[i:], m.SplitKey)
+		i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.EndKey)))
+		i += copy(dAtA[i:], m.EndKey)
 	}
 	return i, nil
 }
 
-func (m *SplitRegionResponse) Marshal() (dAtA []byte, err error) {
+func (m *RawBatchScanRequest) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalTo(dAtA)
@@ -3986,501 +4227,663 @@ func (m *SplitRegionResponse) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *SplitRegionResponse) MarshalTo(dAtA []byte) (int, error) {
+func (m *RawBatchScanRequest) MarshalTo(dAtA []byte) (int, error) {
 	var i int
 	_ = i
 	var l int
 	_ = l
-	if m.RegionError != nil {
+	if m.Context != nil {
 		dAtA[i] = 0xa
 		i++
-		i = encodeVarintKvrpcpb(dAtA, i, uint64(m.RegionError.Size()))
-		n58, err := m.RegionError.MarshalTo(dAtA[i:])
+		i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Context.Size()))
+		n56, err := m.Context.MarshalTo(dAtA[i:])
 		if err != nil {
 			return 0, err
 		}
-		i += n58
+		i += n56
 	}
-	if m.Left != nil {
-		dAtA[i] = 0x12
-		i++
-		i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Left.Size()))
-		n59, err := m.Left.MarshalTo(dAtA[i:])
-		if err != nil {
-			return 0, err
+	if len(m.Ranges) > 0 {
+		for _, msg := range m.Ranges {
+			dAtA[i] = 0x12
+			i++
+			i = encodeVarintKvrpcpb(dAtA, i, uint64(msg.Size()))
+			n, err := msg.MarshalTo(dAtA[i:])
+			if err != nil {
+				return 0, err
+			}
+			i += n
 		}
-		i += n59
 	}
-	if m.Right != nil {
-		dAtA[i] = 0x1a
+	if m.EachLimit != 0 {
+		dAtA[i] = 0x18
 		i++
-		i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Right.Size()))
-		n60, err := m.Right.MarshalTo(dAtA[i:])
-		if err != nil {
-			return 0, err
+		i = encodeVarintKvrpcpb(dAtA, i, uint64(m.EachLimit))
+	}
+	if m.KeyOnly {
+		dAtA[i] = 0x20
+		i++
+		if m.KeyOnly {
+			dAtA[i] = 1
+		} else {
+			dAtA[i] = 0
 		}
-		i += n60
+		i++
 	}
 	return i, nil
 }
 
-func encodeFixed64Kvrpcpb(dAtA []byte, offset int, v uint64) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	dAtA[offset+4] = uint8(v >> 32)
-	dAtA[offset+5] = uint8(v >> 40)
-	dAtA[offset+6] = uint8(v >> 48)
-	dAtA[offset+7] = uint8(v >> 56)
-	return offset + 8
-}
-func encodeFixed32Kvrpcpb(dAtA []byte, offset int, v uint32) int {
-	dAtA[offset] = uint8(v)
-	dAtA[offset+1] = uint8(v >> 8)
-	dAtA[offset+2] = uint8(v >> 16)
-	dAtA[offset+3] = uint8(v >> 24)
-	return offset + 4
-}
-func encodeVarintKvrpcpb(dAtA []byte, offset int, v uint64) int {
-	for v >= 1<<7 {
-		dAtA[offset] = uint8(v&0x7f | 0x80)
-		v >>= 7
-		offset++
+func (m *RawBatchScanResponse) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
 	}
-	dAtA[offset] = uint8(v)
-	return offset + 1
+	return dAtA[:n], nil
 }
-func (m *LockInfo) Size() (n int) {
+
+func (m *RawBatchScanResponse) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
 	var l int
 	_ = l
-	l = len(m.PrimaryLock)
-	if l > 0 {
-		n += 1 + l + sovKvrpcpb(uint64(l))
-	}
-	if m.LockVersion != 0 {
-		n += 1 + sovKvrpcpb(uint64(m.LockVersion))
-	}
-	l = len(m.Key)
-	if l > 0 {
-		n += 1 + l + sovKvrpcpb(uint64(l))
+	if m.RegionError != nil {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintKvrpcpb(dAtA, i, uint64(m.RegionError.Size()))
+		n57, err := m.RegionError.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n57
 	}
-	if m.LockTtl != 0 {
-		n += 1 + sovKvrpcpb(uint64(m.LockTtl))
+	if len(m.Kvs) > 0 {
+		for _, msg := range m.Kvs {
+			dAtA[i] = 0x12
+			i++
+			i = encodeVarintKvrpcpb(dAtA, i, uint64(msg.Size()))
+			n, err := msg.MarshalTo(dAtA[i:])
+			if err != nil {
+				return 0, err
+			}
+			i += n
+		}
 	}
-	return n
+	return i, nil
 }
 
-func (m *KeyError) Size() (n int) {
-	var l int
-	_ = l
-	if m.Locked != nil {
-		l = m.Locked.Size()
-		n += 1 + l + sovKvrpcpb(uint64(l))
-	}
-	l = len(m.Retryable)
-	if l > 0 {
-		n += 1 + l + sovKvrpcpb(uint64(l))
-	}
-	l = len(m.Abort)
-	if l > 0 {
-		n += 1 + l + sovKvrpcpb(uint64(l))
+func (m *MvccWrite) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
 	}
-	return n
+	return dAtA[:n], nil
 }
 
-func (m *Context) Size() (n int) {
+func (m *MvccWrite) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
 	var l int
 	_ = l
-	if m.RegionId != 0 {
-		n += 1 + sovKvrpcpb(uint64(m.RegionId))
-	}
-	if m.RegionEpoch != nil {
-		l = m.RegionEpoch.Size()
-		n += 1 + l + sovKvrpcpb(uint64(l))
-	}
-	if m.Peer != nil {
-		l = m.Peer.Size()
-		n += 1 + l + sovKvrpcpb(uint64(l))
-	}
-	if m.Term != 0 {
-		n += 1 + sovKvrpcpb(uint64(m.Term))
-	}
-	if m.Priority != 0 {
-		n += 1 + sovKvrpcpb(uint64(m.Priority))
-	}
-	if m.IsolationLevel != 0 {
-		n += 1 + sovKvrpcpb(uint64(m.IsolationLevel))
+	if m.Type != 0 {
+		dAtA[i] = 0x8
+		i++
+		i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Type))
 	}
-	if m.NotFillCache {
-		n += 2
+	if m.StartTs != 0 {
+		dAtA[i] = 0x10
+		i++
+		i = encodeVarintKvrpcpb(dAtA, i, uint64(m.StartTs))
 	}
-	if m.SyncLog {
-		n += 2
+	if m.CommitTs != 0 {
+		dAtA[i] = 0x18
+		i++
+		i = encodeVarintKvrpcpb(dAtA, i, uint64(m.CommitTs))
 	}
-	if m.HandleTime {
-		n += 2
+	if len(m.ShortValue) > 0 {
+		dAtA[i] = 0x22
+		i++
+		i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.ShortValue)))
+		i += copy(dAtA[i:], m.ShortValue)
 	}
-	if m.ScanDetail {
-		n += 2
+	return i, nil
+}
+
+func (m *MvccValue) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
 	}
-	return n
+	return dAtA[:n], nil
 }
 
-func (m *HandleTime) Size() (n int) {
+func (m *MvccValue) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
 	var l int
 	_ = l
-	if m.WaitMs != 0 {
-		n += 1 + sovKvrpcpb(uint64(m.WaitMs))
+	if m.StartTs != 0 {
+		dAtA[i] = 0x8
+		i++
+		i = encodeVarintKvrpcpb(dAtA, i, uint64(m.StartTs))
 	}
-	if m.ProcessMs != 0 {
-		n += 1 + sovKvrpcpb(uint64(m.ProcessMs))
+	if len(m.Value) > 0 {
+		dAtA[i] = 0x12
+		i++
+		i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Value)))
+		i += copy(dAtA[i:], m.Value)
 	}
-	return n
+	return i, nil
 }
 
-func (m *ScanInfo) Size() (n int) {
-	var l int
-	_ = l
-	if m.Total != 0 {
-		n += 1 + sovKvrpcpb(uint64(m.Total))
-	}
-	if m.Processed != 0 {
-		n += 1 + sovKvrpcpb(uint64(m.Processed))
+func (m *MvccLock) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
 	}
-	return n
+	return dAtA[:n], nil
 }
 
-func (m *ScanDetail) Size() (n int) {
+func (m *MvccLock) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
 	var l int
 	_ = l
-	if m.Write != nil {
-		l = m.Write.Size()
-		n += 1 + l + sovKvrpcpb(uint64(l))
+	if m.Type != 0 {
+		dAtA[i] = 0x8
+		i++
+		i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Type))
 	}
-	if m.Lock != nil {
-		l = m.Lock.Size()
-		n += 1 + l + sovKvrpcpb(uint64(l))
+	if m.StartTs != 0 {
+		dAtA[i] = 0x10
+		i++
+		i = encodeVarintKvrpcpb(dAtA, i, uint64(m.StartTs))
 	}
-	if m.Data != nil {
-		l = m.Data.Size()
-		n += 1 + l + sovKvrpcpb(uint64(l))
+	if len(m.Primary) > 0 {
+		dAtA[i] = 0x1a
+		i++
+		i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Primary)))
+		i += copy(dAtA[i:], m.Primary)
 	}
-	return n
+	if len(m.ShortValue) > 0 {
+		dAtA[i] = 0x22
+		i++
+		i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.ShortValue)))
+		i += copy(dAtA[i:], m.ShortValue)
+	}
+	return i, nil
 }
 
-func (m *ExecDetails) Size() (n int) {
+func (m *MvccInfo) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *MvccInfo) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
 	var l int
 	_ = l
-	if m.HandleTime != nil {
-		l = m.HandleTime.Size()
-		n += 1 + l + sovKvrpcpb(uint64(l))
+	if m.Lock != nil {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Lock.Size()))
+		n58, err := m.Lock.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n58
 	}
-	if m.ScanDetail != nil {
-		l = m.ScanDetail.Size()
-		n += 1 + l + sovKvrpcpb(uint64(l))
+	if len(m.Writes) > 0 {
+		for _, msg := range m.Writes {
+			dAtA[i] = 0x12
+			i++
+			i = encodeVarintKvrpcpb(dAtA, i, uint64(msg.Size()))
+			n, err := msg.MarshalTo(dAtA[i:])
+			if err != nil {
+				return 0, err
+			}
+			i += n
+		}
 	}
-	return n
+	if len(m.Values) > 0 {
+		for _, msg := range m.Values {
+			dAtA[i] = 0x1a
+			i++
+			i = encodeVarintKvrpcpb(dAtA, i, uint64(msg.Size()))
+			n, err := msg.MarshalTo(dAtA[i:])
+			if err != nil {
+				return 0, err
+			}
+			i += n
+		}
+	}
+	return i, nil
 }
 
-func (m *GetRequest) Size() (n int) {
+func (m *MvccGetByKeyRequest) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *MvccGetByKeyRequest) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
 	var l int
 	_ = l
 	if m.Context != nil {
-		l = m.Context.Size()
-		n += 1 + l + sovKvrpcpb(uint64(l))
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Context.Size()))
+		n59, err := m.Context.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n59
 	}
-	l = len(m.Key)
-	if l > 0 {
-		n += 1 + l + sovKvrpcpb(uint64(l))
+	if len(m.Key) > 0 {
+		dAtA[i] = 0x12
+		i++
+		i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Key)))
+		i += copy(dAtA[i:], m.Key)
 	}
-	if m.Version != 0 {
-		n += 1 + sovKvrpcpb(uint64(m.Version))
+	return i, nil
+}
+
+func (m *MvccGetByKeyResponse) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
 	}
-	return n
+	return dAtA[:n], nil
 }
 
-func (m *GetResponse) Size() (n int) {
+func (m *MvccGetByKeyResponse) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
 	var l int
 	_ = l
 	if m.RegionError != nil {
-		l = m.RegionError.Size()
-		n += 1 + l + sovKvrpcpb(uint64(l))
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintKvrpcpb(dAtA, i, uint64(m.RegionError.Size()))
+		n60, err := m.RegionError.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n60
 	}
-	if m.Error != nil {
-		l = m.Error.Size()
-		n += 1 + l + sovKvrpcpb(uint64(l))
+	if len(m.Error) > 0 {
+		dAtA[i] = 0x12
+		i++
+		i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Error)))
+		i += copy(dAtA[i:], m.Error)
 	}
-	l = len(m.Value)
-	if l > 0 {
-		n += 1 + l + sovKvrpcpb(uint64(l))
+	if m.Info != nil {
+		dAtA[i] = 0x1a
+		i++
+		i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Info.Size()))
+		n61, err := m.Info.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n61
 	}
-	return n
+	return i, nil
 }
 
-func (m *ScanRequest) Size() (n int) {
-	var l int
-	_ = l
-	if m.Context != nil {
-		l = m.Context.Size()
-		n += 1 + l + sovKvrpcpb(uint64(l))
-	}
-	l = len(m.StartKey)
-	if l > 0 {
-		n += 1 + l + sovKvrpcpb(uint64(l))
-	}
-	if m.Limit != 0 {
-		n += 1 + sovKvrpcpb(uint64(m.Limit))
-	}
-	if m.Version != 0 {
-		n += 1 + sovKvrpcpb(uint64(m.Version))
-	}
-	if m.KeyOnly {
-		n += 2
+func (m *MvccGetByStartTsRequest) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
 	}
-	return n
+	return dAtA[:n], nil
 }
 
-func (m *KvPair) Size() (n int) {
+func (m *MvccGetByStartTsRequest) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
 	var l int
 	_ = l
-	if m.Error != nil {
-		l = m.Error.Size()
-		n += 1 + l + sovKvrpcpb(uint64(l))
+	if m.Context != nil {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Context.Size()))
+		n62, err := m.Context.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n62
 	}
-	l = len(m.Key)
-	if l > 0 {
-		n += 1 + l + sovKvrpcpb(uint64(l))
+	if m.StartTs != 0 {
+		dAtA[i] = 0x10
+		i++
+		i = encodeVarintKvrpcpb(dAtA, i, uint64(m.StartTs))
 	}
-	l = len(m.Value)
-	if l > 0 {
-		n += 1 + l + sovKvrpcpb(uint64(l))
+	return i, nil
+}
+
+func (m *MvccGetByStartTsResponse) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
 	}
-	return n
+	return dAtA[:n], nil
 }
 
-func (m *ScanResponse) Size() (n int) {
+func (m *MvccGetByStartTsResponse) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
 	var l int
 	_ = l
 	if m.RegionError != nil {
-		l = m.RegionError.Size()
-		n += 1 + l + sovKvrpcpb(uint64(l))
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintKvrpcpb(dAtA, i, uint64(m.RegionError.Size()))
+		n63, err := m.RegionError.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n63
 	}
-	if len(m.Pairs) > 0 {
-		for _, e := range m.Pairs {
-			l = e.Size()
-			n += 1 + l + sovKvrpcpb(uint64(l))
+	if len(m.Error) > 0 {
+		dAtA[i] = 0x12
+		i++
+		i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Error)))
+		i += copy(dAtA[i:], m.Error)
+	}
+	if len(m.Key) > 0 {
+		dAtA[i] = 0x1a
+		i++
+		i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Key)))
+		i += copy(dAtA[i:], m.Key)
+	}
+	if m.Info != nil {
+		dAtA[i] = 0x22
+		i++
+		i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Info.Size()))
+		n64, err := m.Info.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
 		}
+		i += n64
 	}
-	return n
+	return i, nil
 }
 
-func (m *Mutation) Size() (n int) {
-	var l int
-	_ = l
-	if m.Op != 0 {
-		n += 1 + sovKvrpcpb(uint64(m.Op))
-	}
-	l = len(m.Key)
-	if l > 0 {
-		n += 1 + l + sovKvrpcpb(uint64(l))
-	}
-	l = len(m.Value)
-	if l > 0 {
-		n += 1 + l + sovKvrpcpb(uint64(l))
+func (m *SplitRegionRequest) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
 	}
-	return n
+	return dAtA[:n], nil
 }
 
-func (m *PrewriteRequest) Size() (n int) {
+func (m *SplitRegionRequest) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
 	var l int
 	_ = l
 	if m.Context != nil {
-		l = m.Context.Size()
-		n += 1 + l + sovKvrpcpb(uint64(l))
-	}
-	if len(m.Mutations) > 0 {
-		for _, e := range m.Mutations {
-			l = e.Size()
-			n += 1 + l + sovKvrpcpb(uint64(l))
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Context.Size()))
+		n65, err := m.Context.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
 		}
+		i += n65
 	}
-	l = len(m.PrimaryLock)
-	if l > 0 {
-		n += 1 + l + sovKvrpcpb(uint64(l))
-	}
-	if m.StartVersion != 0 {
-		n += 1 + sovKvrpcpb(uint64(m.StartVersion))
-	}
-	if m.LockTtl != 0 {
-		n += 1 + sovKvrpcpb(uint64(m.LockTtl))
+	if len(m.SplitKey) > 0 {
+		dAtA[i] = 0x12
+		i++
+		i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.SplitKey)))
+		i += copy(dAtA[i:], m.SplitKey)
 	}
-	if m.SkipConstraintCheck {
-		n += 2
+	return i, nil
+}
+
+func (m *SplitRegionResponse) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
 	}
-	return n
+	return dAtA[:n], nil
 }
 
-func (m *PrewriteResponse) Size() (n int) {
+func (m *SplitRegionResponse) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
 	var l int
 	_ = l
 	if m.RegionError != nil {
-		l = m.RegionError.Size()
-		n += 1 + l + sovKvrpcpb(uint64(l))
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintKvrpcpb(dAtA, i, uint64(m.RegionError.Size()))
+		n66, err := m.RegionError.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n66
 	}
-	if len(m.Errors) > 0 {
-		for _, e := range m.Errors {
-			l = e.Size()
-			n += 1 + l + sovKvrpcpb(uint64(l))
+	if m.Left != nil {
+		dAtA[i] = 0x12
+		i++
+		i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Left.Size()))
+		n67, err := m.Left.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
 		}
+		i += n67
 	}
-	return n
+	if m.Right != nil {
+		dAtA[i] = 0x1a
+		i++
+		i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Right.Size()))
+		n68, err := m.Right.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n68
+	}
+	return i, nil
 }
 
-func (m *CommitRequest) Size() (n int) {
+func encodeFixed64Kvrpcpb(dAtA []byte, offset int, v uint64) int {
+	dAtA[offset] = uint8(v)
+	dAtA[offset+1] = uint8(v >> 8)
+	dAtA[offset+2] = uint8(v >> 16)
+	dAtA[offset+3] = uint8(v >> 24)
+	dAtA[offset+4] = uint8(v >> 32)
+	dAtA[offset+5] = uint8(v >> 40)
+	dAtA[offset+6] = uint8(v >> 48)
+	dAtA[offset+7] = uint8(v >> 56)
+	return offset + 8
+}
+func encodeFixed32Kvrpcpb(dAtA []byte, offset int, v uint32) int {
+	dAtA[offset] = uint8(v)
+	dAtA[offset+1] = uint8(v >> 8)
+	dAtA[offset+2] = uint8(v >> 16)
+	dAtA[offset+3] = uint8(v >> 24)
+	return offset + 4
+}
+func encodeVarintKvrpcpb(dAtA []byte, offset int, v uint64) int {
+	for v >= 1<<7 {
+		dAtA[offset] = uint8(v&0x7f | 0x80)
+		v >>= 7
+		offset++
+	}
+	dAtA[offset] = uint8(v)
+	return offset + 1
+}
+func (m *LockInfo) Size() (n int) {
 	var l int
 	_ = l
-	if m.Context != nil {
-		l = m.Context.Size()
+	l = len(m.PrimaryLock)
+	if l > 0 {
 		n += 1 + l + sovKvrpcpb(uint64(l))
 	}
-	if m.StartVersion != 0 {
-		n += 1 + sovKvrpcpb(uint64(m.StartVersion))
+	if m.LockVersion != 0 {
+		n += 1 + sovKvrpcpb(uint64(m.LockVersion))
 	}
-	if len(m.Keys) > 0 {
-		for _, b := range m.Keys {
-			l = len(b)
-			n += 1 + l + sovKvrpcpb(uint64(l))
-		}
+	l = len(m.Key)
+	if l > 0 {
+		n += 1 + l + sovKvrpcpb(uint64(l))
 	}
-	if m.CommitVersion != 0 {
-		n += 1 + sovKvrpcpb(uint64(m.CommitVersion))
+	if m.LockTtl != 0 {
+		n += 1 + sovKvrpcpb(uint64(m.LockTtl))
 	}
 	return n
 }
 
-func (m *CommitResponse) Size() (n int) {
+func (m *KeyError) Size() (n int) {
 	var l int
 	_ = l
-	if m.RegionError != nil {
-		l = m.RegionError.Size()
+	if m.Locked != nil {
+		l = m.Locked.Size()
 		n += 1 + l + sovKvrpcpb(uint64(l))
 	}
-	if m.Error != nil {
-		l = m.Error.Size()
+	l = len(m.Retryable)
+	if l > 0 {
 		n += 1 + l + sovKvrpcpb(uint64(l))
 	}
-	return n
-}
-
-func (m *ImportRequest) Size() (n int) {
-	var l int
-	_ = l
-	if len(m.Mutations) > 0 {
-		for _, e := range m.Mutations {
-			l = e.Size()
-			n += 1 + l + sovKvrpcpb(uint64(l))
-		}
-	}
-	if m.CommitVersion != 0 {
-		n += 1 + sovKvrpcpb(uint64(m.CommitVersion))
+	l = len(m.Abort)
+	if l > 0 {
+		n += 1 + l + sovKvrpcpb(uint64(l))
 	}
 	return n
 }
 
-func (m *ImportResponse) Size() (n int) {
+func (m *Context) Size() (n int) {
 	var l int
 	_ = l
-	if m.RegionError != nil {
-		l = m.RegionError.Size()
+	if m.RegionId != 0 {
+		n += 1 + sovKvrpcpb(uint64(m.RegionId))
+	}
+	if m.RegionEpoch != nil {
+		l = m.RegionEpoch.Size()
 		n += 1 + l + sovKvrpcpb(uint64(l))
 	}
-	l = len(m.Error)
-	if l > 0 {
+	if m.Peer != nil {
+		l = m.Peer.Size()
 		n += 1 + l + sovKvrpcpb(uint64(l))
 	}
+	if m.Term != 0 {
+		n += 1 + sovKvrpcpb(uint64(m.Term))
+	}
+	if m.Priority != 0 {
+		n += 1 + sovKvrpcpb(uint64(m.Priority))
+	}
+	if m.IsolationLevel != 0 {
+		n += 1 + sovKvrpcpb(uint64(m.IsolationLevel))
+	}
+	if m.NotFillCache {
+		n += 2
+	}
+	if m.SyncLog {
+		n += 2
+	}
+	if m.HandleTime {
+		n += 2
+	}
+	if m.ScanDetail {
+		n += 2
+	}
 	return n
 }
 
-func (m *BatchRollbackRequest) Size() (n int) {
+func (m *HandleTime) Size() (n int) {
 	var l int
 	_ = l
-	if m.Context != nil {
-		l = m.Context.Size()
-		n += 1 + l + sovKvrpcpb(uint64(l))
-	}
-	if m.StartVersion != 0 {
-		n += 1 + sovKvrpcpb(uint64(m.StartVersion))
+	if m.WaitMs != 0 {
+		n += 1 + sovKvrpcpb(uint64(m.WaitMs))
 	}
-	if len(m.Keys) > 0 {
-		for _, b := range m.Keys {
-			l = len(b)
-			n += 1 + l + sovKvrpcpb(uint64(l))
-		}
+	if m.ProcessMs != 0 {
+		n += 1 + sovKvrpcpb(uint64(m.ProcessMs))
 	}
 	return n
 }
 
-func (m *BatchRollbackResponse) Size() (n int) {
+func (m *ScanInfo) Size() (n int) {
 	var l int
 	_ = l
-	if m.RegionError != nil {
-		l = m.RegionError.Size()
-		n += 1 + l + sovKvrpcpb(uint64(l))
+	if m.Total != 0 {
+		n += 1 + sovKvrpcpb(uint64(m.Total))
 	}
-	if m.Error != nil {
-		l = m.Error.Size()
-		n += 1 + l + sovKvrpcpb(uint64(l))
+	if m.Processed != 0 {
+		n += 1 + sovKvrpcpb(uint64(m.Processed))
 	}
 	return n
 }
 
-func (m *CleanupRequest) Size() (n int) {
+func (m *ScanDetail) Size() (n int) {
 	var l int
 	_ = l
-	if m.Context != nil {
-		l = m.Context.Size()
+	if m.Write != nil {
+		l = m.Write.Size()
 		n += 1 + l + sovKvrpcpb(uint64(l))
 	}
-	l = len(m.Key)
-	if l > 0 {
+	if m.Lock != nil {
+		l = m.Lock.Size()
 		n += 1 + l + sovKvrpcpb(uint64(l))
 	}
-	if m.StartVersion != 0 {
-		n += 1 + sovKvrpcpb(uint64(m.StartVersion))
+	if m.Data != nil {
+		l = m.Data.Size()
+		n += 1 + l + sovKvrpcpb(uint64(l))
 	}
 	return n
 }
 
-func (m *CleanupResponse) Size() (n int) {
+func (m *ExecDetails) Size() (n int) {
 	var l int
 	_ = l
-	if m.RegionError != nil {
-		l = m.RegionError.Size()
+	if m.HandleTime != nil {
+		l = m.HandleTime.Size()
 		n += 1 + l + sovKvrpcpb(uint64(l))
 	}
-	if m.Error != nil {
-		l = m.Error.Size()
+	if m.ScanDetail != nil {
+		l = m.ScanDetail.Size()
 		n += 1 + l + sovKvrpcpb(uint64(l))
 	}
-	if m.CommitVersion != 0 {
-		n += 1 + sovKvrpcpb(uint64(m.CommitVersion))
-	}
 	return n
 }
 
-func (m *BatchGetRequest) Size() (n int) {
+func (m *GetRequest) Size() (n int) {
 	var l int
 	_ = l
 	if m.Context != nil {
 		l = m.Context.Size()
 		n += 1 + l + sovKvrpcpb(uint64(l))
 	}
-	if len(m.Keys) > 0 {
-		for _, b := range m.Keys {
-			l = len(b)
-			n += 1 + l + sovKvrpcpb(uint64(l))
-		}
+	l = len(m.Key)
+	if l > 0 {
+		n += 1 + l + sovKvrpcpb(uint64(l))
 	}
 	if m.Version != 0 {
 		n += 1 + sovKvrpcpb(uint64(m.Version))
@@ -4488,32 +4891,31 @@ func (m *BatchGetRequest) Size() (n int) {
 	return n
 }
 
-func (m *BatchGetResponse) Size() (n int) {
+func (m *GetResponse) Size() (n int) {
 	var l int
 	_ = l
 	if m.RegionError != nil {
 		l = m.RegionError.Size()
 		n += 1 + l + sovKvrpcpb(uint64(l))
 	}
-	if len(m.Pairs) > 0 {
-		for _, e := range m.Pairs {
-			l = e.Size()
-			n += 1 + l + sovKvrpcpb(uint64(l))
-		}
+	if m.Error != nil {
+		l = m.Error.Size()
+		n += 1 + l + sovKvrpcpb(uint64(l))
+	}
+	l = len(m.Value)
+	if l > 0 {
+		n += 1 + l + sovKvrpcpb(uint64(l))
 	}
 	return n
 }
 
-func (m *ScanLockRequest) Size() (n int) {
+func (m *ScanRequest) Size() (n int) {
 	var l int
 	_ = l
 	if m.Context != nil {
 		l = m.Context.Size()
 		n += 1 + l + sovKvrpcpb(uint64(l))
 	}
-	if m.MaxVersion != 0 {
-		n += 1 + sovKvrpcpb(uint64(m.MaxVersion))
-	}
 	l = len(m.StartKey)
 	if l > 0 {
 		n += 1 + l + sovKvrpcpb(uint64(l))
@@ -4521,22 +4923,42 @@ func (m *ScanLockRequest) Size() (n int) {
 	if m.Limit != 0 {
 		n += 1 + sovKvrpcpb(uint64(m.Limit))
 	}
+	if m.Version != 0 {
+		n += 1 + sovKvrpcpb(uint64(m.Version))
+	}
+	if m.KeyOnly {
+		n += 2
+	}
 	return n
 }
 
-func (m *ScanLockResponse) Size() (n int) {
+func (m *KvPair) Size() (n int) {
 	var l int
 	_ = l
-	if m.RegionError != nil {
-		l = m.RegionError.Size()
-		n += 1 + l + sovKvrpcpb(uint64(l))
-	}
 	if m.Error != nil {
 		l = m.Error.Size()
 		n += 1 + l + sovKvrpcpb(uint64(l))
 	}
-	if len(m.Locks) > 0 {
-		for _, e := range m.Locks {
+	l = len(m.Key)
+	if l > 0 {
+		n += 1 + l + sovKvrpcpb(uint64(l))
+	}
+	l = len(m.Value)
+	if l > 0 {
+		n += 1 + l + sovKvrpcpb(uint64(l))
+	}
+	return n
+}
+
+func (m *ScanResponse) Size() (n int) {
+	var l int
+	_ = l
+	if m.RegionError != nil {
+		l = m.RegionError.Size()
+		n += 1 + l + sovKvrpcpb(uint64(l))
+	}
+	if len(m.Pairs) > 0 {
+		for _, e := range m.Pairs {
 			l = e.Size()
 			n += 1 + l + sovKvrpcpb(uint64(l))
 		}
@@ -4544,68 +4966,91 @@ func (m *ScanLockResponse) Size() (n int) {
 	return n
 }
 
-func (m *TxnInfo) Size() (n int) {
+func (m *Mutation) Size() (n int) {
 	var l int
 	_ = l
-	if m.Txn != 0 {
-		n += 1 + sovKvrpcpb(uint64(m.Txn))
+	if m.Op != 0 {
+		n += 1 + sovKvrpcpb(uint64(m.Op))
 	}
-	if m.Status != 0 {
-		n += 1 + sovKvrpcpb(uint64(m.Status))
+	l = len(m.Key)
+	if l > 0 {
+		n += 1 + l + sovKvrpcpb(uint64(l))
+	}
+	l = len(m.Value)
+	if l > 0 {
+		n += 1 + l + sovKvrpcpb(uint64(l))
 	}
 	return n
 }
 
-func (m *ResolveLockRequest) Size() (n int) {
+func (m *PrewriteRequest) Size() (n int) {
 	var l int
 	_ = l
 	if m.Context != nil {
 		l = m.Context.Size()
 		n += 1 + l + sovKvrpcpb(uint64(l))
 	}
+	if len(m.Mutations) > 0 {
+		for _, e := range m.Mutations {
+			l = e.Size()
+			n += 1 + l + sovKvrpcpb(uint64(l))
+		}
+	}
+	l = len(m.PrimaryLock)
+	if l > 0 {
+		n += 1 + l + sovKvrpcpb(uint64(l))
+	}
 	if m.StartVersion != 0 {
 		n += 1 + sovKvrpcpb(uint64(m.StartVersion))
 	}
-	if m.CommitVersion != 0 {
-		n += 1 + sovKvrpcpb(uint64(m.CommitVersion))
+	if m.LockTtl != 0 {
+		n += 1 + sovKvrpcpb(uint64(m.LockTtl))
 	}
-	if len(m.TxnInfos) > 0 {
-		for _, e := range m.TxnInfos {
-			l = e.Size()
-			n += 1 + l + sovKvrpcpb(uint64(l))
-		}
+	if m.SkipConstraintCheck {
+		n += 2
 	}
 	return n
 }
 
-func (m *ResolveLockResponse) Size() (n int) {
+func (m *PrewriteResponse) Size() (n int) {
 	var l int
 	_ = l
 	if m.RegionError != nil {
 		l = m.RegionError.Size()
 		n += 1 + l + sovKvrpcpb(uint64(l))
 	}
-	if m.Error != nil {
-		l = m.Error.Size()
-		n += 1 + l + sovKvrpcpb(uint64(l))
+	if len(m.Errors) > 0 {
+		for _, e := range m.Errors {
+			l = e.Size()
+			n += 1 + l + sovKvrpcpb(uint64(l))
+		}
 	}
 	return n
 }
 
-func (m *GCRequest) Size() (n int) {
+func (m *CommitRequest) Size() (n int) {
 	var l int
 	_ = l
 	if m.Context != nil {
 		l = m.Context.Size()
 		n += 1 + l + sovKvrpcpb(uint64(l))
 	}
-	if m.SafePoint != 0 {
-		n += 1 + sovKvrpcpb(uint64(m.SafePoint))
+	if m.StartVersion != 0 {
+		n += 1 + sovKvrpcpb(uint64(m.StartVersion))
+	}
+	if len(m.Keys) > 0 {
+		for _, b := range m.Keys {
+			l = len(b)
+			n += 1 + l + sovKvrpcpb(uint64(l))
+		}
+	}
+	if m.CommitVersion != 0 {
+		n += 1 + sovKvrpcpb(uint64(m.CommitVersion))
 	}
 	return n
 }
 
-func (m *GCResponse) Size() (n int) {
+func (m *CommitResponse) Size() (n int) {
 	var l int
 	_ = l
 	if m.RegionError != nil {
@@ -4619,21 +5064,22 @@ func (m *GCResponse) Size() (n int) {
 	return n
 }
 
-func (m *RawGetRequest) Size() (n int) {
+func (m *ImportRequest) Size() (n int) {
 	var l int
 	_ = l
-	if m.Context != nil {
-		l = m.Context.Size()
-		n += 1 + l + sovKvrpcpb(uint64(l))
+	if len(m.Mutations) > 0 {
+		for _, e := range m.Mutations {
+			l = e.Size()
+			n += 1 + l + sovKvrpcpb(uint64(l))
+		}
 	}
-	l = len(m.Key)
-	if l > 0 {
-		n += 1 + l + sovKvrpcpb(uint64(l))
+	if m.CommitVersion != 0 {
+		n += 1 + sovKvrpcpb(uint64(m.CommitVersion))
 	}
 	return n
 }
 
-func (m *RawGetResponse) Size() (n int) {
+func (m *ImportResponse) Size() (n int) {
 	var l int
 	_ = l
 	if m.RegionError != nil {
@@ -4644,46 +5090,43 @@ func (m *RawGetResponse) Size() (n int) {
 	if l > 0 {
 		n += 1 + l + sovKvrpcpb(uint64(l))
 	}
-	l = len(m.Value)
-	if l > 0 {
-		n += 1 + l + sovKvrpcpb(uint64(l))
-	}
 	return n
 }
 
-func (m *RawPutRequest) Size() (n int) {
+func (m *BatchRollbackRequest) Size() (n int) {
 	var l int
 	_ = l
 	if m.Context != nil {
 		l = m.Context.Size()
 		n += 1 + l + sovKvrpcpb(uint64(l))
 	}
-	l = len(m.Key)
-	if l > 0 {
-		n += 1 + l + sovKvrpcpb(uint64(l))
+	if m.StartVersion != 0 {
+		n += 1 + sovKvrpcpb(uint64(m.StartVersion))
 	}
-	l = len(m.Value)
-	if l > 0 {
-		n += 1 + l + sovKvrpcpb(uint64(l))
+	if len(m.Keys) > 0 {
+		for _, b := range m.Keys {
+			l = len(b)
+			n += 1 + l + sovKvrpcpb(uint64(l))
+		}
 	}
 	return n
 }
 
-func (m *RawPutResponse) Size() (n int) {
+func (m *BatchRollbackResponse) Size() (n int) {
 	var l int
 	_ = l
 	if m.RegionError != nil {
 		l = m.RegionError.Size()
 		n += 1 + l + sovKvrpcpb(uint64(l))
 	}
-	l = len(m.Error)
-	if l > 0 {
+	if m.Error != nil {
+		l = m.Error.Size()
 		n += 1 + l + sovKvrpcpb(uint64(l))
 	}
 	return n
 }
 
-func (m *RawDeleteRequest) Size() (n int) {
+func (m *CleanupRequest) Size() (n int) {
 	var l int
 	_ = l
 	if m.Context != nil {
@@ -4694,113 +5137,131 @@ func (m *RawDeleteRequest) Size() (n int) {
 	if l > 0 {
 		n += 1 + l + sovKvrpcpb(uint64(l))
 	}
+	if m.StartVersion != 0 {
+		n += 1 + sovKvrpcpb(uint64(m.StartVersion))
+	}
 	return n
 }
 
-func (m *RawDeleteResponse) Size() (n int) {
+func (m *CleanupResponse) Size() (n int) {
 	var l int
 	_ = l
 	if m.RegionError != nil {
 		l = m.RegionError.Size()
 		n += 1 + l + sovKvrpcpb(uint64(l))
 	}
-	l = len(m.Error)
-	if l > 0 {
+	if m.Error != nil {
+		l = m.Error.Size()
 		n += 1 + l + sovKvrpcpb(uint64(l))
 	}
+	if m.CommitVersion != 0 {
+		n += 1 + sovKvrpcpb(uint64(m.CommitVersion))
+	}
 	return n
 }
 
-func (m *DeleteRangeRequest) Size() (n int) {
+func (m *BatchGetRequest) Size() (n int) {
 	var l int
 	_ = l
 	if m.Context != nil {
 		l = m.Context.Size()
 		n += 1 + l + sovKvrpcpb(uint64(l))
 	}
-	l = len(m.StartKey)
-	if l > 0 {
-		n += 1 + l + sovKvrpcpb(uint64(l))
+	if len(m.Keys) > 0 {
+		for _, b := range m.Keys {
+			l = len(b)
+			n += 1 + l + sovKvrpcpb(uint64(l))
+		}
 	}
-	l = len(m.EndKey)
-	if l > 0 {
-		n += 1 + l + sovKvrpcpb(uint64(l))
+	if m.Version != 0 {
+		n += 1 + sovKvrpcpb(uint64(m.Version))
 	}
 	return n
 }
 
-func (m *DeleteRangeResponse) Size() (n int) {
+func (m *BatchGetResponse) Size() (n int) {
 	var l int
 	_ = l
 	if m.RegionError != nil {
 		l = m.RegionError.Size()
 		n += 1 + l + sovKvrpcpb(uint64(l))
 	}
-	l = len(m.Error)
-	if l > 0 {
-		n += 1 + l + sovKvrpcpb(uint64(l))
+	if len(m.Pairs) > 0 {
+		for _, e := range m.Pairs {
+			l = e.Size()
+			n += 1 + l + sovKvrpcpb(uint64(l))
+		}
 	}
 	return n
 }
 
-func (m *RawDeleteRangeRequest) Size() (n int) {
+func (m *ScanLockRequest) Size() (n int) {
 	var l int
 	_ = l
 	if m.Context != nil {
 		l = m.Context.Size()
 		n += 1 + l + sovKvrpcpb(uint64(l))
 	}
+	if m.MaxVersion != 0 {
+		n += 1 + sovKvrpcpb(uint64(m.MaxVersion))
+	}
 	l = len(m.StartKey)
 	if l > 0 {
 		n += 1 + l + sovKvrpcpb(uint64(l))
 	}
-	l = len(m.EndKey)
-	if l > 0 {
-		n += 1 + l + sovKvrpcpb(uint64(l))
+	if m.Limit != 0 {
+		n += 1 + sovKvrpcpb(uint64(m.Limit))
 	}
 	return n
 }
 
-func (m *RawDeleteRangeResponse) Size() (n int) {
+func (m *ScanLockResponse) Size() (n int) {
 	var l int
 	_ = l
 	if m.RegionError != nil {
 		l = m.RegionError.Size()
 		n += 1 + l + sovKvrpcpb(uint64(l))
 	}
-	l = len(m.Error)
-	if l > 0 {
+	if m.Error != nil {
+		l = m.Error.Size()
 		n += 1 + l + sovKvrpcpb(uint64(l))
 	}
+	if len(m.Locks) > 0 {
+		for _, e := range m.Locks {
+			l = e.Size()
+			n += 1 + l + sovKvrpcpb(uint64(l))
+		}
+	}
 	return n
 }
 
-func (m *RawScanRequest) Size() (n int) {
+func (m *TxnInfo) Size() (n int) {
 	var l int
 	_ = l
-	if m.Context != nil {
-		l = m.Context.Size()
-		n += 1 + l + sovKvrpcpb(uint64(l))
-	}
-	l = len(m.StartKey)
-	if l > 0 {
-		n += 1 + l + sovKvrpcpb(uint64(l))
+	if m.Txn != 0 {
+		n += 1 + sovKvrpcpb(uint64(m.Txn))
 	}
-	if m.Limit != 0 {
-		n += 1 + sovKvrpcpb(uint64(m.Limit))
+	if m.Status != 0 {
+		n += 1 + sovKvrpcpb(uint64(m.Status))
 	}
 	return n
 }
 
-func (m *RawScanResponse) Size() (n int) {
+func (m *ResolveLockRequest) Size() (n int) {
 	var l int
 	_ = l
-	if m.RegionError != nil {
-		l = m.RegionError.Size()
+	if m.Context != nil {
+		l = m.Context.Size()
 		n += 1 + l + sovKvrpcpb(uint64(l))
 	}
-	if len(m.Kvs) > 0 {
-		for _, e := range m.Kvs {
+	if m.StartVersion != 0 {
+		n += 1 + sovKvrpcpb(uint64(m.StartVersion))
+	}
+	if m.CommitVersion != 0 {
+		n += 1 + sovKvrpcpb(uint64(m.CommitVersion))
+	}
+	if len(m.TxnInfos) > 0 {
+		for _, e := range m.TxnInfos {
 			l = e.Size()
 			n += 1 + l + sovKvrpcpb(uint64(l))
 		}
@@ -4808,52 +5269,166 @@ func (m *RawScanResponse) Size() (n int) {
 	return n
 }
 
-func (m *WriteInfo) Size() (n int) {
+func (m *ResolveLockResponse) Size() (n int) {
 	var l int
 	_ = l
-	if m.StartTs != 0 {
-		n += 1 + sovKvrpcpb(uint64(m.StartTs))
-	}
-	if m.Type != 0 {
-		n += 1 + sovKvrpcpb(uint64(m.Type))
+	if m.RegionError != nil {
+		l = m.RegionError.Size()
+		n += 1 + l + sovKvrpcpb(uint64(l))
 	}
-	if m.CommitTs != 0 {
-		n += 1 + sovKvrpcpb(uint64(m.CommitTs))
+	if m.Error != nil {
+		l = m.Error.Size()
+		n += 1 + l + sovKvrpcpb(uint64(l))
 	}
 	return n
 }
 
-func (m *ValueInfo) Size() (n int) {
+func (m *GCRequest) Size() (n int) {
 	var l int
 	_ = l
-	l = len(m.Value)
-	if l > 0 {
+	if m.Context != nil {
+		l = m.Context.Size()
 		n += 1 + l + sovKvrpcpb(uint64(l))
 	}
-	if m.Ts != 0 {
-		n += 1 + sovKvrpcpb(uint64(m.Ts))
-	}
-	if m.IsShortValue {
-		n += 2
+	if m.SafePoint != 0 {
+		n += 1 + sovKvrpcpb(uint64(m.SafePoint))
 	}
 	return n
 }
 
-func (m *MvccInfo) Size() (n int) {
+func (m *GCResponse) Size() (n int) {
 	var l int
 	_ = l
-	if m.Lock != nil {
-		l = m.Lock.Size()
+	if m.RegionError != nil {
+		l = m.RegionError.Size()
 		n += 1 + l + sovKvrpcpb(uint64(l))
 	}
-	if len(m.Writes) > 0 {
-		for _, e := range m.Writes {
+	if m.Error != nil {
+		l = m.Error.Size()
+		n += 1 + l + sovKvrpcpb(uint64(l))
+	}
+	return n
+}
+
+func (m *RawGetRequest) Size() (n int) {
+	var l int
+	_ = l
+	if m.Context != nil {
+		l = m.Context.Size()
+		n += 1 + l + sovKvrpcpb(uint64(l))
+	}
+	l = len(m.Key)
+	if l > 0 {
+		n += 1 + l + sovKvrpcpb(uint64(l))
+	}
+	return n
+}
+
+func (m *RawGetResponse) Size() (n int) {
+	var l int
+	_ = l
+	if m.RegionError != nil {
+		l = m.RegionError.Size()
+		n += 1 + l + sovKvrpcpb(uint64(l))
+	}
+	l = len(m.Error)
+	if l > 0 {
+		n += 1 + l + sovKvrpcpb(uint64(l))
+	}
+	l = len(m.Value)
+	if l > 0 {
+		n += 1 + l + sovKvrpcpb(uint64(l))
+	}
+	return n
+}
+
+func (m *RawPutRequest) Size() (n int) {
+	var l int
+	_ = l
+	if m.Context != nil {
+		l = m.Context.Size()
+		n += 1 + l + sovKvrpcpb(uint64(l))
+	}
+	l = len(m.Key)
+	if l > 0 {
+		n += 1 + l + sovKvrpcpb(uint64(l))
+	}
+	l = len(m.Value)
+	if l > 0 {
+		n += 1 + l + sovKvrpcpb(uint64(l))
+	}
+	return n
+}
+
+func (m *RawPutResponse) Size() (n int) {
+	var l int
+	_ = l
+	if m.RegionError != nil {
+		l = m.RegionError.Size()
+		n += 1 + l + sovKvrpcpb(uint64(l))
+	}
+	l = len(m.Error)
+	if l > 0 {
+		n += 1 + l + sovKvrpcpb(uint64(l))
+	}
+	return n
+}
+
+func (m *RawBatchPutRequest) Size() (n int) {
+	var l int
+	_ = l
+	if m.Context != nil {
+		l = m.Context.Size()
+		n += 1 + l + sovKvrpcpb(uint64(l))
+	}
+	if len(m.Pairs) > 0 {
+		for _, e := range m.Pairs {
 			l = e.Size()
 			n += 1 + l + sovKvrpcpb(uint64(l))
 		}
 	}
-	if len(m.Values) > 0 {
-		for _, e := range m.Values {
+	return n
+}
+
+func (m *RawBatchPutResponse) Size() (n int) {
+	var l int
+	_ = l
+	if m.RegionError != nil {
+		l = m.RegionError.Size()
+		n += 1 + l + sovKvrpcpb(uint64(l))
+	}
+	l = len(m.Error)
+	if l > 0 {
+		n += 1 + l + sovKvrpcpb(uint64(l))
+	}
+	return n
+}
+
+func (m *RawBatchGetRequest) Size() (n int) {
+	var l int
+	_ = l
+	if m.Context != nil {
+		l = m.Context.Size()
+		n += 1 + l + sovKvrpcpb(uint64(l))
+	}
+	if len(m.Keys) > 0 {
+		for _, b := range m.Keys {
+			l = len(b)
+			n += 1 + l + sovKvrpcpb(uint64(l))
+		}
+	}
+	return n
+}
+
+func (m *RawBatchGetResponse) Size() (n int) {
+	var l int
+	_ = l
+	if m.RegionError != nil {
+		l = m.RegionError.Size()
+		n += 1 + l + sovKvrpcpb(uint64(l))
+	}
+	if len(m.Pairs) > 0 {
+		for _, e := range m.Pairs {
 			l = e.Size()
 			n += 1 + l + sovKvrpcpb(uint64(l))
 		}
@@ -4861,7 +5436,7 @@ func (m *MvccInfo) Size() (n int) {
 	return n
 }
 
-func (m *MvccGetByKeyRequest) Size() (n int) {
+func (m *RawDeleteRequest) Size() (n int) {
 	var l int
 	_ = l
 	if m.Context != nil {
@@ -4875,7 +5450,7 @@ func (m *MvccGetByKeyRequest) Size() (n int) {
 	return n
 }
 
-func (m *MvccGetByKeyResponse) Size() (n int) {
+func (m *RawDeleteResponse) Size() (n int) {
 	var l int
 	_ = l
 	if m.RegionError != nil {
@@ -4886,27 +5461,58 @@ func (m *MvccGetByKeyResponse) Size() (n int) {
 	if l > 0 {
 		n += 1 + l + sovKvrpcpb(uint64(l))
 	}
-	if m.Info != nil {
-		l = m.Info.Size()
+	return n
+}
+
+func (m *RawBatchDeleteRequest) Size() (n int) {
+	var l int
+	_ = l
+	if m.Context != nil {
+		l = m.Context.Size()
 		n += 1 + l + sovKvrpcpb(uint64(l))
 	}
+	if len(m.Keys) > 0 {
+		for _, b := range m.Keys {
+			l = len(b)
+			n += 1 + l + sovKvrpcpb(uint64(l))
+		}
+	}
 	return n
 }
 
-func (m *MvccGetByStartTsRequest) Size() (n int) {
+func (m *RawBatchDeleteResponse) Size() (n int) {
+	var l int
+	_ = l
+	if m.RegionError != nil {
+		l = m.RegionError.Size()
+		n += 1 + l + sovKvrpcpb(uint64(l))
+	}
+	l = len(m.Error)
+	if l > 0 {
+		n += 1 + l + sovKvrpcpb(uint64(l))
+	}
+	return n
+}
+
+func (m *DeleteRangeRequest) Size() (n int) {
 	var l int
 	_ = l
 	if m.Context != nil {
 		l = m.Context.Size()
 		n += 1 + l + sovKvrpcpb(uint64(l))
 	}
-	if m.StartTs != 0 {
-		n += 1 + sovKvrpcpb(uint64(m.StartTs))
+	l = len(m.StartKey)
+	if l > 0 {
+		n += 1 + l + sovKvrpcpb(uint64(l))
+	}
+	l = len(m.EndKey)
+	if l > 0 {
+		n += 1 + l + sovKvrpcpb(uint64(l))
 	}
 	return n
 }
 
-func (m *MvccGetByStartTsResponse) Size() (n int) {
+func (m *DeleteRangeResponse) Size() (n int) {
 	var l int
 	_ = l
 	if m.RegionError != nil {
@@ -4917,63 +5523,1320 @@ func (m *MvccGetByStartTsResponse) Size() (n int) {
 	if l > 0 {
 		n += 1 + l + sovKvrpcpb(uint64(l))
 	}
-	l = len(m.Key)
+	return n
+}
+
+func (m *RawDeleteRangeRequest) Size() (n int) {
+	var l int
+	_ = l
+	if m.Context != nil {
+		l = m.Context.Size()
+		n += 1 + l + sovKvrpcpb(uint64(l))
+	}
+	l = len(m.StartKey)
 	if l > 0 {
 		n += 1 + l + sovKvrpcpb(uint64(l))
 	}
-	if m.Info != nil {
-		l = m.Info.Size()
+	l = len(m.EndKey)
+	if l > 0 {
 		n += 1 + l + sovKvrpcpb(uint64(l))
 	}
 	return n
 }
 
-func (m *SplitRegionRequest) Size() (n int) {
+func (m *RawDeleteRangeResponse) Size() (n int) {
+	var l int
+	_ = l
+	if m.RegionError != nil {
+		l = m.RegionError.Size()
+		n += 1 + l + sovKvrpcpb(uint64(l))
+	}
+	l = len(m.Error)
+	if l > 0 {
+		n += 1 + l + sovKvrpcpb(uint64(l))
+	}
+	return n
+}
+
+func (m *RawScanRequest) Size() (n int) {
 	var l int
 	_ = l
 	if m.Context != nil {
 		l = m.Context.Size()
 		n += 1 + l + sovKvrpcpb(uint64(l))
 	}
-	l = len(m.SplitKey)
+	l = len(m.StartKey)
 	if l > 0 {
 		n += 1 + l + sovKvrpcpb(uint64(l))
 	}
+	if m.Limit != 0 {
+		n += 1 + sovKvrpcpb(uint64(m.Limit))
+	}
+	if m.KeyOnly {
+		n += 2
+	}
 	return n
 }
 
-func (m *SplitRegionResponse) Size() (n int) {
+func (m *RawScanResponse) Size() (n int) {
 	var l int
 	_ = l
 	if m.RegionError != nil {
 		l = m.RegionError.Size()
 		n += 1 + l + sovKvrpcpb(uint64(l))
 	}
-	if m.Left != nil {
-		l = m.Left.Size()
+	if len(m.Kvs) > 0 {
+		for _, e := range m.Kvs {
+			l = e.Size()
+			n += 1 + l + sovKvrpcpb(uint64(l))
+		}
+	}
+	return n
+}
+
+func (m *KeyRange) Size() (n int) {
+	var l int
+	_ = l
+	l = len(m.StartKey)
+	if l > 0 {
 		n += 1 + l + sovKvrpcpb(uint64(l))
 	}
-	if m.Right != nil {
-		l = m.Right.Size()
+	l = len(m.EndKey)
+	if l > 0 {
 		n += 1 + l + sovKvrpcpb(uint64(l))
 	}
 	return n
 }
 
-func sovKvrpcpb(x uint64) (n int) {
-	for {
-		n++
-		x >>= 7
-		if x == 0 {
-			break
+func (m *RawBatchScanRequest) Size() (n int) {
+	var l int
+	_ = l
+	if m.Context != nil {
+		l = m.Context.Size()
+		n += 1 + l + sovKvrpcpb(uint64(l))
+	}
+	if len(m.Ranges) > 0 {
+		for _, e := range m.Ranges {
+			l = e.Size()
+			n += 1 + l + sovKvrpcpb(uint64(l))
+		}
+	}
+	if m.EachLimit != 0 {
+		n += 1 + sovKvrpcpb(uint64(m.EachLimit))
+	}
+	if m.KeyOnly {
+		n += 2
+	}
+	return n
+}
+
+func (m *RawBatchScanResponse) Size() (n int) {
+	var l int
+	_ = l
+	if m.RegionError != nil {
+		l = m.RegionError.Size()
+		n += 1 + l + sovKvrpcpb(uint64(l))
+	}
+	if len(m.Kvs) > 0 {
+		for _, e := range m.Kvs {
+			l = e.Size()
+			n += 1 + l + sovKvrpcpb(uint64(l))
+		}
+	}
+	return n
+}
+
+func (m *MvccWrite) Size() (n int) {
+	var l int
+	_ = l
+	if m.Type != 0 {
+		n += 1 + sovKvrpcpb(uint64(m.Type))
+	}
+	if m.StartTs != 0 {
+		n += 1 + sovKvrpcpb(uint64(m.StartTs))
+	}
+	if m.CommitTs != 0 {
+		n += 1 + sovKvrpcpb(uint64(m.CommitTs))
+	}
+	l = len(m.ShortValue)
+	if l > 0 {
+		n += 1 + l + sovKvrpcpb(uint64(l))
+	}
+	return n
+}
+
+func (m *MvccValue) Size() (n int) {
+	var l int
+	_ = l
+	if m.StartTs != 0 {
+		n += 1 + sovKvrpcpb(uint64(m.StartTs))
+	}
+	l = len(m.Value)
+	if l > 0 {
+		n += 1 + l + sovKvrpcpb(uint64(l))
+	}
+	return n
+}
+
+func (m *MvccLock) Size() (n int) {
+	var l int
+	_ = l
+	if m.Type != 0 {
+		n += 1 + sovKvrpcpb(uint64(m.Type))
+	}
+	if m.StartTs != 0 {
+		n += 1 + sovKvrpcpb(uint64(m.StartTs))
+	}
+	l = len(m.Primary)
+	if l > 0 {
+		n += 1 + l + sovKvrpcpb(uint64(l))
+	}
+	l = len(m.ShortValue)
+	if l > 0 {
+		n += 1 + l + sovKvrpcpb(uint64(l))
+	}
+	return n
+}
+
+func (m *MvccInfo) Size() (n int) {
+	var l int
+	_ = l
+	if m.Lock != nil {
+		l = m.Lock.Size()
+		n += 1 + l + sovKvrpcpb(uint64(l))
+	}
+	if len(m.Writes) > 0 {
+		for _, e := range m.Writes {
+			l = e.Size()
+			n += 1 + l + sovKvrpcpb(uint64(l))
+		}
+	}
+	if len(m.Values) > 0 {
+		for _, e := range m.Values {
+			l = e.Size()
+			n += 1 + l + sovKvrpcpb(uint64(l))
+		}
+	}
+	return n
+}
+
+func (m *MvccGetByKeyRequest) Size() (n int) {
+	var l int
+	_ = l
+	if m.Context != nil {
+		l = m.Context.Size()
+		n += 1 + l + sovKvrpcpb(uint64(l))
+	}
+	l = len(m.Key)
+	if l > 0 {
+		n += 1 + l + sovKvrpcpb(uint64(l))
+	}
+	return n
+}
+
+func (m *MvccGetByKeyResponse) Size() (n int) {
+	var l int
+	_ = l
+	if m.RegionError != nil {
+		l = m.RegionError.Size()
+		n += 1 + l + sovKvrpcpb(uint64(l))
+	}
+	l = len(m.Error)
+	if l > 0 {
+		n += 1 + l + sovKvrpcpb(uint64(l))
+	}
+	if m.Info != nil {
+		l = m.Info.Size()
+		n += 1 + l + sovKvrpcpb(uint64(l))
+	}
+	return n
+}
+
+func (m *MvccGetByStartTsRequest) Size() (n int) {
+	var l int
+	_ = l
+	if m.Context != nil {
+		l = m.Context.Size()
+		n += 1 + l + sovKvrpcpb(uint64(l))
+	}
+	if m.StartTs != 0 {
+		n += 1 + sovKvrpcpb(uint64(m.StartTs))
+	}
+	return n
+}
+
+func (m *MvccGetByStartTsResponse) Size() (n int) {
+	var l int
+	_ = l
+	if m.RegionError != nil {
+		l = m.RegionError.Size()
+		n += 1 + l + sovKvrpcpb(uint64(l))
+	}
+	l = len(m.Error)
+	if l > 0 {
+		n += 1 + l + sovKvrpcpb(uint64(l))
+	}
+	l = len(m.Key)
+	if l > 0 {
+		n += 1 + l + sovKvrpcpb(uint64(l))
+	}
+	if m.Info != nil {
+		l = m.Info.Size()
+		n += 1 + l + sovKvrpcpb(uint64(l))
+	}
+	return n
+}
+
+func (m *SplitRegionRequest) Size() (n int) {
+	var l int
+	_ = l
+	if m.Context != nil {
+		l = m.Context.Size()
+		n += 1 + l + sovKvrpcpb(uint64(l))
+	}
+	l = len(m.SplitKey)
+	if l > 0 {
+		n += 1 + l + sovKvrpcpb(uint64(l))
+	}
+	return n
+}
+
+func (m *SplitRegionResponse) Size() (n int) {
+	var l int
+	_ = l
+	if m.RegionError != nil {
+		l = m.RegionError.Size()
+		n += 1 + l + sovKvrpcpb(uint64(l))
+	}
+	if m.Left != nil {
+		l = m.Left.Size()
+		n += 1 + l + sovKvrpcpb(uint64(l))
+	}
+	if m.Right != nil {
+		l = m.Right.Size()
+		n += 1 + l + sovKvrpcpb(uint64(l))
+	}
+	return n
+}
+
+func sovKvrpcpb(x uint64) (n int) {
+	for {
+		n++
+		x >>= 7
+		if x == 0 {
+			break
+		}
+	}
+	return n
+}
+func sozKvrpcpb(x uint64) (n int) {
+	return sovKvrpcpb(uint64((x << 1) ^ uint64((int64(x) >> 63))))
+}
+func (m *LockInfo) 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 ErrIntOverflowKvrpcpb
+			}
+			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: LockInfo: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: LockInfo: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field PrimaryLock", wireType)
+			}
+			var byteLen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowKvrpcpb
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				byteLen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if byteLen < 0 {
+				return ErrInvalidLengthKvrpcpb
+			}
+			postIndex := iNdEx + byteLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.PrimaryLock = append(m.PrimaryLock[:0], dAtA[iNdEx:postIndex]...)
+			if m.PrimaryLock == nil {
+				m.PrimaryLock = []byte{}
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field LockVersion", wireType)
+			}
+			m.LockVersion = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowKvrpcpb
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.LockVersion |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
+			}
+			var byteLen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowKvrpcpb
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				byteLen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if byteLen < 0 {
+				return ErrInvalidLengthKvrpcpb
+			}
+			postIndex := iNdEx + byteLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...)
+			if m.Key == nil {
+				m.Key = []byte{}
+			}
+			iNdEx = postIndex
+		case 4:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field LockTtl", wireType)
+			}
+			m.LockTtl = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowKvrpcpb
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.LockTtl |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		default:
+			iNdEx = preIndex
+			skippy, err := skipKvrpcpb(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthKvrpcpb
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *KeyError) 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 ErrIntOverflowKvrpcpb
+			}
+			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: KeyError: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: KeyError: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Locked", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowKvrpcpb
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthKvrpcpb
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Locked == nil {
+				m.Locked = &LockInfo{}
+			}
+			if err := m.Locked.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Retryable", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowKvrpcpb
+				}
+				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 ErrInvalidLengthKvrpcpb
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Retryable = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Abort", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowKvrpcpb
+				}
+				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 ErrInvalidLengthKvrpcpb
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Abort = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipKvrpcpb(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthKvrpcpb
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *Context) 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 ErrIntOverflowKvrpcpb
+			}
+			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: Context: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: Context: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field RegionId", wireType)
+			}
+			m.RegionId = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowKvrpcpb
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.RegionId |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field RegionEpoch", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowKvrpcpb
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthKvrpcpb
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.RegionEpoch == nil {
+				m.RegionEpoch = &metapb.RegionEpoch{}
+			}
+			if err := m.RegionEpoch.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Peer", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowKvrpcpb
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthKvrpcpb
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Peer == nil {
+				m.Peer = &metapb.Peer{}
+			}
+			if err := m.Peer.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 5:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Term", wireType)
+			}
+			m.Term = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowKvrpcpb
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Term |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 6:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Priority", wireType)
+			}
+			m.Priority = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowKvrpcpb
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Priority |= (CommandPri(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 7:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field IsolationLevel", wireType)
+			}
+			m.IsolationLevel = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowKvrpcpb
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.IsolationLevel |= (IsolationLevel(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 8:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field NotFillCache", wireType)
+			}
+			var v int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowKvrpcpb
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				v |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			m.NotFillCache = bool(v != 0)
+		case 9:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field SyncLog", wireType)
+			}
+			var v int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowKvrpcpb
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				v |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			m.SyncLog = bool(v != 0)
+		case 10:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field HandleTime", wireType)
+			}
+			var v int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowKvrpcpb
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				v |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			m.HandleTime = bool(v != 0)
+		case 11:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ScanDetail", wireType)
+			}
+			var v int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowKvrpcpb
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				v |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			m.ScanDetail = bool(v != 0)
+		default:
+			iNdEx = preIndex
+			skippy, err := skipKvrpcpb(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthKvrpcpb
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *HandleTime) 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 ErrIntOverflowKvrpcpb
+			}
+			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: HandleTime: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: HandleTime: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field WaitMs", wireType)
+			}
+			m.WaitMs = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowKvrpcpb
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.WaitMs |= (int64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 2:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ProcessMs", wireType)
+			}
+			m.ProcessMs = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowKvrpcpb
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.ProcessMs |= (int64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		default:
+			iNdEx = preIndex
+			skippy, err := skipKvrpcpb(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthKvrpcpb
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *ScanInfo) 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 ErrIntOverflowKvrpcpb
+			}
+			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: ScanInfo: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: ScanInfo: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Total", wireType)
+			}
+			m.Total = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowKvrpcpb
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Total |= (int64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 2:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Processed", wireType)
+			}
+			m.Processed = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowKvrpcpb
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Processed |= (int64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		default:
+			iNdEx = preIndex
+			skippy, err := skipKvrpcpb(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthKvrpcpb
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *ScanDetail) 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 ErrIntOverflowKvrpcpb
+			}
+			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: ScanDetail: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: ScanDetail: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Write", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowKvrpcpb
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthKvrpcpb
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Write == nil {
+				m.Write = &ScanInfo{}
+			}
+			if err := m.Write.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Lock", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowKvrpcpb
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthKvrpcpb
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Lock == nil {
+				m.Lock = &ScanInfo{}
+			}
+			if err := m.Lock.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowKvrpcpb
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthKvrpcpb
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Data == nil {
+				m.Data = &ScanInfo{}
+			}
+			if err := m.Data.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipKvrpcpb(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthKvrpcpb
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *ExecDetails) 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 ErrIntOverflowKvrpcpb
+			}
+			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: ExecDetails: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: ExecDetails: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field HandleTime", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowKvrpcpb
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthKvrpcpb
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.HandleTime == nil {
+				m.HandleTime = &HandleTime{}
+			}
+			if err := m.HandleTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ScanDetail", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowKvrpcpb
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthKvrpcpb
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.ScanDetail == nil {
+				m.ScanDetail = &ScanDetail{}
+			}
+			if err := m.ScanDetail.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipKvrpcpb(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthKvrpcpb
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
 		}
 	}
-	return n
-}
-func sozKvrpcpb(x uint64) (n int) {
-	return sovKvrpcpb(uint64((x << 1) ^ uint64((int64(x) >> 63))))
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
 }
-func (m *LockInfo) Unmarshal(dAtA []byte) error {
+func (m *GetRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -4996,17 +6859,17 @@ func (m *LockInfo) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: LockInfo: wiretype end group for non-group")
+			return fmt.Errorf("proto: GetRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: LockInfo: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: GetRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field PrimaryLock", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Context", wireType)
 			}
-			var byteLen int
+			var msglen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowKvrpcpb
@@ -5016,43 +6879,26 @@ func (m *LockInfo) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				byteLen |= (int(b) & 0x7F) << shift
+				msglen |= (int(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if byteLen < 0 {
+			if msglen < 0 {
 				return ErrInvalidLengthKvrpcpb
 			}
-			postIndex := iNdEx + byteLen
+			postIndex := iNdEx + msglen
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.PrimaryLock = append(m.PrimaryLock[:0], dAtA[iNdEx:postIndex]...)
-			if m.PrimaryLock == nil {
-				m.PrimaryLock = []byte{}
+			if m.Context == nil {
+				m.Context = &Context{}
+			}
+			if err := m.Context.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
 			}
 			iNdEx = postIndex
 		case 2:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field LockVersion", wireType)
-			}
-			m.LockVersion = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowKvrpcpb
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.LockVersion |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-		case 3:
 			if wireType != 2 {
 				return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
 			}
@@ -5083,11 +6929,11 @@ func (m *LockInfo) Unmarshal(dAtA []byte) error {
 				m.Key = []byte{}
 			}
 			iNdEx = postIndex
-		case 4:
+		case 3:
 			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field LockTtl", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
 			}
-			m.LockTtl = 0
+			m.Version = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowKvrpcpb
@@ -5097,7 +6943,7 @@ func (m *LockInfo) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.LockTtl |= (uint64(b) & 0x7F) << shift
+				m.Version |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -5123,7 +6969,7 @@ func (m *LockInfo) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *KeyError) Unmarshal(dAtA []byte) error {
+func (m *GetResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -5146,15 +6992,15 @@ func (m *KeyError) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: KeyError: wiretype end group for non-group")
+			return fmt.Errorf("proto: GetResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: KeyError: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: GetResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Locked", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field RegionError", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -5178,18 +7024,18 @@ func (m *KeyError) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.Locked == nil {
-				m.Locked = &LockInfo{}
+			if m.RegionError == nil {
+				m.RegionError = &errorpb.Error{}
 			}
-			if err := m.Locked.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if err := m.RegionError.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
 		case 2:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Retryable", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
 			}
-			var stringLen uint64
+			var msglen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowKvrpcpb
@@ -5199,26 +7045,30 @@ func (m *KeyError) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= (uint64(b) & 0x7F) << shift
+				msglen |= (int(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
+			if msglen < 0 {
 				return ErrInvalidLengthKvrpcpb
 			}
-			postIndex := iNdEx + intStringLen
+			postIndex := iNdEx + msglen
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Retryable = string(dAtA[iNdEx:postIndex])
+			if m.Error == nil {
+				m.Error = &KeyError{}
+			}
+			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
 			iNdEx = postIndex
 		case 3:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Abort", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
 			}
-			var stringLen uint64
+			var byteLen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowKvrpcpb
@@ -5228,20 +7078,22 @@ func (m *KeyError) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= (uint64(b) & 0x7F) << shift
+				byteLen |= (int(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
+			if byteLen < 0 {
 				return ErrInvalidLengthKvrpcpb
 			}
-			postIndex := iNdEx + intStringLen
+			postIndex := iNdEx + byteLen
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Abort = string(dAtA[iNdEx:postIndex])
+			m.Value = append(m.Value[:0], dAtA[iNdEx:postIndex]...)
+			if m.Value == nil {
+				m.Value = []byte{}
+			}
 			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
@@ -5264,7 +7116,7 @@ func (m *KeyError) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *Context) Unmarshal(dAtA []byte) error {
+func (m *ScanRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -5287,34 +7139,15 @@ func (m *Context) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: Context: wiretype end group for non-group")
+			return fmt.Errorf("proto: ScanRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: Context: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: ScanRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field RegionId", wireType)
-			}
-			m.RegionId = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowKvrpcpb
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.RegionId |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-		case 2:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field RegionEpoch", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Context", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -5338,18 +7171,18 @@ func (m *Context) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.RegionEpoch == nil {
-				m.RegionEpoch = &metapb.RegionEpoch{}
+			if m.Context == nil {
+				m.Context = &Context{}
 			}
-			if err := m.RegionEpoch.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if err := m.Context.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
-		case 3:
+		case 2:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Peer", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field StartKey", wireType)
 			}
-			var msglen int
+			var byteLen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowKvrpcpb
@@ -5359,49 +7192,28 @@ func (m *Context) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= (int(b) & 0x7F) << shift
+				byteLen |= (int(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if msglen < 0 {
+			if byteLen < 0 {
 				return ErrInvalidLengthKvrpcpb
 			}
-			postIndex := iNdEx + msglen
+			postIndex := iNdEx + byteLen
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.Peer == nil {
-				m.Peer = &metapb.Peer{}
-			}
-			if err := m.Peer.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
+			m.StartKey = append(m.StartKey[:0], dAtA[iNdEx:postIndex]...)
+			if m.StartKey == nil {
+				m.StartKey = []byte{}
 			}
 			iNdEx = postIndex
-		case 5:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Term", wireType)
-			}
-			m.Term = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowKvrpcpb
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.Term |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-		case 6:
+		case 3:
 			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Priority", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Limit", wireType)
 			}
-			m.Priority = 0
+			m.Limit = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowKvrpcpb
@@ -5411,16 +7223,16 @@ func (m *Context) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.Priority |= (CommandPri(b) & 0x7F) << shift
+				m.Limit |= (uint32(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-		case 7:
+		case 4:
 			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field IsolationLevel", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
 			}
-			m.IsolationLevel = 0
+			m.Version = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowKvrpcpb
@@ -5430,14 +7242,14 @@ func (m *Context) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.IsolationLevel |= (IsolationLevel(b) & 0x7F) << shift
+				m.Version |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-		case 8:
+		case 5:
 			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field NotFillCache", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field KeyOnly", wireType)
 			}
 			var v int
 			for shift := uint(0); ; shift += 7 {
@@ -5454,12 +7266,62 @@ func (m *Context) Unmarshal(dAtA []byte) error {
 					break
 				}
 			}
-			m.NotFillCache = bool(v != 0)
-		case 9:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field SyncLog", wireType)
+			m.KeyOnly = bool(v != 0)
+		default:
+			iNdEx = preIndex
+			skippy, err := skipKvrpcpb(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthKvrpcpb
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *KvPair) 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 ErrIntOverflowKvrpcpb
+			}
+			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: KvPair: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: KvPair: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
 			}
-			var v int
+			var msglen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowKvrpcpb
@@ -5469,17 +7331,30 @@ func (m *Context) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				v |= (int(b) & 0x7F) << shift
+				msglen |= (int(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			m.SyncLog = bool(v != 0)
-		case 10:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field HandleTime", wireType)
+			if msglen < 0 {
+				return ErrInvalidLengthKvrpcpb
 			}
-			var v int
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Error == nil {
+				m.Error = &KeyError{}
+			}
+			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
+			}
+			var byteLen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowKvrpcpb
@@ -5489,17 +7364,28 @@ func (m *Context) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				v |= (int(b) & 0x7F) << shift
+				byteLen |= (int(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			m.HandleTime = bool(v != 0)
-		case 11:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field ScanDetail", wireType)
+			if byteLen < 0 {
+				return ErrInvalidLengthKvrpcpb
 			}
-			var v int
+			postIndex := iNdEx + byteLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...)
+			if m.Key == nil {
+				m.Key = []byte{}
+			}
+			iNdEx = postIndex
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
+			}
+			var byteLen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowKvrpcpb
@@ -5509,12 +7395,23 @@ func (m *Context) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				v |= (int(b) & 0x7F) << shift
+				byteLen |= (int(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			m.ScanDetail = bool(v != 0)
+			if byteLen < 0 {
+				return ErrInvalidLengthKvrpcpb
+			}
+			postIndex := iNdEx + byteLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Value = append(m.Value[:0], dAtA[iNdEx:postIndex]...)
+			if m.Value == nil {
+				m.Value = []byte{}
+			}
+			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipKvrpcpb(dAtA[iNdEx:])
@@ -5536,7 +7433,7 @@ func (m *Context) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *HandleTime) Unmarshal(dAtA []byte) error {
+func (m *ScanResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -5559,17 +7456,17 @@ func (m *HandleTime) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: HandleTime: wiretype end group for non-group")
+			return fmt.Errorf("proto: ScanResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: HandleTime: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: ScanResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field WaitMs", wireType)
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field RegionError", wireType)
 			}
-			m.WaitMs = 0
+			var msglen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowKvrpcpb
@@ -5579,16 +7476,30 @@ func (m *HandleTime) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.WaitMs |= (int64(b) & 0x7F) << shift
+				msglen |= (int(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
+			if msglen < 0 {
+				return ErrInvalidLengthKvrpcpb
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.RegionError == nil {
+				m.RegionError = &errorpb.Error{}
+			}
+			if err := m.RegionError.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
 		case 2:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field ProcessMs", wireType)
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Pairs", wireType)
 			}
-			m.ProcessMs = 0
+			var msglen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowKvrpcpb
@@ -5598,11 +7509,23 @@ func (m *HandleTime) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.ProcessMs |= (int64(b) & 0x7F) << shift
+				msglen |= (int(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
+			if msglen < 0 {
+				return ErrInvalidLengthKvrpcpb
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Pairs = append(m.Pairs, &KvPair{})
+			if err := m.Pairs[len(m.Pairs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipKvrpcpb(dAtA[iNdEx:])
@@ -5624,7 +7547,7 @@ func (m *HandleTime) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *ScanInfo) Unmarshal(dAtA []byte) error {
+func (m *Mutation) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -5647,17 +7570,17 @@ func (m *ScanInfo) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: ScanInfo: wiretype end group for non-group")
+			return fmt.Errorf("proto: Mutation: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: ScanInfo: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: Mutation: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Total", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Op", wireType)
 			}
-			m.Total = 0
+			m.Op = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowKvrpcpb
@@ -5667,16 +7590,16 @@ func (m *ScanInfo) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.Total |= (int64(b) & 0x7F) << shift
+				m.Op |= (Op(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
 		case 2:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Processed", wireType)
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
 			}
-			m.Processed = 0
+			var byteLen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowKvrpcpb
@@ -5686,11 +7609,54 @@ func (m *ScanInfo) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.Processed |= (int64(b) & 0x7F) << shift
+				byteLen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if byteLen < 0 {
+				return ErrInvalidLengthKvrpcpb
+			}
+			postIndex := iNdEx + byteLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...)
+			if m.Key == nil {
+				m.Key = []byte{}
+			}
+			iNdEx = postIndex
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
+			}
+			var byteLen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowKvrpcpb
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				byteLen |= (int(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
+			if byteLen < 0 {
+				return ErrInvalidLengthKvrpcpb
+			}
+			postIndex := iNdEx + byteLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Value = append(m.Value[:0], dAtA[iNdEx:postIndex]...)
+			if m.Value == nil {
+				m.Value = []byte{}
+			}
+			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipKvrpcpb(dAtA[iNdEx:])
@@ -5712,7 +7678,7 @@ func (m *ScanInfo) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *ScanDetail) Unmarshal(dAtA []byte) error {
+func (m *PrewriteRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -5735,15 +7701,15 @@ func (m *ScanDetail) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: ScanDetail: wiretype end group for non-group")
+			return fmt.Errorf("proto: PrewriteRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: ScanDetail: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: PrewriteRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Write", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Context", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -5767,16 +7733,16 @@ func (m *ScanDetail) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.Write == nil {
-				m.Write = &ScanInfo{}
+			if m.Context == nil {
+				m.Context = &Context{}
 			}
-			if err := m.Write.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if err := m.Context.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
 		case 2:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Lock", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Mutations", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -5800,18 +7766,66 @@ func (m *ScanDetail) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.Lock == nil {
-				m.Lock = &ScanInfo{}
-			}
-			if err := m.Lock.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			m.Mutations = append(m.Mutations, &Mutation{})
+			if err := m.Mutations[len(m.Mutations)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
 		case 3:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field PrimaryLock", wireType)
+			}
+			var byteLen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowKvrpcpb
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				byteLen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if byteLen < 0 {
+				return ErrInvalidLengthKvrpcpb
+			}
+			postIndex := iNdEx + byteLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.PrimaryLock = append(m.PrimaryLock[:0], dAtA[iNdEx:postIndex]...)
+			if m.PrimaryLock == nil {
+				m.PrimaryLock = []byte{}
+			}
+			iNdEx = postIndex
+		case 4:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field StartVersion", wireType)
+			}
+			m.StartVersion = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowKvrpcpb
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.StartVersion |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 5:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field LockTtl", wireType)
 			}
-			var msglen int
+			m.LockTtl = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowKvrpcpb
@@ -5821,25 +7835,31 @@ func (m *ScanDetail) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= (int(b) & 0x7F) << shift
+				m.LockTtl |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if msglen < 0 {
-				return ErrInvalidLengthKvrpcpb
-			}
-			postIndex := iNdEx + msglen
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			if m.Data == nil {
-				m.Data = &ScanInfo{}
+		case 6:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field SkipConstraintCheck", wireType)
 			}
-			if err := m.Data.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
+			var v int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowKvrpcpb
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				v |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
 			}
-			iNdEx = postIndex
+			m.SkipConstraintCheck = bool(v != 0)
 		default:
 			iNdEx = preIndex
 			skippy, err := skipKvrpcpb(dAtA[iNdEx:])
@@ -5861,7 +7881,7 @@ func (m *ScanDetail) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *ExecDetails) Unmarshal(dAtA []byte) error {
+func (m *PrewriteResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -5884,15 +7904,15 @@ func (m *ExecDetails) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: ExecDetails: wiretype end group for non-group")
+			return fmt.Errorf("proto: PrewriteResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: ExecDetails: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: PrewriteResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field HandleTime", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field RegionError", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -5916,16 +7936,16 @@ func (m *ExecDetails) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.HandleTime == nil {
-				m.HandleTime = &HandleTime{}
+			if m.RegionError == nil {
+				m.RegionError = &errorpb.Error{}
 			}
-			if err := m.HandleTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if err := m.RegionError.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
 		case 2:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field ScanDetail", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Errors", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -5949,10 +7969,8 @@ func (m *ExecDetails) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.ScanDetail == nil {
-				m.ScanDetail = &ScanDetail{}
-			}
-			if err := m.ScanDetail.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			m.Errors = append(m.Errors, &KeyError{})
+			if err := m.Errors[len(m.Errors)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
@@ -5977,7 +7995,7 @@ func (m *ExecDetails) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *GetRequest) Unmarshal(dAtA []byte) error {
+func (m *CommitRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -6000,10 +8018,10 @@ func (m *GetRequest) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: GetRequest: wiretype end group for non-group")
+			return fmt.Errorf("proto: CommitRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: GetRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: CommitRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
@@ -6040,8 +8058,27 @@ func (m *GetRequest) Unmarshal(dAtA []byte) error {
 			}
 			iNdEx = postIndex
 		case 2:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field StartVersion", wireType)
+			}
+			m.StartVersion = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowKvrpcpb
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.StartVersion |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 3:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Keys", wireType)
 			}
 			var byteLen int
 			for shift := uint(0); ; shift += 7 {
@@ -6065,16 +8102,14 @@ func (m *GetRequest) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...)
-			if m.Key == nil {
-				m.Key = []byte{}
-			}
+			m.Keys = append(m.Keys, make([]byte, postIndex-iNdEx))
+			copy(m.Keys[len(m.Keys)-1], dAtA[iNdEx:postIndex])
 			iNdEx = postIndex
-		case 3:
+		case 4:
 			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field CommitVersion", wireType)
 			}
-			m.Version = 0
+			m.CommitVersion = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowKvrpcpb
@@ -6084,7 +8119,7 @@ func (m *GetRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.Version |= (uint64(b) & 0x7F) << shift
+				m.CommitVersion |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -6110,7 +8145,7 @@ func (m *GetRequest) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *GetResponse) Unmarshal(dAtA []byte) error {
+func (m *CommitResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -6133,10 +8168,10 @@ func (m *GetResponse) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: GetResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: CommitResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: GetResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: CommitResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
@@ -6205,37 +8240,6 @@ func (m *GetResponse) Unmarshal(dAtA []byte) error {
 				return err
 			}
 			iNdEx = postIndex
-		case 3:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
-			}
-			var byteLen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowKvrpcpb
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				byteLen |= (int(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if byteLen < 0 {
-				return ErrInvalidLengthKvrpcpb
-			}
-			postIndex := iNdEx + byteLen
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.Value = append(m.Value[:0], dAtA[iNdEx:postIndex]...)
-			if m.Value == nil {
-				m.Value = []byte{}
-			}
-			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipKvrpcpb(dAtA[iNdEx:])
@@ -6257,7 +8261,7 @@ func (m *GetResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *ScanRequest) Unmarshal(dAtA []byte) error {
+func (m *ImportRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -6280,15 +8284,15 @@ func (m *ScanRequest) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: ScanRequest: wiretype end group for non-group")
+			return fmt.Errorf("proto: ImportRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: ScanRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: ImportRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Context", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Mutations", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -6312,18 +8316,16 @@ func (m *ScanRequest) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.Context == nil {
-				m.Context = &Context{}
-			}
-			if err := m.Context.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			m.Mutations = append(m.Mutations, &Mutation{})
+			if err := m.Mutations[len(m.Mutations)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
 		case 2:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field StartKey", wireType)
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field CommitVersion", wireType)
 			}
-			var byteLen int
+			m.CommitVersion = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowKvrpcpb
@@ -6333,47 +8335,66 @@ func (m *ScanRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				byteLen |= (int(b) & 0x7F) << shift
+				m.CommitVersion |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if byteLen < 0 {
+		default:
+			iNdEx = preIndex
+			skippy, err := skipKvrpcpb(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
 				return ErrInvalidLengthKvrpcpb
 			}
-			postIndex := iNdEx + byteLen
-			if postIndex > l {
+			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.StartKey = append(m.StartKey[:0], dAtA[iNdEx:postIndex]...)
-			if m.StartKey == nil {
-				m.StartKey = []byte{}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *ImportResponse) 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 ErrIntOverflowKvrpcpb
 			}
-			iNdEx = postIndex
-		case 3:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Limit", wireType)
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
 			}
-			m.Limit = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowKvrpcpb
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.Limit |= (uint32(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
 			}
-		case 4:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: ImportResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: ImportResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field RegionError", wireType)
 			}
-			m.Version = 0
+			var msglen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowKvrpcpb
@@ -6383,16 +8404,30 @@ func (m *ScanRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.Version |= (uint64(b) & 0x7F) << shift
+				msglen |= (int(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-		case 5:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field KeyOnly", wireType)
+			if msglen < 0 {
+				return ErrInvalidLengthKvrpcpb
 			}
-			var v int
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.RegionError == nil {
+				m.RegionError = &errorpb.Error{}
+			}
+			if err := m.RegionError.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
+			}
+			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowKvrpcpb
@@ -6402,12 +8437,21 @@ func (m *ScanRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				v |= (int(b) & 0x7F) << shift
+				stringLen |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			m.KeyOnly = bool(v != 0)
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthKvrpcpb
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Error = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipKvrpcpb(dAtA[iNdEx:])
@@ -6429,7 +8473,7 @@ func (m *ScanRequest) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *KvPair) Unmarshal(dAtA []byte) error {
+func (m *BatchRollbackRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -6452,15 +8496,15 @@ func (m *KvPair) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: KvPair: wiretype end group for non-group")
+			return fmt.Errorf("proto: BatchRollbackRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: KvPair: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: BatchRollbackRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Context", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -6484,18 +8528,18 @@ func (m *KvPair) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.Error == nil {
-				m.Error = &KeyError{}
+			if m.Context == nil {
+				m.Context = &Context{}
 			}
-			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if err := m.Context.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
 		case 2:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field StartVersion", wireType)
 			}
-			var byteLen int
+			m.StartVersion = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowKvrpcpb
@@ -6505,26 +8549,14 @@ func (m *KvPair) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				byteLen |= (int(b) & 0x7F) << shift
+				m.StartVersion |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if byteLen < 0 {
-				return ErrInvalidLengthKvrpcpb
-			}
-			postIndex := iNdEx + byteLen
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...)
-			if m.Key == nil {
-				m.Key = []byte{}
-			}
-			iNdEx = postIndex
 		case 3:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Keys", wireType)
 			}
 			var byteLen int
 			for shift := uint(0); ; shift += 7 {
@@ -6548,10 +8580,8 @@ func (m *KvPair) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Value = append(m.Value[:0], dAtA[iNdEx:postIndex]...)
-			if m.Value == nil {
-				m.Value = []byte{}
-			}
+			m.Keys = append(m.Keys, make([]byte, postIndex-iNdEx))
+			copy(m.Keys[len(m.Keys)-1], dAtA[iNdEx:postIndex])
 			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
@@ -6574,7 +8604,7 @@ func (m *KvPair) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *ScanResponse) Unmarshal(dAtA []byte) error {
+func (m *BatchRollbackResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -6597,10 +8627,10 @@ func (m *ScanResponse) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: ScanResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: BatchRollbackResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: ScanResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: BatchRollbackResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
@@ -6638,7 +8668,7 @@ func (m *ScanResponse) Unmarshal(dAtA []byte) error {
 			iNdEx = postIndex
 		case 2:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Pairs", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -6662,8 +8692,10 @@ func (m *ScanResponse) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Pairs = append(m.Pairs, &KvPair{})
-			if err := m.Pairs[len(m.Pairs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if m.Error == nil {
+				m.Error = &KeyError{}
+			}
+			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
@@ -6688,7 +8720,7 @@ func (m *ScanResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *Mutation) Unmarshal(dAtA []byte) error {
+func (m *CleanupRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -6711,17 +8743,17 @@ func (m *Mutation) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: Mutation: wiretype end group for non-group")
+			return fmt.Errorf("proto: CleanupRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: Mutation: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: CleanupRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Op", wireType)
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Context", wireType)
 			}
-			m.Op = 0
+			var msglen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowKvrpcpb
@@ -6731,11 +8763,25 @@ func (m *Mutation) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.Op |= (Op(b) & 0x7F) << shift
+				msglen |= (int(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
+			if msglen < 0 {
+				return ErrInvalidLengthKvrpcpb
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Context == nil {
+				m.Context = &Context{}
+			}
+			if err := m.Context.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
 		case 2:
 			if wireType != 2 {
 				return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
@@ -6768,10 +8814,10 @@ func (m *Mutation) Unmarshal(dAtA []byte) error {
 			}
 			iNdEx = postIndex
 		case 3:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field StartVersion", wireType)
 			}
-			var byteLen int
+			m.StartVersion = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowKvrpcpb
@@ -6781,23 +8827,11 @@ func (m *Mutation) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				byteLen |= (int(b) & 0x7F) << shift
+				m.StartVersion |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if byteLen < 0 {
-				return ErrInvalidLengthKvrpcpb
-			}
-			postIndex := iNdEx + byteLen
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.Value = append(m.Value[:0], dAtA[iNdEx:postIndex]...)
-			if m.Value == nil {
-				m.Value = []byte{}
-			}
-			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipKvrpcpb(dAtA[iNdEx:])
@@ -6819,7 +8853,7 @@ func (m *Mutation) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *PrewriteRequest) Unmarshal(dAtA []byte) error {
+func (m *CleanupResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -6842,15 +8876,15 @@ func (m *PrewriteRequest) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: PrewriteRequest: wiretype end group for non-group")
+			return fmt.Errorf("proto: CleanupResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: PrewriteRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: CleanupResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Context", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field RegionError", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -6874,16 +8908,16 @@ func (m *PrewriteRequest) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.Context == nil {
-				m.Context = &Context{}
+			if m.RegionError == nil {
+				m.RegionError = &errorpb.Error{}
 			}
-			if err := m.Context.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if err := m.RegionError.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
 		case 2:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Mutations", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -6907,16 +8941,18 @@ func (m *PrewriteRequest) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Mutations = append(m.Mutations, &Mutation{})
-			if err := m.Mutations[len(m.Mutations)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if m.Error == nil {
+				m.Error = &KeyError{}
+			}
+			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
 		case 3:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field PrimaryLock", wireType)
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field CommitVersion", wireType)
 			}
-			var byteLen int
+			m.CommitVersion = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowKvrpcpb
@@ -6926,28 +8962,66 @@ func (m *PrewriteRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				byteLen |= (int(b) & 0x7F) << shift
+				m.CommitVersion |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if byteLen < 0 {
+		default:
+			iNdEx = preIndex
+			skippy, err := skipKvrpcpb(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
 				return ErrInvalidLengthKvrpcpb
 			}
-			postIndex := iNdEx + byteLen
-			if postIndex > l {
+			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.PrimaryLock = append(m.PrimaryLock[:0], dAtA[iNdEx:postIndex]...)
-			if m.PrimaryLock == nil {
-				m.PrimaryLock = []byte{}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *BatchGetRequest) 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 ErrIntOverflowKvrpcpb
 			}
-			iNdEx = postIndex
-		case 4:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field StartVersion", wireType)
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
 			}
-			m.StartVersion = 0
+			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: BatchGetRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: BatchGetRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Context", wireType)
+			}
+			var msglen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowKvrpcpb
@@ -6957,16 +9031,30 @@ func (m *PrewriteRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.StartVersion |= (uint64(b) & 0x7F) << shift
+				msglen |= (int(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-		case 5:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field LockTtl", wireType)
+			if msglen < 0 {
+				return ErrInvalidLengthKvrpcpb
 			}
-			m.LockTtl = 0
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Context == nil {
+				m.Context = &Context{}
+			}
+			if err := m.Context.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Keys", wireType)
+			}
+			var byteLen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowKvrpcpb
@@ -6976,16 +9064,26 @@ func (m *PrewriteRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.LockTtl |= (uint64(b) & 0x7F) << shift
+				byteLen |= (int(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-		case 6:
+			if byteLen < 0 {
+				return ErrInvalidLengthKvrpcpb
+			}
+			postIndex := iNdEx + byteLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Keys = append(m.Keys, make([]byte, postIndex-iNdEx))
+			copy(m.Keys[len(m.Keys)-1], dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 3:
 			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field SkipConstraintCheck", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
 			}
-			var v int
+			m.Version = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowKvrpcpb
@@ -6995,12 +9093,11 @@ func (m *PrewriteRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				v |= (int(b) & 0x7F) << shift
+				m.Version |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			m.SkipConstraintCheck = bool(v != 0)
 		default:
 			iNdEx = preIndex
 			skippy, err := skipKvrpcpb(dAtA[iNdEx:])
@@ -7022,7 +9119,7 @@ func (m *PrewriteRequest) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *PrewriteResponse) Unmarshal(dAtA []byte) error {
+func (m *BatchGetResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -7045,10 +9142,10 @@ func (m *PrewriteResponse) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: PrewriteResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: BatchGetResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: PrewriteResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: BatchGetResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
@@ -7086,7 +9183,7 @@ func (m *PrewriteResponse) Unmarshal(dAtA []byte) error {
 			iNdEx = postIndex
 		case 2:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Errors", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Pairs", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -7110,8 +9207,8 @@ func (m *PrewriteResponse) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Errors = append(m.Errors, &KeyError{})
-			if err := m.Errors[len(m.Errors)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			m.Pairs = append(m.Pairs, &KvPair{})
+			if err := m.Pairs[len(m.Pairs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
@@ -7136,7 +9233,7 @@ func (m *PrewriteResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *CommitRequest) Unmarshal(dAtA []byte) error {
+func (m *ScanLockRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -7159,10 +9256,10 @@ func (m *CommitRequest) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: CommitRequest: wiretype end group for non-group")
+			return fmt.Errorf("proto: ScanLockRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: CommitRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: ScanLockRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
@@ -7200,9 +9297,9 @@ func (m *CommitRequest) Unmarshal(dAtA []byte) error {
 			iNdEx = postIndex
 		case 2:
 			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field StartVersion", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field MaxVersion", wireType)
 			}
-			m.StartVersion = 0
+			m.MaxVersion = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowKvrpcpb
@@ -7212,14 +9309,14 @@ func (m *CommitRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.StartVersion |= (uint64(b) & 0x7F) << shift
+				m.MaxVersion |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
 		case 3:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Keys", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field StartKey", wireType)
 			}
 			var byteLen int
 			for shift := uint(0); ; shift += 7 {
@@ -7243,14 +9340,16 @@ func (m *CommitRequest) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Keys = append(m.Keys, make([]byte, postIndex-iNdEx))
-			copy(m.Keys[len(m.Keys)-1], dAtA[iNdEx:postIndex])
+			m.StartKey = append(m.StartKey[:0], dAtA[iNdEx:postIndex]...)
+			if m.StartKey == nil {
+				m.StartKey = []byte{}
+			}
 			iNdEx = postIndex
 		case 4:
 			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field CommitVersion", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Limit", wireType)
 			}
-			m.CommitVersion = 0
+			m.Limit = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowKvrpcpb
@@ -7260,7 +9359,7 @@ func (m *CommitRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.CommitVersion |= (uint64(b) & 0x7F) << shift
+				m.Limit |= (uint32(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -7286,7 +9385,7 @@ func (m *CommitRequest) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *CommitResponse) Unmarshal(dAtA []byte) error {
+func (m *ScanLockResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -7309,10 +9408,10 @@ func (m *CommitResponse) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: CommitResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: ScanLockResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: CommitResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: ScanLockResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
@@ -7381,59 +9480,9 @@ func (m *CommitResponse) Unmarshal(dAtA []byte) error {
 				return err
 			}
 			iNdEx = postIndex
-		default:
-			iNdEx = preIndex
-			skippy, err := skipKvrpcpb(dAtA[iNdEx:])
-			if err != nil {
-				return err
-			}
-			if skippy < 0 {
-				return ErrInvalidLengthKvrpcpb
-			}
-			if (iNdEx + skippy) > l {
-				return io.ErrUnexpectedEOF
-			}
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
-func (m *ImportRequest) 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 ErrIntOverflowKvrpcpb
-			}
-			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: ImportRequest: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: ImportRequest: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
+		case 3:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Mutations", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Locks", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -7457,30 +9506,11 @@ func (m *ImportRequest) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Mutations = append(m.Mutations, &Mutation{})
-			if err := m.Mutations[len(m.Mutations)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			m.Locks = append(m.Locks, &LockInfo{})
+			if err := m.Locks[len(m.Locks)-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 CommitVersion", wireType)
-			}
-			m.CommitVersion = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowKvrpcpb
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.CommitVersion |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
 		default:
 			iNdEx = preIndex
 			skippy, err := skipKvrpcpb(dAtA[iNdEx:])
@@ -7502,7 +9532,7 @@ func (m *ImportRequest) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *ImportResponse) Unmarshal(dAtA []byte) error {
+func (m *TxnInfo) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -7525,17 +9555,17 @@ func (m *ImportResponse) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: ImportResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: TxnInfo: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: ImportResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: TxnInfo: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field RegionError", wireType)
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Txn", wireType)
 			}
-			var msglen int
+			m.Txn = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowKvrpcpb
@@ -7545,30 +9575,16 @@ func (m *ImportResponse) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= (int(b) & 0x7F) << shift
+				m.Txn |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if msglen < 0 {
-				return ErrInvalidLengthKvrpcpb
-			}
-			postIndex := iNdEx + msglen
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			if m.RegionError == nil {
-				m.RegionError = &errorpb.Error{}
-			}
-			if err := m.RegionError.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
 		case 2:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
 			}
-			var stringLen uint64
+			m.Status = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowKvrpcpb
@@ -7578,21 +9594,11 @@ func (m *ImportResponse) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= (uint64(b) & 0x7F) << shift
+				m.Status |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
-				return ErrInvalidLengthKvrpcpb
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.Error = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipKvrpcpb(dAtA[iNdEx:])
@@ -7614,7 +9620,7 @@ func (m *ImportResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *BatchRollbackRequest) Unmarshal(dAtA []byte) error {
+func (m *ResolveLockRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -7637,10 +9643,10 @@ func (m *BatchRollbackRequest) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: BatchRollbackRequest: wiretype end group for non-group")
+			return fmt.Errorf("proto: ResolveLockRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: BatchRollbackRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: ResolveLockRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
@@ -7696,89 +9702,10 @@ func (m *BatchRollbackRequest) Unmarshal(dAtA []byte) error {
 				}
 			}
 		case 3:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Keys", wireType)
-			}
-			var byteLen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowKvrpcpb
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				byteLen |= (int(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if byteLen < 0 {
-				return ErrInvalidLengthKvrpcpb
-			}
-			postIndex := iNdEx + byteLen
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.Keys = append(m.Keys, make([]byte, postIndex-iNdEx))
-			copy(m.Keys[len(m.Keys)-1], dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		default:
-			iNdEx = preIndex
-			skippy, err := skipKvrpcpb(dAtA[iNdEx:])
-			if err != nil {
-				return err
-			}
-			if skippy < 0 {
-				return ErrInvalidLengthKvrpcpb
-			}
-			if (iNdEx + skippy) > l {
-				return io.ErrUnexpectedEOF
-			}
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
-func (m *BatchRollbackResponse) 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 ErrIntOverflowKvrpcpb
-			}
-			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: BatchRollbackResponse: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: BatchRollbackResponse: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field RegionError", wireType)
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field CommitVersion", wireType)
 			}
-			var msglen int
+			m.CommitVersion = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowKvrpcpb
@@ -7788,28 +9715,14 @@ func (m *BatchRollbackResponse) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= (int(b) & 0x7F) << shift
+				m.CommitVersion |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if msglen < 0 {
-				return ErrInvalidLengthKvrpcpb
-			}
-			postIndex := iNdEx + msglen
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			if m.RegionError == nil {
-				m.RegionError = &errorpb.Error{}
-			}
-			if err := m.RegionError.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
-		case 2:
+		case 4:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field TxnInfos", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -7833,10 +9746,8 @@ func (m *BatchRollbackResponse) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.Error == nil {
-				m.Error = &KeyError{}
-			}
-			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			m.TxnInfos = append(m.TxnInfos, &TxnInfo{})
+			if err := m.TxnInfos[len(m.TxnInfos)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
@@ -7861,7 +9772,7 @@ func (m *BatchRollbackResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *CleanupRequest) Unmarshal(dAtA []byte) error {
+func (m *ResolveLockResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -7884,15 +9795,15 @@ func (m *CleanupRequest) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: CleanupRequest: wiretype end group for non-group")
+			return fmt.Errorf("proto: ResolveLockResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: CleanupRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: ResolveLockResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Context", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field RegionError", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -7916,18 +9827,18 @@ func (m *CleanupRequest) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.Context == nil {
-				m.Context = &Context{}
+			if m.RegionError == nil {
+				m.RegionError = &errorpb.Error{}
 			}
-			if err := m.Context.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if err := m.RegionError.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
 		case 2:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
 			}
-			var byteLen int
+			var msglen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowKvrpcpb
@@ -7937,42 +9848,25 @@ func (m *CleanupRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				byteLen |= (int(b) & 0x7F) << shift
+				msglen |= (int(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if byteLen < 0 {
+			if msglen < 0 {
 				return ErrInvalidLengthKvrpcpb
 			}
-			postIndex := iNdEx + byteLen
+			postIndex := iNdEx + msglen
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...)
-			if m.Key == nil {
-				m.Key = []byte{}
-			}
-			iNdEx = postIndex
-		case 3:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field StartVersion", wireType)
+			if m.Error == nil {
+				m.Error = &KeyError{}
 			}
-			m.StartVersion = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowKvrpcpb
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.StartVersion |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
+			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
 			}
+			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipKvrpcpb(dAtA[iNdEx:])
@@ -7994,7 +9888,7 @@ func (m *CleanupRequest) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *CleanupResponse) Unmarshal(dAtA []byte) error {
+func (m *GCRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -8017,15 +9911,15 @@ func (m *CleanupResponse) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: CleanupResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: GCRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: CleanupResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: GCRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field RegionError", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Context", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -8049,51 +9943,18 @@ func (m *CleanupResponse) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.RegionError == nil {
-				m.RegionError = &errorpb.Error{}
+			if m.Context == nil {
+				m.Context = &Context{}
 			}
-			if err := m.RegionError.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if err := m.Context.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
 		case 2:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
-			}
-			var msglen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowKvrpcpb
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				msglen |= (int(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if msglen < 0 {
-				return ErrInvalidLengthKvrpcpb
-			}
-			postIndex := iNdEx + msglen
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			if m.Error == nil {
-				m.Error = &KeyError{}
-			}
-			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
-		case 3:
 			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field CommitVersion", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field SafePoint", wireType)
 			}
-			m.CommitVersion = 0
+			m.SafePoint = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowKvrpcpb
@@ -8103,7 +9964,7 @@ func (m *CleanupResponse) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.CommitVersion |= (uint64(b) & 0x7F) << shift
+				m.SafePoint |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -8129,7 +9990,7 @@ func (m *CleanupResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *BatchGetRequest) Unmarshal(dAtA []byte) error {
+func (m *GCResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -8152,15 +10013,15 @@ func (m *BatchGetRequest) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: BatchGetRequest: wiretype end group for non-group")
+			return fmt.Errorf("proto: GCResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: BatchGetRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: GCResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Context", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field RegionError", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -8184,18 +10045,18 @@ func (m *BatchGetRequest) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.Context == nil {
-				m.Context = &Context{}
+			if m.RegionError == nil {
+				m.RegionError = &errorpb.Error{}
 			}
-			if err := m.Context.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if err := m.RegionError.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
 		case 2:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Keys", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
 			}
-			var byteLen int
+			var msglen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowKvrpcpb
@@ -8205,40 +10066,25 @@ func (m *BatchGetRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				byteLen |= (int(b) & 0x7F) << shift
+				msglen |= (int(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if byteLen < 0 {
+			if msglen < 0 {
 				return ErrInvalidLengthKvrpcpb
 			}
-			postIndex := iNdEx + byteLen
+			postIndex := iNdEx + msglen
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Keys = append(m.Keys, make([]byte, postIndex-iNdEx))
-			copy(m.Keys[len(m.Keys)-1], dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		case 3:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
+			if m.Error == nil {
+				m.Error = &KeyError{}
 			}
-			m.Version = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowKvrpcpb
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.Version |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
+			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
 			}
+			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipKvrpcpb(dAtA[iNdEx:])
@@ -8260,7 +10106,7 @@ func (m *BatchGetRequest) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *BatchGetResponse) Unmarshal(dAtA []byte) error {
+func (m *RawGetRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -8283,15 +10129,15 @@ func (m *BatchGetResponse) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: BatchGetResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: RawGetRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: BatchGetResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: RawGetRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field RegionError", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Context", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -8315,18 +10161,18 @@ func (m *BatchGetResponse) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.RegionError == nil {
-				m.RegionError = &errorpb.Error{}
+			if m.Context == nil {
+				m.Context = &Context{}
 			}
-			if err := m.RegionError.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if err := m.Context.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
 		case 2:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Pairs", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
 			}
-			var msglen int
+			var byteLen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowKvrpcpb
@@ -8336,21 +10182,21 @@ func (m *BatchGetResponse) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= (int(b) & 0x7F) << shift
+				byteLen |= (int(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if msglen < 0 {
+			if byteLen < 0 {
 				return ErrInvalidLengthKvrpcpb
 			}
-			postIndex := iNdEx + msglen
+			postIndex := iNdEx + byteLen
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Pairs = append(m.Pairs, &KvPair{})
-			if err := m.Pairs[len(m.Pairs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
+			m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...)
+			if m.Key == nil {
+				m.Key = []byte{}
 			}
 			iNdEx = postIndex
 		default:
@@ -8374,7 +10220,7 @@ func (m *BatchGetResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *ScanLockRequest) Unmarshal(dAtA []byte) error {
+func (m *RawGetResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -8397,15 +10243,15 @@ func (m *ScanLockRequest) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: ScanLockRequest: wiretype end group for non-group")
+			return fmt.Errorf("proto: RawGetResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: ScanLockRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: RawGetResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Context", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field RegionError", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -8429,37 +10275,18 @@ func (m *ScanLockRequest) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.Context == nil {
-				m.Context = &Context{}
+			if m.RegionError == nil {
+				m.RegionError = &errorpb.Error{}
 			}
-			if err := m.Context.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if err := m.RegionError.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
 		case 2:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field MaxVersion", wireType)
-			}
-			m.MaxVersion = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowKvrpcpb
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.MaxVersion |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-		case 3:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field StartKey", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
 			}
-			var byteLen int
+			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowKvrpcpb
@@ -8469,28 +10296,26 @@ func (m *ScanLockRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				byteLen |= (int(b) & 0x7F) << shift
+				stringLen |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if byteLen < 0 {
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
 				return ErrInvalidLengthKvrpcpb
 			}
-			postIndex := iNdEx + byteLen
+			postIndex := iNdEx + intStringLen
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.StartKey = append(m.StartKey[:0], dAtA[iNdEx:postIndex]...)
-			if m.StartKey == nil {
-				m.StartKey = []byte{}
-			}
+			m.Error = string(dAtA[iNdEx:postIndex])
 			iNdEx = postIndex
-		case 4:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Limit", wireType)
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
 			}
-			m.Limit = 0
+			var byteLen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowKvrpcpb
@@ -8500,11 +10325,23 @@ func (m *ScanLockRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.Limit |= (uint32(b) & 0x7F) << shift
+				byteLen |= (int(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
+			if byteLen < 0 {
+				return ErrInvalidLengthKvrpcpb
+			}
+			postIndex := iNdEx + byteLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Value = append(m.Value[:0], dAtA[iNdEx:postIndex]...)
+			if m.Value == nil {
+				m.Value = []byte{}
+			}
+			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipKvrpcpb(dAtA[iNdEx:])
@@ -8526,7 +10363,7 @@ func (m *ScanLockRequest) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *ScanLockResponse) Unmarshal(dAtA []byte) error {
+func (m *RawPutRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -8549,15 +10386,15 @@ func (m *ScanLockResponse) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: ScanLockResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: RawPutRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: ScanLockResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: RawPutRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field RegionError", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Context", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -8581,18 +10418,18 @@ func (m *ScanLockResponse) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.RegionError == nil {
-				m.RegionError = &errorpb.Error{}
+			if m.Context == nil {
+				m.Context = &Context{}
 			}
-			if err := m.RegionError.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if err := m.Context.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
 		case 2:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
 			}
-			var msglen int
+			var byteLen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowKvrpcpb
@@ -8602,30 +10439,28 @@ func (m *ScanLockResponse) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= (int(b) & 0x7F) << shift
+				byteLen |= (int(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if msglen < 0 {
+			if byteLen < 0 {
 				return ErrInvalidLengthKvrpcpb
 			}
-			postIndex := iNdEx + msglen
+			postIndex := iNdEx + byteLen
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.Error == nil {
-				m.Error = &KeyError{}
-			}
-			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
+			m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...)
+			if m.Key == nil {
+				m.Key = []byte{}
 			}
 			iNdEx = postIndex
 		case 3:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Locks", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
 			}
-			var msglen int
+			var byteLen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowKvrpcpb
@@ -8635,21 +10470,21 @@ func (m *ScanLockResponse) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= (int(b) & 0x7F) << shift
+				byteLen |= (int(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if msglen < 0 {
+			if byteLen < 0 {
 				return ErrInvalidLengthKvrpcpb
 			}
-			postIndex := iNdEx + msglen
+			postIndex := iNdEx + byteLen
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Locks = append(m.Locks, &LockInfo{})
-			if err := m.Locks[len(m.Locks)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
+			m.Value = append(m.Value[:0], dAtA[iNdEx:postIndex]...)
+			if m.Value == nil {
+				m.Value = []byte{}
 			}
 			iNdEx = postIndex
 		default:
@@ -8673,7 +10508,7 @@ func (m *ScanLockResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *TxnInfo) Unmarshal(dAtA []byte) error {
+func (m *RawPutResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -8696,17 +10531,17 @@ func (m *TxnInfo) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: TxnInfo: wiretype end group for non-group")
+			return fmt.Errorf("proto: RawPutResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: TxnInfo: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: RawPutResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Txn", wireType)
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field RegionError", wireType)
 			}
-			m.Txn = 0
+			var msglen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowKvrpcpb
@@ -8716,16 +10551,30 @@ func (m *TxnInfo) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.Txn |= (uint64(b) & 0x7F) << shift
+				msglen |= (int(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
+			if msglen < 0 {
+				return ErrInvalidLengthKvrpcpb
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.RegionError == nil {
+				m.RegionError = &errorpb.Error{}
+			}
+			if err := m.RegionError.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
 		case 2:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
 			}
-			m.Status = 0
+			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowKvrpcpb
@@ -8735,11 +10584,21 @@ func (m *TxnInfo) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.Status |= (uint64(b) & 0x7F) << shift
+				stringLen |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthKvrpcpb
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Error = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipKvrpcpb(dAtA[iNdEx:])
@@ -8761,7 +10620,7 @@ func (m *TxnInfo) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *ResolveLockRequest) Unmarshal(dAtA []byte) error {
+func (m *RawBatchPutRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -8784,10 +10643,10 @@ func (m *ResolveLockRequest) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: ResolveLockRequest: wiretype end group for non-group")
+			return fmt.Errorf("proto: RawBatchPutRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: ResolveLockRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: RawBatchPutRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
@@ -8824,46 +10683,8 @@ func (m *ResolveLockRequest) Unmarshal(dAtA []byte) error {
 			}
 			iNdEx = postIndex
 		case 2:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field StartVersion", wireType)
-			}
-			m.StartVersion = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowKvrpcpb
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.StartVersion |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-		case 3:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field CommitVersion", wireType)
-			}
-			m.CommitVersion = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowKvrpcpb
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.CommitVersion |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-		case 4:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field TxnInfos", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Pairs", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -8887,8 +10708,8 @@ func (m *ResolveLockRequest) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.TxnInfos = append(m.TxnInfos, &TxnInfo{})
-			if err := m.TxnInfos[len(m.TxnInfos)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			m.Pairs = append(m.Pairs, &KvPair{})
+			if err := m.Pairs[len(m.Pairs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
@@ -8913,7 +10734,7 @@ func (m *ResolveLockRequest) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *ResolveLockResponse) Unmarshal(dAtA []byte) error {
+func (m *RawBatchPutResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -8936,10 +10757,10 @@ func (m *ResolveLockResponse) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: ResolveLockResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: RawBatchPutResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: ResolveLockResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: RawBatchPutResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
@@ -8979,7 +10800,7 @@ func (m *ResolveLockResponse) Unmarshal(dAtA []byte) error {
 			if wireType != 2 {
 				return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
 			}
-			var msglen int
+			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowKvrpcpb
@@ -8989,24 +10810,20 @@ func (m *ResolveLockResponse) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= (int(b) & 0x7F) << shift
+				stringLen |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if msglen < 0 {
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
 				return ErrInvalidLengthKvrpcpb
 			}
-			postIndex := iNdEx + msglen
+			postIndex := iNdEx + intStringLen
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.Error == nil {
-				m.Error = &KeyError{}
-			}
-			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
+			m.Error = string(dAtA[iNdEx:postIndex])
 			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
@@ -9029,7 +10846,7 @@ func (m *ResolveLockResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *GCRequest) Unmarshal(dAtA []byte) error {
+func (m *RawBatchGetRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -9052,10 +10869,10 @@ func (m *GCRequest) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: GCRequest: wiretype end group for non-group")
+			return fmt.Errorf("proto: RawBatchGetRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: GCRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: RawBatchGetRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
@@ -9092,10 +10909,10 @@ func (m *GCRequest) Unmarshal(dAtA []byte) error {
 			}
 			iNdEx = postIndex
 		case 2:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field SafePoint", wireType)
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Keys", wireType)
 			}
-			m.SafePoint = 0
+			var byteLen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowKvrpcpb
@@ -9105,11 +10922,21 @@ func (m *GCRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.SafePoint |= (uint64(b) & 0x7F) << shift
+				byteLen |= (int(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
+			if byteLen < 0 {
+				return ErrInvalidLengthKvrpcpb
+			}
+			postIndex := iNdEx + byteLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Keys = append(m.Keys, make([]byte, postIndex-iNdEx))
+			copy(m.Keys[len(m.Keys)-1], dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipKvrpcpb(dAtA[iNdEx:])
@@ -9131,7 +10958,7 @@ func (m *GCRequest) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *GCResponse) Unmarshal(dAtA []byte) error {
+func (m *RawBatchGetResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -9154,10 +10981,10 @@ func (m *GCResponse) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: GCResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: RawBatchGetResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: GCResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: RawBatchGetResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
@@ -9195,7 +11022,7 @@ func (m *GCResponse) Unmarshal(dAtA []byte) error {
 			iNdEx = postIndex
 		case 2:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Pairs", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -9219,10 +11046,8 @@ func (m *GCResponse) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.Error == nil {
-				m.Error = &KeyError{}
-			}
-			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			m.Pairs = append(m.Pairs, &KvPair{})
+			if err := m.Pairs[len(m.Pairs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
@@ -9247,7 +11072,7 @@ func (m *GCResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *RawGetRequest) Unmarshal(dAtA []byte) error {
+func (m *RawDeleteRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -9270,10 +11095,10 @@ func (m *RawGetRequest) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: RawGetRequest: wiretype end group for non-group")
+			return fmt.Errorf("proto: RawDeleteRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: RawGetRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: RawDeleteRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
@@ -9361,7 +11186,7 @@ func (m *RawGetRequest) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *RawGetResponse) Unmarshal(dAtA []byte) error {
+func (m *RawDeleteResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -9384,10 +11209,10 @@ func (m *RawGetResponse) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: RawGetResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: RawDeleteResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: RawGetResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: RawDeleteResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
@@ -9437,51 +11262,20 @@ func (m *RawGetResponse) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
-				return ErrInvalidLengthKvrpcpb
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.Error = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		case 3:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
-			}
-			var byteLen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowKvrpcpb
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				byteLen |= (int(b) & 0x7F) << shift
+				stringLen |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if byteLen < 0 {
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
 				return ErrInvalidLengthKvrpcpb
 			}
-			postIndex := iNdEx + byteLen
+			postIndex := iNdEx + intStringLen
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Value = append(m.Value[:0], dAtA[iNdEx:postIndex]...)
-			if m.Value == nil {
-				m.Value = []byte{}
-			}
+			m.Error = string(dAtA[iNdEx:postIndex])
 			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
@@ -9504,7 +11298,7 @@ func (m *RawGetResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *RawPutRequest) Unmarshal(dAtA []byte) error {
+func (m *RawBatchDeleteRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -9527,10 +11321,10 @@ func (m *RawPutRequest) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: RawPutRequest: wiretype end group for non-group")
+			return fmt.Errorf("proto: RawBatchDeleteRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: RawPutRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: RawBatchDeleteRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
@@ -9568,38 +11362,7 @@ func (m *RawPutRequest) Unmarshal(dAtA []byte) error {
 			iNdEx = postIndex
 		case 2:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
-			}
-			var byteLen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowKvrpcpb
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				byteLen |= (int(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if byteLen < 0 {
-				return ErrInvalidLengthKvrpcpb
-			}
-			postIndex := iNdEx + byteLen
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...)
-			if m.Key == nil {
-				m.Key = []byte{}
-			}
-			iNdEx = postIndex
-		case 3:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Keys", wireType)
 			}
 			var byteLen int
 			for shift := uint(0); ; shift += 7 {
@@ -9623,10 +11386,8 @@ func (m *RawPutRequest) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Value = append(m.Value[:0], dAtA[iNdEx:postIndex]...)
-			if m.Value == nil {
-				m.Value = []byte{}
-			}
+			m.Keys = append(m.Keys, make([]byte, postIndex-iNdEx))
+			copy(m.Keys[len(m.Keys)-1], dAtA[iNdEx:postIndex])
 			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
@@ -9649,7 +11410,7 @@ func (m *RawPutRequest) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *RawPutResponse) Unmarshal(dAtA []byte) error {
+func (m *RawBatchDeleteResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -9672,10 +11433,10 @@ func (m *RawPutResponse) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: RawPutResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: RawBatchDeleteResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: RawPutResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: RawBatchDeleteResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
@@ -9761,7 +11522,7 @@ func (m *RawPutResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *RawDeleteRequest) Unmarshal(dAtA []byte) error {
+func (m *DeleteRangeRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -9784,10 +11545,10 @@ func (m *RawDeleteRequest) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: RawDeleteRequest: wiretype end group for non-group")
+			return fmt.Errorf("proto: DeleteRangeRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: RawDeleteRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: DeleteRangeRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
@@ -9825,7 +11586,7 @@ func (m *RawDeleteRequest) Unmarshal(dAtA []byte) error {
 			iNdEx = postIndex
 		case 2:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field StartKey", wireType)
 			}
 			var byteLen int
 			for shift := uint(0); ; shift += 7 {
@@ -9849,9 +11610,40 @@ func (m *RawDeleteRequest) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...)
-			if m.Key == nil {
-				m.Key = []byte{}
+			m.StartKey = append(m.StartKey[:0], dAtA[iNdEx:postIndex]...)
+			if m.StartKey == nil {
+				m.StartKey = []byte{}
+			}
+			iNdEx = postIndex
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field EndKey", wireType)
+			}
+			var byteLen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowKvrpcpb
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				byteLen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if byteLen < 0 {
+				return ErrInvalidLengthKvrpcpb
+			}
+			postIndex := iNdEx + byteLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.EndKey = append(m.EndKey[:0], dAtA[iNdEx:postIndex]...)
+			if m.EndKey == nil {
+				m.EndKey = []byte{}
 			}
 			iNdEx = postIndex
 		default:
@@ -9875,7 +11667,7 @@ func (m *RawDeleteRequest) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *RawDeleteResponse) Unmarshal(dAtA []byte) error {
+func (m *DeleteRangeResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -9898,10 +11690,10 @@ func (m *RawDeleteResponse) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: RawDeleteResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: DeleteRangeResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: RawDeleteResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: DeleteRangeResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
@@ -9987,7 +11779,7 @@ func (m *RawDeleteResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *DeleteRangeRequest) Unmarshal(dAtA []byte) error {
+func (m *RawDeleteRangeRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -10010,10 +11802,10 @@ func (m *DeleteRangeRequest) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: DeleteRangeRequest: wiretype end group for non-group")
+			return fmt.Errorf("proto: RawDeleteRangeRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: DeleteRangeRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: RawDeleteRangeRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
@@ -10132,7 +11924,7 @@ func (m *DeleteRangeRequest) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *DeleteRangeResponse) Unmarshal(dAtA []byte) error {
+func (m *RawDeleteRangeResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -10155,10 +11947,10 @@ func (m *DeleteRangeResponse) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: DeleteRangeResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: RawDeleteRangeResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: DeleteRangeResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: RawDeleteRangeResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
@@ -10244,7 +12036,7 @@ func (m *DeleteRangeResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *RawDeleteRangeRequest) Unmarshal(dAtA []byte) error {
+func (m *RawScanRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -10267,10 +12059,10 @@ func (m *RawDeleteRangeRequest) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: RawDeleteRangeRequest: wiretype end group for non-group")
+			return fmt.Errorf("proto: RawScanRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: RawDeleteRangeRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: RawScanRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
@@ -10338,10 +12130,99 @@ func (m *RawDeleteRangeRequest) Unmarshal(dAtA []byte) error {
 			}
 			iNdEx = postIndex
 		case 3:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Limit", wireType)
+			}
+			m.Limit = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowKvrpcpb
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Limit |= (uint32(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 4:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field KeyOnly", wireType)
+			}
+			var v int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowKvrpcpb
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				v |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			m.KeyOnly = bool(v != 0)
+		default:
+			iNdEx = preIndex
+			skippy, err := skipKvrpcpb(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthKvrpcpb
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *RawScanResponse) 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 ErrIntOverflowKvrpcpb
+			}
+			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: RawScanResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: RawScanResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field EndKey", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field RegionError", wireType)
 			}
-			var byteLen int
+			var msglen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowKvrpcpb
@@ -10351,21 +12232,54 @@ func (m *RawDeleteRangeRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				byteLen |= (int(b) & 0x7F) << shift
+				msglen |= (int(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if byteLen < 0 {
+			if msglen < 0 {
+				return ErrInvalidLengthKvrpcpb
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.RegionError == nil {
+				m.RegionError = &errorpb.Error{}
+			}
+			if err := m.RegionError.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Kvs", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowKvrpcpb
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
 				return ErrInvalidLengthKvrpcpb
 			}
-			postIndex := iNdEx + byteLen
+			postIndex := iNdEx + msglen
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.EndKey = append(m.EndKey[:0], dAtA[iNdEx:postIndex]...)
-			if m.EndKey == nil {
-				m.EndKey = []byte{}
+			m.Kvs = append(m.Kvs, &KvPair{})
+			if err := m.Kvs[len(m.Kvs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
 			}
 			iNdEx = postIndex
 		default:
@@ -10389,7 +12303,7 @@ func (m *RawDeleteRangeRequest) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *RawDeleteRangeResponse) Unmarshal(dAtA []byte) error {
+func (m *KeyRange) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -10412,17 +12326,17 @@ func (m *RawDeleteRangeResponse) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: RawDeleteRangeResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: KeyRange: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: RawDeleteRangeResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: KeyRange: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field RegionError", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field StartKey", wireType)
 			}
-			var msglen int
+			var byteLen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowKvrpcpb
@@ -10432,30 +12346,28 @@ func (m *RawDeleteRangeResponse) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= (int(b) & 0x7F) << shift
+				byteLen |= (int(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if msglen < 0 {
+			if byteLen < 0 {
 				return ErrInvalidLengthKvrpcpb
 			}
-			postIndex := iNdEx + msglen
+			postIndex := iNdEx + byteLen
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.RegionError == nil {
-				m.RegionError = &errorpb.Error{}
-			}
-			if err := m.RegionError.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
+			m.StartKey = append(m.StartKey[:0], dAtA[iNdEx:postIndex]...)
+			if m.StartKey == nil {
+				m.StartKey = []byte{}
 			}
 			iNdEx = postIndex
 		case 2:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field EndKey", wireType)
 			}
-			var stringLen uint64
+			var byteLen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowKvrpcpb
@@ -10465,20 +12377,22 @@ func (m *RawDeleteRangeResponse) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= (uint64(b) & 0x7F) << shift
+				byteLen |= (int(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
+			if byteLen < 0 {
 				return ErrInvalidLengthKvrpcpb
 			}
-			postIndex := iNdEx + intStringLen
+			postIndex := iNdEx + byteLen
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Error = string(dAtA[iNdEx:postIndex])
+			m.EndKey = append(m.EndKey[:0], dAtA[iNdEx:postIndex]...)
+			if m.EndKey == nil {
+				m.EndKey = []byte{}
+			}
 			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
@@ -10501,7 +12415,7 @@ func (m *RawDeleteRangeResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *RawScanRequest) Unmarshal(dAtA []byte) error {
+func (m *RawBatchScanRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -10524,10 +12438,10 @@ func (m *RawScanRequest) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: RawScanRequest: wiretype end group for non-group")
+			return fmt.Errorf("proto: RawBatchScanRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: RawScanRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: RawBatchScanRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
@@ -10565,9 +12479,9 @@ func (m *RawScanRequest) Unmarshal(dAtA []byte) error {
 			iNdEx = postIndex
 		case 2:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field StartKey", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Ranges", wireType)
 			}
-			var byteLen int
+			var msglen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowKvrpcpb
@@ -10577,28 +12491,28 @@ func (m *RawScanRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				byteLen |= (int(b) & 0x7F) << shift
+				msglen |= (int(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if byteLen < 0 {
+			if msglen < 0 {
 				return ErrInvalidLengthKvrpcpb
 			}
-			postIndex := iNdEx + byteLen
+			postIndex := iNdEx + msglen
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.StartKey = append(m.StartKey[:0], dAtA[iNdEx:postIndex]...)
-			if m.StartKey == nil {
-				m.StartKey = []byte{}
+			m.Ranges = append(m.Ranges, &KeyRange{})
+			if err := m.Ranges[len(m.Ranges)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
 			}
 			iNdEx = postIndex
 		case 3:
 			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Limit", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field EachLimit", wireType)
 			}
-			m.Limit = 0
+			m.EachLimit = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowKvrpcpb
@@ -10608,11 +12522,31 @@ func (m *RawScanRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.Limit |= (uint32(b) & 0x7F) << shift
+				m.EachLimit |= (uint32(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
+		case 4:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field KeyOnly", wireType)
+			}
+			var v int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowKvrpcpb
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				v |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			m.KeyOnly = bool(v != 0)
 		default:
 			iNdEx = preIndex
 			skippy, err := skipKvrpcpb(dAtA[iNdEx:])
@@ -10634,7 +12568,7 @@ func (m *RawScanRequest) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *RawScanResponse) Unmarshal(dAtA []byte) error {
+func (m *RawBatchScanResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -10657,10 +12591,10 @@ func (m *RawScanResponse) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: RawScanResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: RawBatchScanResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: RawScanResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: RawBatchScanResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
@@ -10748,7 +12682,7 @@ func (m *RawScanResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *WriteInfo) Unmarshal(dAtA []byte) error {
+func (m *MvccWrite) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -10771,17 +12705,17 @@ func (m *WriteInfo) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: WriteInfo: wiretype end group for non-group")
+			return fmt.Errorf("proto: MvccWrite: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: WriteInfo: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: MvccWrite: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field StartTs", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
 			}
-			m.StartTs = 0
+			m.Type = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowKvrpcpb
@@ -10791,16 +12725,16 @@ func (m *WriteInfo) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.StartTs |= (uint64(b) & 0x7F) << shift
+				m.Type |= (Op(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
 		case 2:
 			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field StartTs", wireType)
 			}
-			m.Type = 0
+			m.StartTs = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowKvrpcpb
@@ -10810,7 +12744,7 @@ func (m *WriteInfo) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.Type |= (Op(b) & 0x7F) << shift
+				m.StartTs |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -10834,6 +12768,37 @@ func (m *WriteInfo) Unmarshal(dAtA []byte) error {
 					break
 				}
 			}
+		case 4:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ShortValue", wireType)
+			}
+			var byteLen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowKvrpcpb
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				byteLen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if byteLen < 0 {
+				return ErrInvalidLengthKvrpcpb
+			}
+			postIndex := iNdEx + byteLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.ShortValue = append(m.ShortValue[:0], dAtA[iNdEx:postIndex]...)
+			if m.ShortValue == nil {
+				m.ShortValue = []byte{}
+			}
+			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipKvrpcpb(dAtA[iNdEx:])
@@ -10855,7 +12820,7 @@ func (m *WriteInfo) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *ValueInfo) Unmarshal(dAtA []byte) error {
+func (m *MvccValue) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -10878,13 +12843,32 @@ func (m *ValueInfo) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: ValueInfo: wiretype end group for non-group")
+			return fmt.Errorf("proto: MvccValue: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: ValueInfo: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: MvccValue: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field StartTs", wireType)
+			}
+			m.StartTs = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowKvrpcpb
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.StartTs |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 2:
 			if wireType != 2 {
 				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
 			}
@@ -10915,11 +12899,80 @@ func (m *ValueInfo) Unmarshal(dAtA []byte) error {
 				m.Value = []byte{}
 			}
 			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipKvrpcpb(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthKvrpcpb
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *MvccLock) 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 ErrIntOverflowKvrpcpb
+			}
+			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: MvccLock: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: MvccLock: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			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 ErrIntOverflowKvrpcpb
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Type |= (Op(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
 		case 2:
 			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Ts", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field StartTs", wireType)
 			}
-			m.Ts = 0
+			m.StartTs = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowKvrpcpb
@@ -10929,16 +12982,16 @@ func (m *ValueInfo) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.Ts |= (uint64(b) & 0x7F) << shift
+				m.StartTs |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
 		case 3:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field IsShortValue", wireType)
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Primary", wireType)
 			}
-			var v int
+			var byteLen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowKvrpcpb
@@ -10948,12 +13001,54 @@ func (m *ValueInfo) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				v |= (int(b) & 0x7F) << shift
+				byteLen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if byteLen < 0 {
+				return ErrInvalidLengthKvrpcpb
+			}
+			postIndex := iNdEx + byteLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Primary = append(m.Primary[:0], dAtA[iNdEx:postIndex]...)
+			if m.Primary == nil {
+				m.Primary = []byte{}
+			}
+			iNdEx = postIndex
+		case 4:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ShortValue", wireType)
+			}
+			var byteLen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowKvrpcpb
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				byteLen |= (int(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			m.IsShortValue = bool(v != 0)
+			if byteLen < 0 {
+				return ErrInvalidLengthKvrpcpb
+			}
+			postIndex := iNdEx + byteLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.ShortValue = append(m.ShortValue[:0], dAtA[iNdEx:postIndex]...)
+			if m.ShortValue == nil {
+				m.ShortValue = []byte{}
+			}
+			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipKvrpcpb(dAtA[iNdEx:])
@@ -11031,7 +13126,7 @@ func (m *MvccInfo) Unmarshal(dAtA []byte) error {
 				return io.ErrUnexpectedEOF
 			}
 			if m.Lock == nil {
-				m.Lock = &LockInfo{}
+				m.Lock = &MvccLock{}
 			}
 			if err := m.Lock.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
@@ -11063,7 +13158,7 @@ func (m *MvccInfo) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Writes = append(m.Writes, &WriteInfo{})
+			m.Writes = append(m.Writes, &MvccWrite{})
 			if err := m.Writes[len(m.Writes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
@@ -11094,7 +13189,7 @@ func (m *MvccInfo) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Values = append(m.Values, &ValueInfo{})
+			m.Values = append(m.Values, &MvccValue{})
 			if err := m.Values[len(m.Values)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
@@ -12028,116 +14123,126 @@ var (
 func init() { proto.RegisterFile("kvrpcpb.proto", fileDescriptorKvrpcpb) }
 
 var fileDescriptorKvrpcpb = []byte{
-	// 1773 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xbc, 0x59, 0x5f, 0x6f, 0x1b, 0x45,
-	0x10, 0xef, 0x9d, 0xff, 0x9d, 0xc7, 0x7f, 0xe2, 0x6e, 0xd2, 0xc6, 0x14, 0x28, 0xed, 0x41, 0x05,
-	0x04, 0x91, 0x8a, 0xb4, 0xe2, 0x11, 0xa1, 0xa6, 0xa5, 0x0d, 0x4d, 0x48, 0x74, 0x89, 0x52, 0x55,
-	0x02, 0x8e, 0xcb, 0x79, 0xe3, 0x9c, 0x72, 0xbe, 0xbb, 0xde, 0xad, 0x9d, 0x58, 0x08, 0xf1, 0x80,
-	0x40, 0xe2, 0x11, 0x84, 0x04, 0x0f, 0xf0, 0xc0, 0x23, 0x9f, 0x81, 0x2f, 0xc0, 0x23, 0x1f, 0x01,
-	0xc1, 0x17, 0x61, 0x76, 0xf7, 0xfe, 0xf8, 0xec, 0x04, 0x22, 0xcb, 0xf5, 0x43, 0xe4, 0xdb, 0x99,
-	0xd9, 0x9d, 0x99, 0xdf, 0xcc, 0xce, 0xec, 0x6e, 0xa0, 0x71, 0x3c, 0x08, 0x03, 0x3b, 0x38, 0x58,
-	0x0d, 0x42, 0x9f, 0xf9, 0xa4, 0x12, 0x0f, 0xaf, 0xd5, 0x7b, 0x94, 0x59, 0x09, 0xf9, 0x5a, 0x83,
-	0x86, 0xa1, 0x1f, 0xa6, 0xc3, 0xa5, 0xae, 0xdf, 0xf5, 0xc5, 0xe7, 0x6d, 0xfe, 0x25, 0xa9, 0xfa,
-	0x17, 0xa0, 0x6d, 0xfa, 0xf6, 0xf1, 0x86, 0x77, 0xe8, 0x93, 0x9b, 0x50, 0x0f, 0x42, 0xa7, 0x67,
-	0x85, 0x43, 0xd3, 0x45, 0x5a, 0x5b, 0xb9, 0xa1, 0xbc, 0x51, 0x37, 0x6a, 0x31, 0x8d, 0x8b, 0x71,
-	0x11, 0xce, 0x32, 0x07, 0x34, 0x8c, 0x1c, 0xdf, 0x6b, 0xab, 0x28, 0x52, 0x34, 0x6a, 0x9c, 0xb6,
-	0x2f, 0x49, 0xa4, 0x05, 0x85, 0x63, 0x3a, 0x6c, 0x17, 0xc4, 0x64, 0xfe, 0x49, 0x5e, 0x00, 0x4d,
-	0x4c, 0x62, 0xcc, 0x6d, 0x17, 0xc5, 0x84, 0x0a, 0x1f, 0xef, 0x31, 0x57, 0x77, 0x40, 0x7b, 0x4c,
-	0x87, 0x0f, 0xb8, 0xa1, 0xe4, 0x4d, 0x28, 0x73, 0x32, 0xed, 0x08, 0xc5, 0xb5, 0xb5, 0xcb, 0xab,
-	0x89, 0x9b, 0x89, 0x85, 0x46, 0x2c, 0x40, 0x5e, 0x82, 0x6a, 0x48, 0x59, 0x38, 0xb4, 0x0e, 0x5c,
-	0x2a, 0x6c, 0xa8, 0x1a, 0x19, 0x81, 0x2c, 0x41, 0xc9, 0x3a, 0xf0, 0x43, 0x26, 0x6c, 0xa8, 0x1a,
-	0x72, 0xa0, 0xff, 0x52, 0x80, 0xca, 0xba, 0xef, 0x31, 0x7a, 0xca, 0xc8, 0x8b, 0x7c, 0x7e, 0x17,
-	0xad, 0x35, 0x1d, 0xa9, 0xad, 0x68, 0x68, 0x92, 0xb0, 0xd1, 0x21, 0xef, 0x42, 0x3d, 0x66, 0xd2,
-	0xc0, 0xb7, 0x8f, 0xc4, 0xfa, 0xb5, 0xb5, 0xc5, 0xd5, 0x18, 0x5c, 0x43, 0xf0, 0x1e, 0x70, 0x96,
-	0x51, 0x0b, 0xb3, 0x01, 0xb9, 0x01, 0xc5, 0x80, 0xd2, 0x50, 0x68, 0xad, 0xad, 0xd5, 0x13, 0xf9,
-	0x1d, 0xa4, 0x19, 0x82, 0x43, 0x08, 0x14, 0x19, 0x0d, 0x7b, 0xed, 0x92, 0xd0, 0x28, 0xbe, 0xc9,
-	0x6d, 0xd0, 0x10, 0x60, 0x3f, 0x74, 0xd8, 0xb0, 0x5d, 0x46, 0x7a, 0x13, 0x35, 0x25, 0x7e, 0xaf,
-	0xfb, 0xbd, 0x9e, 0xe5, 0x75, 0x76, 0x42, 0xc7, 0x48, 0x85, 0xc8, 0xfb, 0xb0, 0xe0, 0x44, 0xbe,
-	0x6b, 0x31, 0x6e, 0xa1, 0x4b, 0x07, 0xd4, 0x6d, 0x57, 0xc4, 0xbc, 0xe5, 0x74, 0xde, 0x46, 0xc2,
-	0xdf, 0xe4, 0x6c, 0xa3, 0xe9, 0xe4, 0xc6, 0xe4, 0x35, 0x68, 0x7a, 0x3e, 0x33, 0x0f, 0x1d, 0xd7,
-	0x35, 0x6d, 0xcb, 0x3e, 0xa2, 0x6d, 0x0d, 0x17, 0xd0, 0x8c, 0x3a, 0x52, 0x3f, 0x40, 0xe2, 0x3a,
-	0xa7, 0xf1, 0xa8, 0x45, 0x43, 0xcf, 0xc6, 0x54, 0xe8, 0xb6, 0xab, 0x82, 0x5f, 0xe1, 0xe3, 0x4d,
-	0xbf, 0x4b, 0x5e, 0x81, 0xda, 0x11, 0xda, 0xe5, 0x52, 0x93, 0x39, 0x3d, 0xda, 0x06, 0xc1, 0x05,
-	0x49, 0xda, 0x43, 0x0a, 0x17, 0x88, 0x6c, 0xcb, 0x33, 0x3b, 0x08, 0x81, 0xe3, 0xb6, 0x6b, 0x52,
-	0x80, 0x93, 0xee, 0x0b, 0xca, 0x87, 0x45, 0xad, 0xd8, 0x2a, 0x71, 0xf8, 0xac, 0x8e, 0xf9, 0xac,
-	0xef, 0x87, 0xfd, 0x9e, 0x7e, 0x1f, 0xe0, 0x51, 0xb6, 0xc2, 0x32, 0x54, 0x4e, 0x2c, 0x87, 0x99,
-	0xbd, 0x48, 0xc4, 0xa7, 0x60, 0x94, 0xf9, 0x70, 0x2b, 0x22, 0x2f, 0x03, 0x60, 0xe6, 0xda, 0x34,
-	0x8a, 0x38, 0x4f, 0x15, 0xbc, 0x6a, 0x4c, 0xd9, 0x8a, 0xf4, 0xf7, 0x40, 0xdb, 0x45, 0x35, 0x22,
-	0x9f, 0x31, 0x0f, 0x98, 0xcf, 0x2c, 0x37, 0x5e, 0x41, 0x0e, 0x78, 0xee, 0xc4, 0xe2, 0x98, 0x69,
-	0xf9, 0xf9, 0xb4, 0xa3, 0x7f, 0xa5, 0x00, 0xec, 0xa6, 0x76, 0x92, 0xd7, 0xa1, 0x74, 0x82, 0xa8,
-	0xd3, 0x89, 0x94, 0x4c, 0x94, 0x18, 0x92, 0x4f, 0x6e, 0x41, 0x51, 0xec, 0x19, 0xf5, 0x3c, 0x39,
-	0xc1, 0xe6, 0x62, 0x1d, 0x8b, 0x59, 0x71, 0x8e, 0x9c, 0x25, 0xc6, 0xd9, 0xfa, 0x10, 0x6a, 0x0f,
-	0x4e, 0xa9, 0x2d, 0x8d, 0x88, 0xc8, 0xdd, 0x3c, 0xde, 0x4a, 0x9c, 0x90, 0xc9, 0xe4, 0x0c, 0xb6,
-	0x5c, 0x10, 0xee, 0xe6, 0x83, 0xa0, 0x8e, 0xcd, 0xca, 0xbc, 0x1c, 0x8d, 0x8c, 0xde, 0x01, 0x78,
-	0x48, 0x99, 0x41, 0x9f, 0xf5, 0x69, 0xc4, 0xc8, 0x0a, 0x54, 0x6c, 0xb9, 0x67, 0x62, 0xad, 0xad,
-	0x91, 0xe4, 0x14, 0x74, 0x23, 0x11, 0x48, 0x36, 0xbe, 0x9a, 0x6d, 0xfc, 0x36, 0x54, 0x92, 0x42,
-	0x51, 0x90, 0xfb, 0x3e, 0x1e, 0xea, 0x5f, 0x42, 0x4d, 0x68, 0x89, 0x02, 0xdf, 0x8b, 0x28, 0x79,
-	0x27, 0xdb, 0x72, 0xbc, 0x14, 0xc4, 0xba, 0x9a, 0xab, 0x49, 0x05, 0x13, 0x05, 0x22, 0xdd, 0x6d,
-	0xa2, 0x5a, 0x60, 0x64, 0xa4, 0xec, 0x38, 0xe2, 0x49, 0x3d, 0x31, 0x24, 0x9f, 0x67, 0xc1, 0xc0,
-	0x72, 0xfb, 0x34, 0xae, 0x48, 0x72, 0xa0, 0xff, 0xaa, 0x40, 0x8d, 0x23, 0x30, 0x8d, 0xa3, 0x58,
-	0x3d, 0x22, 0x66, 0x85, 0xcc, 0xcc, 0xdc, 0xd5, 0x04, 0x01, 0x55, 0x73, 0x75, 0xae, 0xd3, 0x73,
-	0x64, 0xf1, 0x69, 0x18, 0x72, 0x30, 0x8a, 0x44, 0x31, 0x87, 0x04, 0xdf, 0x66, 0xb8, 0x8c, 0xe9,
-	0x7b, 0xee, 0x50, 0xd4, 0x05, 0xdc, 0x66, 0x38, 0xde, 0xc6, 0xa1, 0xfe, 0x14, 0xca, 0x8f, 0x07,
-	0x3b, 0x96, 0x33, 0xe2, 0xac, 0xf2, 0x3f, 0xce, 0x4e, 0xc6, 0xe0, 0x6c, 0xf7, 0x8f, 0xa0, 0x2e,
-	0xbd, 0x9f, 0x3e, 0x00, 0xb7, 0xa0, 0x14, 0xa0, 0x6d, 0x7c, 0x0f, 0x16, 0x50, 0x76, 0x21, 0xb3,
-	0x49, 0xd8, 0x6c, 0x48, 0xae, 0xbe, 0x0d, 0xda, 0x56, 0x9f, 0x89, 0xea, 0x83, 0xc0, 0xa9, 0x7e,
-	0x20, 0xd6, 0x6e, 0xae, 0xd5, 0x52, 0xf9, 0xed, 0xc0, 0x40, 0xf2, 0x85, 0x4d, 0xff, 0x5a, 0x85,
-	0x85, 0x9d, 0x90, 0x8a, 0x6d, 0x37, 0x4d, 0xf4, 0x6e, 0x43, 0xb5, 0x17, 0x1b, 0x94, 0xd8, 0x9e,
-	0xe1, 0x99, 0x98, 0x6a, 0x64, 0x32, 0x13, 0x6d, 0xb1, 0x30, 0xd9, 0x16, 0x5f, 0x85, 0x86, 0xcc,
-	0x88, 0x7c, 0x90, 0xeb, 0x82, 0xb8, 0x9f, 0x45, 0x3a, 0x6d, 0x83, 0xa5, 0x5c, 0x1b, 0x24, 0x6b,
-	0x70, 0x25, 0x3a, 0x76, 0x02, 0x13, 0x6d, 0x8c, 0x58, 0x68, 0x39, 0x1e, 0x33, 0xb1, 0x04, 0xa3,
-	0xae, 0xb2, 0xc8, 0x88, 0x45, 0xce, 0x5c, 0x4f, 0x79, 0xeb, 0x9c, 0xa5, 0x07, 0xd0, 0xca, 0x60,
-	0x98, 0x3e, 0x8c, 0xd8, 0x75, 0x05, 0x77, 0x12, 0x8b, 0x34, 0xb7, 0x62, 0x01, 0xfd, 0x37, 0x05,
-	0x1a, 0xbc, 0x25, 0x39, 0x53, 0x95, 0x87, 0x09, 0x8c, 0xd4, 0x33, 0x30, 0xc2, 0x0e, 0x89, 0x91,
-	0x8f, 0x10, 0xe3, 0x02, 0x62, 0x2c, 0xbe, 0x31, 0xd1, 0x9a, 0xb6, 0xd0, 0x3a, 0x86, 0x6e, 0x43,
-	0x52, 0xe3, 0xa9, 0xd8, 0x52, 0x4a, 0xad, 0xb2, 0x51, 0x3e, 0x70, 0x3c, 0xec, 0x58, 0xba, 0x0b,
-	0xcd, 0xc4, 0xd4, 0xe7, 0x5f, 0x63, 0xf4, 0x2e, 0x34, 0x36, 0x7a, 0x01, 0x9e, 0x32, 0x12, 0x60,
-	0x72, 0x49, 0xa6, 0x5c, 0x20, 0xc9, 0x26, 0x9d, 0x54, 0xcf, 0x70, 0x12, 0x4b, 0x42, 0x33, 0x51,
-	0x34, 0xbd, 0x5b, 0x4b, 0xa3, 0x6e, 0x55, 0x13, 0x1f, 0x3e, 0x87, 0xa5, 0x7b, 0x16, 0xc3, 0x43,
-	0x8d, 0xef, 0xba, 0x07, 0x96, 0x7d, 0x3c, 0xcf, 0x18, 0xeb, 0x11, 0x5c, 0x19, 0x53, 0x3e, 0x87,
-	0xa8, 0x45, 0x98, 0x23, 0x2e, 0xb5, 0xbc, 0x7e, 0x30, 0x9b, 0x76, 0x37, 0xe1, 0x7d, 0x61, 0xd2,
-	0x7b, 0xfd, 0x07, 0x05, 0x16, 0x52, 0xad, 0x73, 0x68, 0x7f, 0x93, 0x89, 0x55, 0x38, 0x2b, 0xb1,
-	0x8e, 0x61, 0x41, 0x04, 0x60, 0xca, 0xde, 0x9f, 0xc4, 0x54, 0x1d, 0xd9, 0xb7, 0xe7, 0x77, 0x7f,
-	0x17, 0x5a, 0x99, 0xb2, 0xe7, 0xde, 0x81, 0xbe, 0x43, 0xc4, 0x79, 0xb3, 0xe3, 0x95, 0x7a, 0x1a,
-	0xdf, 0xf0, 0x30, 0xdb, 0xb3, 0x4e, 0xc7, 0x52, 0x1a, 0x90, 0x94, 0x24, 0x74, 0xee, 0x3c, 0x50,
-	0x38, 0xef, 0x3c, 0x50, 0x1c, 0x39, 0x0f, 0xe8, 0x3f, 0x2a, 0xd0, 0xca, 0x6c, 0x9a, 0x43, 0x1a,
-	0xa0, 0x20, 0x6f, 0x36, 0x72, 0xd7, 0x9d, 0x79, 0xb7, 0x92, 0x7c, 0xfd, 0x0e, 0x54, 0xf6, 0x4e,
-	0xe5, 0xf9, 0x19, 0x33, 0x9c, 0x9d, 0x7a, 0xf1, 0xfd, 0x88, 0x7f, 0x92, 0xab, 0x50, 0x46, 0xc7,
-	0x58, 0x3f, 0x8a, 0x51, 0x88, 0x47, 0xfa, 0xef, 0x0a, 0x10, 0x74, 0xc3, 0x77, 0x07, 0x74, 0x5a,
-	0x94, 0x2f, 0x54, 0x3a, 0x2e, 0x96, 0xcc, 0xe4, 0x6d, 0xa8, 0xa2, 0xb5, 0xa6, 0x83, 0x4e, 0x44,
-	0x88, 0x7b, 0x21, 0xa7, 0x39, 0xf6, 0xce, 0xd0, 0x98, 0xfc, 0x88, 0xf4, 0x67, 0xb0, 0x98, 0x33,
-	0x7e, 0x0e, 0xa5, 0x67, 0x1f, 0xaa, 0x0f, 0xd7, 0xa7, 0x81, 0x09, 0xaf, 0x3f, 0x91, 0x75, 0x48,
-	0xcd, 0xc0, 0xc7, 0x83, 0x40, 0x8c, 0x51, 0x95, 0x53, 0x76, 0x38, 0x01, 0xcf, 0x75, 0xc0, 0xd7,
-	0x9d, 0x83, 0x07, 0x5b, 0xd0, 0x30, 0xac, 0x93, 0x59, 0x5d, 0x15, 0x74, 0x1f, 0x9a, 0xc9, 0x72,
-	0x33, 0x6e, 0x6c, 0xe7, 0x1c, 0x23, 0x6d, 0x61, 0xff, 0x4e, 0x7f, 0x46, 0x57, 0x9d, 0xb3, 0x95,
-	0x3c, 0x15, 0x5e, 0x09, 0x25, 0xb3, 0x6e, 0xd7, 0x3b, 0xd0, 0xc2, 0xa5, 0xef, 0x53, 0x97, 0x4e,
-	0x77, 0x0c, 0x9e, 0x0c, 0xc1, 0xc7, 0x70, 0x79, 0x64, 0xc5, 0x59, 0xdb, 0x3b, 0x00, 0x12, 0x2f,
-	0x6d, 0x79, 0x5d, 0x3a, 0xf3, 0x6b, 0xd7, 0x32, 0x54, 0xa8, 0xd7, 0x19, 0xa9, 0xc0, 0x65, 0x1c,
-	0x22, 0x43, 0xff, 0x14, 0x16, 0x73, 0x7a, 0x67, 0xed, 0xd7, 0x10, 0xae, 0x64, 0xa8, 0xcd, 0xd7,
-	0x35, 0x0b, 0xae, 0x8e, 0xab, 0x9e, 0xb5, 0x77, 0x72, 0x5b, 0xce, 0xef, 0xa2, 0x8c, 0x27, 0xe9,
-	0x85, 0x54, 0xe1, 0xf4, 0xce, 0xdc, 0xc4, 0xe4, 0x1e, 0x9c, 0x7b, 0x2e, 0xe0, 0x3c, 0xbd, 0x03,
-	0xd5, 0x27, 0xfc, 0xee, 0x24, 0x3a, 0x1d, 0x7f, 0xeb, 0x12, 0x86, 0xb2, 0x28, 0x6e, 0x77, 0x15,
-	0x31, 0xde, 0x8b, 0xb0, 0xfb, 0x17, 0xd9, 0x30, 0x90, 0xaf, 0x8c, 0x63, 0xb7, 0x56, 0xc1, 0xe0,
-	0x4e, 0xc6, 0x3d, 0x89, 0x45, 0x71, 0x3b, 0xd2, 0x24, 0x61, 0x2f, 0xd2, 0x9f, 0x40, 0x75, 0x9f,
-	0x57, 0x82, 0xe4, 0x3d, 0x4a, 0xd6, 0x08, 0x65, 0xa4, 0x46, 0x90, 0x26, 0xa8, 0x2c, 0xe9, 0xa7,
-	0xf8, 0xc5, 0x5f, 0xe7, 0x9c, 0xc8, 0x8c, 0x8e, 0x7c, 0xde, 0x0b, 0xd3, 0x92, 0xa2, 0x19, 0x75,
-	0x27, 0xda, 0xe5, 0x44, 0xb1, 0x9e, 0xfe, 0xad, 0x82, 0xf7, 0xea, 0x81, 0x6d, 0x8b, 0x85, 0x93,
-	0xc7, 0xa7, 0x73, 0xdf, 0x4d, 0xe5, 0xe3, 0xd3, 0x0a, 0x94, 0xc5, 0x75, 0x31, 0x01, 0x86, 0xa4,
-	0x82, 0x29, 0x12, 0x46, 0x2c, 0xc1, 0x65, 0x85, 0xf2, 0xe4, 0xc0, 0x90, 0xc9, 0xa6, 0xfe, 0x18,
-	0xb1, 0x84, 0xbe, 0x0b, 0x8b, 0xdc, 0x14, 0x2c, 0xde, 0xf7, 0x86, 0x18, 0xd9, 0xd9, 0x54, 0xa3,
-	0x6f, 0x14, 0x58, 0xca, 0xaf, 0x3a, 0xeb, 0xbe, 0x80, 0xa8, 0xf1, 0x13, 0xc2, 0xc4, 0x5b, 0x5c,
-	0x02, 0xab, 0x21, 0xd8, 0xfa, 0x67, 0xb0, 0x9c, 0xda, 0xb1, 0x2b, 0x93, 0x62, 0x1a, 0x0f, 0x47,
-	0x53, 0x4c, 0xcd, 0xa5, 0x98, 0xfe, 0xb3, 0x02, 0xed, 0x49, 0x15, 0xb3, 0x76, 0x77, 0xf2, 0x5d,
-	0x3e, 0x01, 0xa0, 0xf8, 0xdf, 0x00, 0x7c, 0x02, 0x64, 0x37, 0x70, 0xf9, 0x4d, 0x9a, 0xab, 0x98,
-	0xb6, 0x0e, 0xf0, 0x15, 0x72, 0x75, 0x80, 0x13, 0x78, 0x15, 0xfb, 0x5e, 0x81, 0xc5, 0xdc, 0xfa,
-	0xd3, 0x3b, 0xae, 0xe3, 0x3e, 0xa0, 0x87, 0x2c, 0x3e, 0xbb, 0x34, 0xf3, 0x2f, 0xf6, 0x86, 0xe0,
-	0xe1, 0xf6, 0x2a, 0x85, 0x4e, 0xf7, 0x88, 0xc5, 0x61, 0x1f, 0x17, 0x92, 0xcc, 0x95, 0xb7, 0x00,
-	0xb2, 0xc7, 0x77, 0x02, 0x50, 0xfe, 0xc8, 0x0f, 0x7b, 0x96, 0xdb, 0xba, 0x44, 0x2a, 0x50, 0xd8,
-	0xf4, 0x4f, 0x5a, 0x0a, 0xd1, 0xa0, 0xf8, 0x08, 0x65, 0x5b, 0xea, 0xca, 0x0d, 0xbc, 0x94, 0xe7,
-	0x5f, 0xd8, 0xcb, 0xa0, 0xee, 0x6e, 0xa0, 0x30, 0xfe, 0x1a, 0xeb, 0x2d, 0x65, 0x65, 0x15, 0xd4,
-	0xed, 0x80, 0x4f, 0xc5, 0xa3, 0x80, 0x5c, 0x03, 0xab, 0xb6, 0x5c, 0x83, 0xef, 0xd1, 0x96, 0x4a,
-	0xea, 0xa0, 0x25, 0x77, 0xdf, 0x56, 0xe1, 0xde, 0xca, 0x1f, 0x7f, 0x5f, 0x57, 0xfe, 0xc4, 0xbf,
-	0xbf, 0xf0, 0xef, 0xa7, 0x7f, 0xae, 0x5f, 0x82, 0x36, 0x96, 0x94, 0xd5, 0xc0, 0xf1, 0xba, 0xb6,
-	0x15, 0xac, 0x32, 0xe7, 0x78, 0x80, 0x68, 0x8b, 0xff, 0xe0, 0x1c, 0x94, 0xc5, 0xcf, 0x9d, 0x7f,
-	0x03, 0x00, 0x00, 0xff, 0xff, 0x08, 0xac, 0x24, 0x9c, 0x15, 0x1a, 0x00, 0x00,
+	// 1922 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x59, 0x51, 0x8f, 0x1b, 0x49,
+	0x11, 0xce, 0xd8, 0x63, 0x7b, 0x5c, 0xf6, 0x7a, 0x7d, 0xbd, 0x9b, 0x8b, 0xb9, 0x70, 0xc9, 0xde,
+	0x70, 0x51, 0x36, 0x8b, 0xd8, 0x88, 0xbd, 0x13, 0x4f, 0x08, 0x9d, 0xb2, 0x09, 0xb9, 0x5c, 0x76,
+	0xc9, 0xaa, 0x77, 0x95, 0x53, 0x24, 0xc0, 0xf4, 0x8e, 0x7b, 0xed, 0x91, 0xc7, 0xd3, 0x93, 0x99,
+	0xb6, 0x77, 0x47, 0x08, 0x21, 0x84, 0x0e, 0x09, 0xde, 0x40, 0x48, 0xf0, 0x00, 0x0f, 0xbc, 0x20,
+	0xf1, 0x1b, 0xf8, 0x03, 0x3c, 0xf2, 0x13, 0x50, 0xf8, 0x23, 0xa8, 0x6b, 0x7a, 0x3c, 0x1e, 0xdb,
+	0x4b, 0x56, 0x83, 0xb3, 0x3c, 0x79, 0xba, 0xaa, 0xba, 0xab, 0xbe, 0xaa, 0xea, 0xaa, 0xee, 0x36,
+	0xac, 0x0d, 0x27, 0x61, 0xe0, 0x04, 0xa7, 0xbb, 0x41, 0x28, 0xa4, 0x20, 0x35, 0x3d, 0xfc, 0xa0,
+	0x39, 0xe2, 0x92, 0xa5, 0xe4, 0x0f, 0xd6, 0x78, 0x18, 0x8a, 0x70, 0x3a, 0xdc, 0xec, 0x8b, 0xbe,
+	0xc0, 0xcf, 0x87, 0xea, 0x2b, 0xa1, 0xda, 0x3f, 0x03, 0xeb, 0x40, 0x38, 0xc3, 0x67, 0xfe, 0x99,
+	0x20, 0x1f, 0x41, 0x33, 0x08, 0xdd, 0x11, 0x0b, 0xe3, 0xae, 0x27, 0x9c, 0x61, 0xc7, 0xd8, 0x32,
+	0xb6, 0x9b, 0xb4, 0xa1, 0x69, 0x4a, 0x4c, 0x89, 0x28, 0x56, 0x77, 0xc2, 0xc3, 0xc8, 0x15, 0x7e,
+	0xa7, 0xb4, 0x65, 0x6c, 0x9b, 0xb4, 0xa1, 0x68, 0x2f, 0x13, 0x12, 0x69, 0x43, 0x79, 0xc8, 0xe3,
+	0x4e, 0x19, 0x27, 0xab, 0x4f, 0xf2, 0x35, 0xb0, 0x70, 0x92, 0x94, 0x5e, 0xc7, 0xc4, 0x09, 0x35,
+	0x35, 0x3e, 0x91, 0x9e, 0xed, 0x82, 0xf5, 0x9c, 0xc7, 0x4f, 0x94, 0xa1, 0xe4, 0x01, 0x54, 0x15,
+	0x99, 0xf7, 0x50, 0x71, 0x63, 0xef, 0xbd, 0xdd, 0x14, 0x66, 0x6a, 0x21, 0xd5, 0x02, 0xe4, 0xeb,
+	0x50, 0x0f, 0xb9, 0x0c, 0x63, 0x76, 0xea, 0x71, 0xb4, 0xa1, 0x4e, 0x33, 0x02, 0xd9, 0x84, 0x0a,
+	0x3b, 0x15, 0xa1, 0x44, 0x1b, 0xea, 0x34, 0x19, 0xd8, 0x7f, 0x2e, 0x43, 0x6d, 0x5f, 0xf8, 0x92,
+	0x5f, 0x48, 0x72, 0x5b, 0xcd, 0xef, 0xbb, 0xc2, 0xef, 0xba, 0x89, 0x36, 0x93, 0x5a, 0x09, 0xe1,
+	0x59, 0x8f, 0x7c, 0x07, 0x9a, 0x9a, 0xc9, 0x03, 0xe1, 0x0c, 0x70, 0xfd, 0xc6, 0xde, 0xc6, 0xae,
+	0x76, 0x2e, 0x45, 0xde, 0x13, 0xc5, 0xa2, 0x8d, 0x30, 0x1b, 0x90, 0x2d, 0x30, 0x03, 0xce, 0x43,
+	0xd4, 0xda, 0xd8, 0x6b, 0xa6, 0xf2, 0x47, 0x9c, 0x87, 0x14, 0x39, 0x84, 0x80, 0x29, 0x79, 0x38,
+	0xea, 0x54, 0x50, 0x23, 0x7e, 0x93, 0x87, 0x60, 0x05, 0xa1, 0x2b, 0x42, 0x57, 0xc6, 0x9d, 0xea,
+	0x96, 0xb1, 0xdd, 0xda, 0xdb, 0x98, 0xe2, 0xde, 0x17, 0xa3, 0x11, 0xf3, 0x7b, 0x47, 0xa1, 0x4b,
+	0xa7, 0x42, 0xe4, 0x33, 0x58, 0x77, 0x23, 0xe1, 0x31, 0xa9, 0x2c, 0xf4, 0xf8, 0x84, 0x7b, 0x9d,
+	0x1a, 0xce, 0xbb, 0x35, 0x9d, 0xf7, 0x2c, 0xe5, 0x1f, 0x28, 0x36, 0x6d, 0xb9, 0xb9, 0x31, 0xf9,
+	0x18, 0x5a, 0xbe, 0x90, 0xdd, 0x33, 0xd7, 0xf3, 0xba, 0x0e, 0x73, 0x06, 0xbc, 0x63, 0x6d, 0x19,
+	0xdb, 0x16, 0x6d, 0xfa, 0x42, 0x7e, 0xdf, 0xf5, 0xbc, 0x7d, 0x45, 0x53, 0x51, 0x8b, 0x62, 0xdf,
+	0xe9, 0x7a, 0xa2, 0xdf, 0xa9, 0x23, 0xbf, 0xa6, 0xc6, 0x07, 0xa2, 0x4f, 0xee, 0x42, 0x63, 0xc0,
+	0xfc, 0x9e, 0xc7, 0xbb, 0xd2, 0x1d, 0xf1, 0x0e, 0x20, 0x17, 0x12, 0xd2, 0x89, 0x3b, 0xe2, 0x4a,
+	0x20, 0x72, 0x98, 0xdf, 0xed, 0x71, 0xc9, 0x5c, 0xaf, 0xd3, 0x48, 0x04, 0x14, 0xe9, 0x31, 0x52,
+	0xbe, 0x30, 0x2d, 0xb3, 0x5d, 0x51, 0xee, 0x63, 0xbd, 0xee, 0xeb, 0xb1, 0x08, 0xc7, 0x23, 0xfb,
+	0x31, 0xc0, 0xe7, 0xd9, 0x0a, 0xb7, 0xa0, 0x76, 0xce, 0x5c, 0xd9, 0x1d, 0x45, 0x18, 0x9f, 0x32,
+	0xad, 0xaa, 0xe1, 0x61, 0x44, 0x3e, 0x04, 0x08, 0x42, 0xe1, 0xf0, 0x28, 0x52, 0xbc, 0x12, 0xf2,
+	0xea, 0x9a, 0x72, 0x18, 0xd9, 0xdf, 0x03, 0xeb, 0xd8, 0x61, 0x3e, 0xe6, 0xf3, 0x26, 0x54, 0xa4,
+	0x90, 0xcc, 0xd3, 0x2b, 0x24, 0x03, 0x95, 0x3b, 0x5a, 0x9c, 0xf7, 0xe6, 0xe6, 0xf3, 0x9e, 0xfd,
+	0x4b, 0x03, 0xe0, 0x78, 0x6a, 0x27, 0xb9, 0x0f, 0x95, 0xf3, 0xd0, 0x95, 0x7c, 0x21, 0x25, 0x53,
+	0x25, 0x34, 0xe1, 0x93, 0x7b, 0x60, 0xe2, 0x9e, 0x29, 0x5d, 0x26, 0x87, 0x6c, 0x25, 0xd6, 0x63,
+	0x92, 0xe9, 0x1c, 0x59, 0x26, 0xa6, 0xd8, 0x76, 0x0c, 0x8d, 0x27, 0x17, 0xdc, 0x49, 0x8c, 0x88,
+	0xc8, 0xa7, 0x79, 0x7f, 0x1b, 0x3a, 0x21, 0xd3, 0xc9, 0x99, 0xdb, 0x72, 0x41, 0xf8, 0x34, 0x1f,
+	0x84, 0xd2, 0xdc, 0xac, 0x0c, 0xe5, 0x6c, 0x64, 0xec, 0x1e, 0xc0, 0x53, 0x2e, 0x29, 0x7f, 0x3d,
+	0xe6, 0x91, 0x24, 0x3b, 0x50, 0x73, 0x92, 0x3d, 0xa3, 0xb5, 0xb6, 0x67, 0x92, 0x13, 0xe9, 0x34,
+	0x15, 0x48, 0x37, 0x7e, 0x29, 0xdb, 0xf8, 0x1d, 0xa8, 0xa5, 0x85, 0xa2, 0x9c, 0xec, 0x7b, 0x3d,
+	0xb4, 0x7f, 0x0e, 0x0d, 0xd4, 0x12, 0x05, 0xc2, 0x8f, 0x38, 0xf9, 0x76, 0xb6, 0xe5, 0x54, 0x29,
+	0xd0, 0xba, 0x5a, 0xbb, 0x69, 0x05, 0xc3, 0x02, 0x31, 0xdd, 0x6d, 0x58, 0x2d, 0xee, 0x43, 0x25,
+	0x91, 0x9d, 0xf7, 0x78, 0x5a, 0x4f, 0x68, 0xc2, 0x57, 0x59, 0x30, 0x61, 0xde, 0x98, 0xeb, 0x8a,
+	0x94, 0x0c, 0xec, 0xbf, 0x18, 0xd0, 0x50, 0x1e, 0x28, 0x02, 0xf4, 0x36, 0xd4, 0x23, 0xc9, 0x42,
+	0xd9, 0xcd, 0xe0, 0x5a, 0x48, 0x78, 0xce, 0x63, 0xa5, 0xce, 0x73, 0x47, 0x6e, 0x52, 0x7c, 0xd6,
+	0x68, 0x32, 0x98, 0xf5, 0x84, 0x99, 0xf3, 0x84, 0xda, 0x66, 0x43, 0x1e, 0x77, 0x85, 0xef, 0xc5,
+	0x58, 0x17, 0x2c, 0x5a, 0x1b, 0xf2, 0xf8, 0x85, 0xef, 0xc5, 0xf6, 0x2b, 0xa8, 0x3e, 0x9f, 0x1c,
+	0x31, 0x77, 0x06, 0xac, 0xf1, 0x16, 0xb0, 0x8b, 0x31, 0x58, 0x0e, 0x7f, 0x00, 0xcd, 0x04, 0x7d,
+	0xf1, 0x00, 0xdc, 0x83, 0x4a, 0xc0, 0xdc, 0x50, 0xed, 0xc1, 0xf2, 0x76, 0x63, 0x6f, 0x3d, 0xb3,
+	0x09, 0x6d, 0xa6, 0x09, 0xd7, 0x7e, 0x01, 0xd6, 0xe1, 0x58, 0x62, 0xf5, 0x21, 0xb7, 0xa1, 0x24,
+	0x02, 0x5c, 0xbb, 0xb5, 0xd7, 0x98, 0xca, 0xbf, 0x08, 0x68, 0x49, 0x04, 0x57, 0x36, 0xfd, 0xab,
+	0x12, 0xac, 0x1f, 0x85, 0x1c, 0xb7, 0x5d, 0x91, 0xe8, 0x3d, 0x84, 0xfa, 0x48, 0x1b, 0x94, 0xda,
+	0x9e, 0xf9, 0x33, 0x35, 0x95, 0x66, 0x32, 0x0b, 0x6d, 0xb1, 0xbc, 0xd8, 0x16, 0xbf, 0x01, 0x6b,
+	0x49, 0x46, 0xe4, 0x83, 0xdc, 0x44, 0xe2, 0xcb, 0x2c, 0xd2, 0xd3, 0x36, 0x58, 0xc9, 0xb5, 0x41,
+	0xb2, 0x07, 0x37, 0xa3, 0xa1, 0x1b, 0x74, 0x1d, 0xe1, 0x47, 0x32, 0x64, 0xae, 0x2f, 0xbb, 0xce,
+	0x80, 0x3b, 0x43, 0xec, 0x08, 0x16, 0xdd, 0x50, 0xcc, 0xfd, 0x29, 0x6f, 0x5f, 0xb1, 0xec, 0x00,
+	0xda, 0x99, 0x1b, 0x8a, 0x87, 0xf1, 0x01, 0x54, 0x91, 0xbb, 0xe8, 0x8b, 0x69, 0x6e, 0x69, 0x01,
+	0xfb, 0x6f, 0x06, 0xac, 0xa9, 0x96, 0xe4, 0x16, 0x2a, 0x0f, 0x0b, 0x3e, 0x2a, 0x2d, 0xf1, 0x11,
+	0x01, 0x73, 0xc8, 0xe3, 0xa8, 0x53, 0xde, 0x2a, 0x6f, 0x37, 0x29, 0x7e, 0x93, 0x7b, 0xd0, 0x72,
+	0x50, 0xeb, 0x9c, 0x77, 0xd7, 0x12, 0xaa, 0x9e, 0xfa, 0x85, 0x69, 0x55, 0xda, 0x55, 0x5a, 0x3d,
+	0x75, 0x7d, 0x4f, 0xf4, 0x6d, 0x0f, 0x5a, 0xa9, 0xa9, 0xef, 0xbe, 0xc6, 0xd8, 0x7d, 0x58, 0x7b,
+	0x36, 0x0a, 0x44, 0x38, 0x75, 0x4c, 0x2e, 0xc9, 0x8c, 0x2b, 0x24, 0xd9, 0x22, 0xc8, 0xd2, 0x12,
+	0x90, 0xf6, 0x2b, 0x68, 0xa5, 0x8a, 0x8a, 0xc3, 0xda, 0x9c, 0x85, 0x55, 0x4f, 0x31, 0xfc, 0x14,
+	0x36, 0x1f, 0x31, 0xe9, 0x0c, 0xa8, 0xf0, 0xbc, 0x53, 0xe6, 0x0c, 0xaf, 0x33, 0xc6, 0x76, 0x04,
+	0x37, 0xe7, 0x94, 0x5f, 0x43, 0xd4, 0x22, 0x68, 0xed, 0x7b, 0x9c, 0xf9, 0xe3, 0x60, 0x35, 0xed,
+	0x6e, 0x01, 0x7d, 0x79, 0x11, 0xbd, 0xfd, 0x7b, 0x03, 0xd6, 0xa7, 0x5a, 0xaf, 0xa1, 0xfd, 0x2d,
+	0x26, 0x56, 0x79, 0x59, 0x62, 0x0d, 0x61, 0x1d, 0x03, 0x50, 0xb0, 0xf7, 0xa7, 0x31, 0x2d, 0xcd,
+	0xec, 0xdb, 0xcb, 0xbb, 0xbf, 0x07, 0xed, 0x4c, 0xd9, 0x3b, 0xef, 0x40, 0xbf, 0x35, 0x60, 0x5d,
+	0x35, 0x3b, 0x55, 0xa9, 0x8b, 0x60, 0xbb, 0x0b, 0x8d, 0x11, 0xbb, 0x98, 0x4b, 0x69, 0x18, 0xb1,
+	0x8b, 0x34, 0xa1, 0x73, 0xe7, 0x81, 0xf2, 0x65, 0xe7, 0x01, 0x73, 0xe6, 0x3c, 0x60, 0xff, 0xc1,
+	0x80, 0x76, 0x66, 0xd3, 0x35, 0xa4, 0xc1, 0x7d, 0xa8, 0xa8, 0x66, 0x93, 0xec, 0xba, 0xa5, 0x77,
+	0xab, 0x84, 0x6f, 0x7f, 0x02, 0xb5, 0x93, 0x8b, 0xe4, 0xfc, 0xdc, 0x86, 0xb2, 0xbc, 0xf0, 0xf5,
+	0xfd, 0x48, 0x7d, 0x92, 0xf7, 0xa1, 0x1a, 0x49, 0x26, 0xc7, 0x91, 0xf6, 0x82, 0x1e, 0xd9, 0x7f,
+	0x37, 0x80, 0x50, 0x1e, 0x09, 0x6f, 0xc2, 0x8b, 0x7a, 0xf9, 0x4a, 0xa5, 0xe3, 0x6a, 0xc9, 0x4c,
+	0xbe, 0x05, 0x75, 0x79, 0xe1, 0x77, 0x5d, 0xff, 0x4c, 0x44, 0x1d, 0x13, 0x01, 0x67, 0x9a, 0x35,
+	0x3a, 0x6a, 0xc9, 0xe4, 0x23, 0xb2, 0x5f, 0xc3, 0x46, 0xce, 0xf8, 0x6b, 0x28, 0x3d, 0x2f, 0xa1,
+	0xfe, 0x74, 0xbf, 0x88, 0x9b, 0x3e, 0x04, 0x88, 0xd8, 0x19, 0xef, 0x06, 0xc2, 0xf5, 0xa5, 0xf6,
+	0x51, 0x5d, 0x51, 0x8e, 0x14, 0xc1, 0x1e, 0x00, 0xa8, 0x75, 0xaf, 0x01, 0xc1, 0x21, 0xac, 0x51,
+	0x76, 0xbe, 0xaa, 0xab, 0x82, 0x2d, 0xa0, 0x95, 0x2e, 0xb7, 0xe2, 0xc6, 0x76, 0xc9, 0x31, 0xd2,
+	0x41, 0xfb, 0x8f, 0xc6, 0x2b, 0xba, 0xea, 0x2c, 0x57, 0xf2, 0x0a, 0x51, 0xa1, 0x92, 0x55, 0xb7,
+	0xeb, 0x3e, 0x10, 0xca, 0xce, 0xb1, 0x8c, 0x16, 0x04, 0x71, 0xc5, 0xf2, 0xf9, 0x63, 0xd8, 0xc8,
+	0x29, 0x5a, 0x35, 0x90, 0x93, 0x0c, 0xc8, 0xea, 0x9a, 0x8f, 0x2d, 0x32, 0xab, 0xaf, 0xa7, 0xcb,
+	0x1c, 0x41, 0x9b, 0xb2, 0xf3, 0xc7, 0xdc, 0xe3, 0xc5, 0xae, 0x25, 0x8b, 0x5b, 0xe2, 0x87, 0xf0,
+	0xde, 0xcc, 0x8a, 0xab, 0x76, 0xfb, 0x97, 0x70, 0x33, 0x75, 0x50, 0x71, 0xa3, 0x97, 0x79, 0x9e,
+	0xc1, 0xfb, 0xf3, 0x0b, 0xaf, 0xda, 0xf6, 0x09, 0x10, 0xbd, 0x34, 0xf3, 0xfb, 0x7c, 0xe5, 0x57,
+	0xf8, 0x5b, 0x50, 0xe3, 0x7e, 0x6f, 0xa6, 0x9b, 0x57, 0xb9, 0xdf, 0x7b, 0xce, 0x63, 0xb5, 0x15,
+	0x72, 0x7a, 0x57, 0x8d, 0x2b, 0xc6, 0x98, 0xfc, 0x5f, 0xa0, 0x25, 0x51, 0x7b, 0xa7, 0xe8, 0x7e,
+	0x63, 0x60, 0x35, 0xbc, 0xc6, 0x57, 0x97, 0xd9, 0xb7, 0x15, 0x33, 0xff, 0xb6, 0xd2, 0x87, 0xf5,
+	0xa9, 0x2d, 0xc5, 0x81, 0x7e, 0x04, 0xe5, 0xe1, 0xe4, 0xd2, 0xca, 0xa0, 0x78, 0xf6, 0x67, 0xf8,
+	0xc2, 0x8d, 0x2e, 0xcd, 0x43, 0x30, 0x2e, 0x0f, 0x4d, 0x29, 0x17, 0x9a, 0xbf, 0x1a, 0x59, 0x2d,
+	0x2b, 0xea, 0xbc, 0x07, 0x50, 0x0d, 0x95, 0x09, 0x4b, 0x6f, 0xf9, 0x49, 0xbc, 0xb5, 0x80, 0x3a,
+	0x61, 0x70, 0xe6, 0x0c, 0xba, 0xb3, 0xfe, 0xac, 0x2b, 0xca, 0xc1, 0xdb, 0x7c, 0xea, 0xc1, 0x66,
+	0xde, 0xce, 0x77, 0xea, 0xd8, 0xaf, 0x0c, 0xa8, 0x1f, 0x4e, 0x1c, 0xe7, 0x4b, 0x7c, 0x7f, 0xbd,
+	0x0b, 0xa6, 0x8c, 0x03, 0xbe, 0xec, 0x71, 0x09, 0x19, 0xf8, 0x9c, 0x8d, 0xbe, 0x97, 0xe9, 0xe1,
+	0xb5, 0x86, 0xe3, 0x93, 0x48, 0x85, 0x45, 0x9f, 0x2a, 0x65, 0xa4, 0x0f, 0x94, 0x56, 0x42, 0x38,
+	0x89, 0xf0, 0x29, 0x7b, 0x20, 0xd4, 0xb9, 0x14, 0xdb, 0xbb, 0x89, 0xa1, 0x01, 0x24, 0xbd, 0xc4,
+	0x1e, 0xff, 0xdd, 0xc4, 0x0c, 0x1c, 0xe4, 0xb4, 0x18, 0x79, 0x2d, 0xd3, 0x13, 0x42, 0x69, 0xf6,
+	0x84, 0xf0, 0x0b, 0x03, 0x2c, 0x35, 0x1d, 0x9f, 0x91, 0xfe, 0x17, 0x10, 0x1d, 0xa8, 0xe9, 0x17,
+	0x29, 0xbd, 0xb3, 0xd3, 0xe1, 0xdb, 0x11, 0xfc, 0x5a, 0xdb, 0x80, 0x87, 0xfe, 0xf4, 0x21, 0x7b,
+	0xfe, 0xa5, 0x31, 0x35, 0x52, 0x3f, 0x64, 0xef, 0x40, 0x15, 0x9f, 0x9e, 0xd2, 0x18, 0x91, 0x9c,
+	0x20, 0xc6, 0x84, 0x6a, 0x09, 0x25, 0x8b, 0xaa, 0xd3, 0xcb, 0x47, 0x5e, 0x16, 0x6d, 0xa0, 0x5a,
+	0xc2, 0x3e, 0x86, 0x0d, 0x45, 0x7c, 0xca, 0xe5, 0xa3, 0x58, 0xa5, 0xe6, 0x4a, 0x3a, 0xe9, 0xaf,
+	0x0c, 0xd8, 0xcc, 0xaf, 0xba, 0xea, 0x33, 0xe6, 0x3d, 0x30, 0xd5, 0x6d, 0x63, 0xe1, 0x5d, 0x3f,
+	0x75, 0x2b, 0x45, 0xb6, 0xfd, 0x13, 0xb8, 0x35, 0xb5, 0xe3, 0x38, 0x09, 0x5c, 0x11, 0x84, 0x97,
+	0xa7, 0x81, 0xfd, 0x27, 0x03, 0x3a, 0x8b, 0x2a, 0x56, 0x0d, 0x77, 0xf1, 0x3f, 0xbe, 0xd4, 0x01,
+	0xe6, 0x7f, 0x77, 0xc0, 0x8f, 0x80, 0x1c, 0x07, 0x9e, 0x2b, 0x93, 0x3f, 0xd1, 0x8a, 0xb6, 0x01,
+	0xb5, 0x42, 0xae, 0x0d, 0x28, 0x82, 0x2a, 0x95, 0xbf, 0x33, 0x60, 0x23, 0xb7, 0x7e, 0x71, 0xe0,
+	0x36, 0x98, 0x1e, 0x3f, 0x93, 0xfa, 0x1e, 0xd4, 0xca, 0xff, 0xfb, 0x47, 0x91, 0x47, 0x3e, 0x86,
+	0x4a, 0xe8, 0xf6, 0x07, 0x52, 0x87, 0x7d, 0x5e, 0x28, 0x61, 0xee, 0x7c, 0x13, 0x20, 0xfb, 0x23,
+	0x8f, 0x00, 0x54, 0x7f, 0x20, 0xc2, 0x11, 0xf3, 0xda, 0x37, 0x48, 0x0d, 0xca, 0x07, 0xe2, 0xbc,
+	0x6d, 0x10, 0x0b, 0xcc, 0xcf, 0xdd, 0xfe, 0xa0, 0x5d, 0xda, 0xd9, 0x82, 0x56, 0xfe, 0xdf, 0x3b,
+	0x52, 0x85, 0xd2, 0xf1, 0xb3, 0xf6, 0x0d, 0xf5, 0x4b, 0xf7, 0xdb, 0xc6, 0xce, 0x2e, 0x94, 0x5e,
+	0x04, 0x6a, 0xea, 0xd1, 0x58, 0x26, 0x6b, 0x3c, 0xe6, 0x5e, 0xb2, 0x86, 0xda, 0x9f, 0xed, 0x12,
+	0x69, 0x82, 0x95, 0xbe, 0xa3, 0xb5, 0xcb, 0x8f, 0x76, 0xfe, 0xf1, 0xe6, 0x8e, 0xf1, 0xcf, 0x37,
+	0x77, 0x8c, 0x7f, 0xbd, 0xb9, 0x63, 0xfc, 0xf1, 0xdf, 0x77, 0x6e, 0x40, 0xc7, 0x11, 0xa3, 0xdd,
+	0xc0, 0xf5, 0xfb, 0x0e, 0x0b, 0x76, 0xa5, 0x3b, 0x9c, 0xec, 0x0e, 0x27, 0xf8, 0x6f, 0xf0, 0x69,
+	0x15, 0x7f, 0x3e, 0xf9, 0x4f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xe2, 0x8f, 0x9a, 0x77, 0x61, 0x1e,
+	0x00, 0x00,
 }
diff --git a/vendor/github.com/pingcap/kvproto/pkg/metapb/metapb.pb.go b/vendor/github.com/pingcap/kvproto/pkg/metapb/metapb.pb.go
index 72d3eb96eaec3..3da13857558b5 100644
--- a/vendor/github.com/pingcap/kvproto/pkg/metapb/metapb.pb.go
+++ b/vendor/github.com/pingcap/kvproto/pkg/metapb/metapb.pb.go
@@ -1439,33 +1439,34 @@ var (
 func init() { proto.RegisterFile("metapb.proto", fileDescriptorMetapb) }
 
 var fileDescriptorMetapb = []byte{
-	// 445 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x64, 0x52, 0xdd, 0x8a, 0xd3, 0x40,
-	0x14, 0xde, 0xb4, 0x4d, 0xb2, 0x3d, 0xcd, 0x96, 0x32, 0x2e, 0x18, 0x15, 0x96, 0x25, 0x78, 0x51,
-	0x7a, 0x11, 0x7f, 0xf1, 0x56, 0xd8, 0xc5, 0x0b, 0x51, 0x50, 0x66, 0xd5, 0xdb, 0x90, 0x9f, 0x69,
-	0x0c, 0x4d, 0x32, 0x61, 0x66, 0x1a, 0xf4, 0x09, 0x7c, 0x05, 0x9f, 0xc1, 0x27, 0xf1, 0xd2, 0x47,
-	0x10, 0x7d, 0x11, 0xcf, 0x9c, 0xa4, 0xb0, 0xd8, 0x8b, 0xa1, 0xf3, 0x7d, 0xdf, 0x39, 0xa7, 0xdf,
-	0x77, 0x26, 0x10, 0x34, 0xc2, 0xa4, 0x5d, 0x16, 0x77, 0x4a, 0x1a, 0xc9, 0xbc, 0x01, 0xdd, 0x3f,
-	0x2f, 0x65, 0x29, 0x89, 0x7a, 0x64, 0x6f, 0x83, 0x1a, 0xbd, 0x04, 0xff, 0xba, 0xde, 0x6b, 0x23,
-	0x14, 0x5b, 0xc2, 0xa4, 0x2a, 0x42, 0xe7, 0xd2, 0x59, 0xcf, 0x38, 0xde, 0xd8, 0x43, 0x58, 0x36,
-	0xe9, 0x97, 0xa4, 0x13, 0x42, 0x25, 0xb9, 0xdc, 0xb7, 0x26, 0x9c, 0xa0, 0x76, 0xc6, 0x03, 0x64,
-	0xdf, 0x23, 0x79, 0x6d, 0xb9, 0xe8, 0x39, 0xc0, 0x8d, 0x91, 0x4a, 0xbc, 0x4d, 0x33, 0x51, 0xb3,
-	0x15, 0x4c, 0x77, 0xe2, 0x2b, 0x0d, 0x99, 0x73, 0x7b, 0x65, 0xe7, 0xe0, 0xf6, 0x69, 0xbd, 0x17,
-	0xd4, 0x3c, 0xe7, 0x03, 0x88, 0xbe, 0x39, 0xe0, 0x52, 0xdb, 0xd1, 0xbf, 0x86, 0xe0, 0xa7, 0x45,
-	0xa1, 0x84, 0xd6, 0x63, 0xc7, 0x01, 0xb2, 0x35, 0xb8, 0xda, 0xa4, 0x46, 0x84, 0x53, 0xe4, 0x97,
-	0x4f, 0x59, 0x3c, 0xc6, 0xa4, 0x39, 0x37, 0x56, 0xe1, 0x43, 0x01, 0xdb, 0x80, 0x57, 0x5b, 0x3b,
-	0x3a, 0x9c, 0x5d, 0x4e, 0xd7, 0x8b, 0xff, 0x4a, 0xc9, 0x29, 0x1f, 0x2b, 0xa2, 0x2b, 0x58, 0x70,
-	0x51, 0x56, 0xb2, 0x7d, 0xd5, 0xc9, 0xfc, 0x33, 0xbb, 0x07, 0xa7, 0xb9, 0x6c, 0xb7, 0x49, 0x2f,
-	0xd4, 0x68, 0xca, 0xb7, 0xf8, 0x13, 0xee, 0x07, 0x9d, 0x21, 0xab, 0xb1, 0x94, 0x9c, 0xa1, 0x32,
-	0xc2, 0xe8, 0x87, 0x03, 0xde, 0x30, 0xe4, 0x28, 0xce, 0x03, 0x98, 0xa3, 0x27, 0x65, 0x12, 0xbb,
-	0x16, 0xdb, 0x16, 0xf0, 0x53, 0x22, 0xde, 0xe0, 0x6e, 0xee, 0x82, 0x2f, 0xda, 0x82, 0xa4, 0x29,
-	0x49, 0x1e, 0x42, 0x2b, 0xbc, 0x80, 0x40, 0xd1, 0xbc, 0x44, 0x58, 0x57, 0x18, 0xc3, 0xc1, 0x18,
-	0x77, 0x0e, 0x31, 0x6e, 0x19, 0xe6, 0x0b, 0x75, 0xcb, 0x7d, 0x04, 0xae, 0x7d, 0x2e, 0x1d, 0xba,
-	0x94, 0x3b, 0x38, 0x34, 0xd8, 0xe7, 0xe2, 0x83, 0x14, 0x3d, 0x81, 0x99, 0x85, 0x47, 0x4e, 0x31,
-	0xb9, 0xb6, 0xeb, 0x49, 0x90, 0x1d, 0xf3, 0x11, 0x7e, 0x5d, 0x6c, 0x1e, 0x8f, 0x6f, 0x4c, 0x4b,
-	0x66, 0x1e, 0x4c, 0x3e, 0x76, 0xab, 0x13, 0xb6, 0x00, 0xff, 0xdd, 0x76, 0x5b, 0x57, 0xad, 0x58,
-	0x39, 0xec, 0x0c, 0xe6, 0x1f, 0x64, 0x93, 0x61, 0x07, 0xc2, 0xc9, 0xd5, 0xe6, 0xe7, 0x9f, 0x0b,
-	0xe7, 0x17, 0x9e, 0xdf, 0x78, 0xbe, 0xff, 0xbd, 0x38, 0x81, 0x30, 0x97, 0x4d, 0xdc, 0x55, 0x6d,
-	0x99, 0xa7, 0x5d, 0x6c, 0xaa, 0x5d, 0x1f, 0xef, 0x7a, 0xfa, 0x04, 0x33, 0x8f, 0x7e, 0x9e, 0xfd,
-	0x0b, 0x00, 0x00, 0xff, 0xff, 0x50, 0x3f, 0x60, 0xb0, 0xb7, 0x02, 0x00, 0x00,
+	// 456 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x64, 0x52, 0x4d, 0x8e, 0xd3, 0x4c,
+	0x10, 0x9d, 0x4e, 0xfc, 0x93, 0x94, 0x3d, 0x51, 0xd4, 0xdf, 0x48, 0x9f, 0x07, 0xa4, 0xc8, 0xb2,
+	0x58, 0x58, 0x59, 0x18, 0x18, 0x10, 0x5b, 0xa4, 0x19, 0xb1, 0x40, 0x20, 0x81, 0x7a, 0x80, 0xad,
+	0xe5, 0xd8, 0x95, 0x60, 0xc5, 0x76, 0x5b, 0xdd, 0x1d, 0x6b, 0xe6, 0x04, 0x5c, 0x81, 0x33, 0x70,
+	0x12, 0x96, 0x1c, 0x01, 0x85, 0x8b, 0xa0, 0x6e, 0xdb, 0xd2, 0x88, 0xac, 0xd2, 0xaf, 0x5e, 0xbd,
+	0xca, 0x7b, 0x55, 0x06, 0xbf, 0x46, 0x95, 0xb5, 0x9b, 0xa4, 0x15, 0x5c, 0x71, 0xea, 0xf4, 0xe8,
+	0xd1, 0xc5, 0x8e, 0xef, 0xb8, 0x29, 0x3d, 0xd5, 0xaf, 0x9e, 0x8d, 0x5e, 0x83, 0x7b, 0x53, 0x1d,
+	0xa4, 0x42, 0x41, 0x17, 0x30, 0x29, 0x8b, 0x80, 0x84, 0x24, 0xb6, 0xd8, 0xa4, 0x2c, 0xe8, 0x13,
+	0x58, 0xd4, 0xd9, 0x5d, 0xda, 0x22, 0x8a, 0x34, 0xe7, 0x87, 0x46, 0x05, 0x93, 0x90, 0xc4, 0xe7,
+	0xcc, 0xaf, 0xb3, 0xbb, 0x8f, 0x88, 0xe2, 0x46, 0xd7, 0xa2, 0x97, 0x00, 0xb7, 0x8a, 0x0b, 0x7c,
+	0x9f, 0x6d, 0xb0, 0xa2, 0x4b, 0x98, 0xee, 0xf1, 0xde, 0x0c, 0x99, 0x33, 0xfd, 0xa4, 0x17, 0x60,
+	0x77, 0x59, 0x75, 0x40, 0x23, 0x9e, 0xb3, 0x1e, 0x44, 0xdf, 0x08, 0xd8, 0x46, 0x76, 0xf2, 0xaf,
+	0x01, 0xb8, 0x59, 0x51, 0x08, 0x94, 0x72, 0x50, 0x8c, 0x90, 0xc6, 0x60, 0x4b, 0x95, 0x29, 0x0c,
+	0xa6, 0x21, 0x89, 0x17, 0x57, 0x34, 0x19, 0x62, 0x9a, 0x39, 0xb7, 0x9a, 0x61, 0x7d, 0x03, 0x5d,
+	0x83, 0x53, 0x69, 0x3b, 0x32, 0xb0, 0xc2, 0x69, 0xec, 0xfd, 0xd3, 0x6a, 0x9c, 0xb2, 0xa1, 0x23,
+	0xba, 0x06, 0x8f, 0xe1, 0xae, 0xe4, 0xcd, 0x9b, 0x96, 0xe7, 0x5f, 0xe9, 0x25, 0xcc, 0x72, 0xde,
+	0x6c, 0xd3, 0x0e, 0xc5, 0x60, 0xca, 0xd5, 0xf8, 0x0b, 0x0a, 0xed, 0xac, 0x43, 0x21, 0x4b, 0xde,
+	0x18, 0x67, 0x16, 0x1b, 0x61, 0xf4, 0x83, 0x80, 0xd3, 0x0f, 0x39, 0x89, 0xf3, 0x18, 0xe6, 0x52,
+	0x65, 0x42, 0xa5, 0x7a, 0x2d, 0x5a, 0xe6, 0xb3, 0x99, 0x29, 0xbc, 0xc3, 0x7b, 0xfa, 0x3f, 0xb8,
+	0xd8, 0x14, 0x86, 0x9a, 0x1a, 0xca, 0xc1, 0xa6, 0xd0, 0xc4, 0x2b, 0xf0, 0x85, 0x99, 0x97, 0xa2,
+	0x76, 0x15, 0x58, 0x21, 0x89, 0xbd, 0xab, 0xff, 0xc6, 0x18, 0x0f, 0x0c, 0x33, 0x4f, 0x3c, 0x70,
+	0x1f, 0x81, 0xad, 0xcf, 0x25, 0x03, 0xdb, 0xe4, 0xf6, 0x47, 0x81, 0x3e, 0x17, 0xeb, 0xa9, 0xe8,
+	0x39, 0x58, 0x1a, 0x9e, 0x38, 0xbd, 0x84, 0x99, 0xd4, 0xeb, 0x49, 0xcb, 0x62, 0xcc, 0x67, 0xf0,
+	0xdb, 0x62, 0xfd, 0x6c, 0xb8, 0xb1, 0x59, 0x32, 0x75, 0x60, 0xf2, 0xb9, 0x5d, 0x9e, 0x51, 0x0f,
+	0xdc, 0x0f, 0xdb, 0x6d, 0x55, 0x36, 0xb8, 0x24, 0xf4, 0x1c, 0xe6, 0x9f, 0x78, 0xbd, 0x91, 0x8a,
+	0x37, 0xb8, 0x9c, 0x5c, 0xaf, 0x7f, 0x1e, 0x57, 0xe4, 0xd7, 0x71, 0x45, 0x7e, 0x1f, 0x57, 0xe4,
+	0xfb, 0x9f, 0xd5, 0x19, 0x04, 0x39, 0xaf, 0x93, 0xb6, 0x6c, 0x76, 0x79, 0xd6, 0x26, 0xaa, 0xdc,
+	0x77, 0xc9, 0xbe, 0x33, 0x9f, 0xe0, 0xc6, 0x31, 0x3f, 0x2f, 0xfe, 0x06, 0x00, 0x00, 0xff, 0xff,
+	0x50, 0x3f, 0x60, 0xb0, 0xb7, 0x02, 0x00, 0x00,
 }
diff --git a/vendor/github.com/pingcap/kvproto/pkg/pdpb/pdpb.pb.go b/vendor/github.com/pingcap/kvproto/pkg/pdpb/pdpb.pb.go
index 5fc41ce00c046..10c758ee88429 100644
--- a/vendor/github.com/pingcap/kvproto/pkg/pdpb/pdpb.pb.go
+++ b/vendor/github.com/pingcap/kvproto/pkg/pdpb/pdpb.pb.go
@@ -41,6 +41,8 @@
 		RegionHeartbeatRequest
 		ChangePeer
 		TransferLeader
+		Merge
+		SplitRegion
 		RegionHeartbeatResponse
 		AskSplitRequest
 		AskSplitResponse
@@ -947,6 +949,30 @@ func (m *TransferLeader) GetPeer() *metapb.Peer {
 	return nil
 }
 
+type Merge struct {
+	Target *metapb.Region `protobuf:"bytes,1,opt,name=target" json:"target,omitempty"`
+}
+
+func (m *Merge) Reset()                    { *m = Merge{} }
+func (m *Merge) String() string            { return proto.CompactTextString(m) }
+func (*Merge) ProtoMessage()               {}
+func (*Merge) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{32} }
+
+func (m *Merge) GetTarget() *metapb.Region {
+	if m != nil {
+		return m.Target
+	}
+	return nil
+}
+
+type SplitRegion struct {
+}
+
+func (m *SplitRegion) Reset()                    { *m = SplitRegion{} }
+func (m *SplitRegion) String() string            { return proto.CompactTextString(m) }
+func (*SplitRegion) ProtoMessage()               {}
+func (*SplitRegion) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{33} }
+
 type RegionHeartbeatResponse struct {
 	Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
 	// Notice, Pd only allows handling reported epoch >= current pd's.
@@ -971,12 +997,15 @@ type RegionHeartbeatResponse struct {
 	RegionEpoch *metapb.RegionEpoch `protobuf:"bytes,5,opt,name=region_epoch,json=regionEpoch" json:"region_epoch,omitempty"`
 	// Leader of the region at the moment of the corresponding request was made.
 	TargetPeer *metapb.Peer `protobuf:"bytes,6,opt,name=target_peer,json=targetPeer" json:"target_peer,omitempty"`
+	Merge      *Merge       `protobuf:"bytes,7,opt,name=merge" json:"merge,omitempty"`
+	// PD sends split_region to let TiKV split a region into two regions.
+	SplitRegion *SplitRegion `protobuf:"bytes,8,opt,name=split_region,json=splitRegion" json:"split_region,omitempty"`
 }
 
 func (m *RegionHeartbeatResponse) Reset()                    { *m = RegionHeartbeatResponse{} }
 func (m *RegionHeartbeatResponse) String() string            { return proto.CompactTextString(m) }
 func (*RegionHeartbeatResponse) ProtoMessage()               {}
-func (*RegionHeartbeatResponse) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{32} }
+func (*RegionHeartbeatResponse) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{34} }
 
 func (m *RegionHeartbeatResponse) GetHeader() *ResponseHeader {
 	if m != nil {
@@ -1020,6 +1049,20 @@ func (m *RegionHeartbeatResponse) GetTargetPeer() *metapb.Peer {
 	return nil
 }
 
+func (m *RegionHeartbeatResponse) GetMerge() *Merge {
+	if m != nil {
+		return m.Merge
+	}
+	return nil
+}
+
+func (m *RegionHeartbeatResponse) GetSplitRegion() *SplitRegion {
+	if m != nil {
+		return m.SplitRegion
+	}
+	return nil
+}
+
 type AskSplitRequest struct {
 	Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
 	Region *metapb.Region `protobuf:"bytes,2,opt,name=region" json:"region,omitempty"`
@@ -1028,7 +1071,7 @@ type AskSplitRequest struct {
 func (m *AskSplitRequest) Reset()                    { *m = AskSplitRequest{} }
 func (m *AskSplitRequest) String() string            { return proto.CompactTextString(m) }
 func (*AskSplitRequest) ProtoMessage()               {}
-func (*AskSplitRequest) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{33} }
+func (*AskSplitRequest) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{35} }
 
 func (m *AskSplitRequest) GetHeader() *RequestHeader {
 	if m != nil {
@@ -1057,7 +1100,7 @@ type AskSplitResponse struct {
 func (m *AskSplitResponse) Reset()                    { *m = AskSplitResponse{} }
 func (m *AskSplitResponse) String() string            { return proto.CompactTextString(m) }
 func (*AskSplitResponse) ProtoMessage()               {}
-func (*AskSplitResponse) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{34} }
+func (*AskSplitResponse) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{36} }
 
 func (m *AskSplitResponse) GetHeader() *ResponseHeader {
 	if m != nil {
@@ -1089,7 +1132,7 @@ type ReportSplitRequest struct {
 func (m *ReportSplitRequest) Reset()                    { *m = ReportSplitRequest{} }
 func (m *ReportSplitRequest) String() string            { return proto.CompactTextString(m) }
 func (*ReportSplitRequest) ProtoMessage()               {}
-func (*ReportSplitRequest) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{35} }
+func (*ReportSplitRequest) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{37} }
 
 func (m *ReportSplitRequest) GetHeader() *RequestHeader {
 	if m != nil {
@@ -1119,7 +1162,7 @@ type ReportSplitResponse struct {
 func (m *ReportSplitResponse) Reset()                    { *m = ReportSplitResponse{} }
 func (m *ReportSplitResponse) String() string            { return proto.CompactTextString(m) }
 func (*ReportSplitResponse) ProtoMessage()               {}
-func (*ReportSplitResponse) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{36} }
+func (*ReportSplitResponse) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{38} }
 
 func (m *ReportSplitResponse) GetHeader() *ResponseHeader {
 	if m != nil {
@@ -1161,7 +1204,7 @@ type StoreStats struct {
 func (m *StoreStats) Reset()                    { *m = StoreStats{} }
 func (m *StoreStats) String() string            { return proto.CompactTextString(m) }
 func (*StoreStats) ProtoMessage()               {}
-func (*StoreStats) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{37} }
+func (*StoreStats) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{39} }
 
 func (m *StoreStats) GetStoreId() uint64 {
 	if m != nil {
@@ -1269,7 +1312,7 @@ type StoreHeartbeatRequest struct {
 func (m *StoreHeartbeatRequest) Reset()                    { *m = StoreHeartbeatRequest{} }
 func (m *StoreHeartbeatRequest) String() string            { return proto.CompactTextString(m) }
 func (*StoreHeartbeatRequest) ProtoMessage()               {}
-func (*StoreHeartbeatRequest) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{38} }
+func (*StoreHeartbeatRequest) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{40} }
 
 func (m *StoreHeartbeatRequest) GetHeader() *RequestHeader {
 	if m != nil {
@@ -1292,7 +1335,7 @@ type StoreHeartbeatResponse struct {
 func (m *StoreHeartbeatResponse) Reset()                    { *m = StoreHeartbeatResponse{} }
 func (m *StoreHeartbeatResponse) String() string            { return proto.CompactTextString(m) }
 func (*StoreHeartbeatResponse) ProtoMessage()               {}
-func (*StoreHeartbeatResponse) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{39} }
+func (*StoreHeartbeatResponse) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{41} }
 
 func (m *StoreHeartbeatResponse) GetHeader() *ResponseHeader {
 	if m != nil {
@@ -1313,7 +1356,7 @@ type ScatterRegionRequest struct {
 func (m *ScatterRegionRequest) Reset()                    { *m = ScatterRegionRequest{} }
 func (m *ScatterRegionRequest) String() string            { return proto.CompactTextString(m) }
 func (*ScatterRegionRequest) ProtoMessage()               {}
-func (*ScatterRegionRequest) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{40} }
+func (*ScatterRegionRequest) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{42} }
 
 func (m *ScatterRegionRequest) GetHeader() *RequestHeader {
 	if m != nil {
@@ -1350,7 +1393,7 @@ type ScatterRegionResponse struct {
 func (m *ScatterRegionResponse) Reset()                    { *m = ScatterRegionResponse{} }
 func (m *ScatterRegionResponse) String() string            { return proto.CompactTextString(m) }
 func (*ScatterRegionResponse) ProtoMessage()               {}
-func (*ScatterRegionResponse) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{41} }
+func (*ScatterRegionResponse) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{43} }
 
 func (m *ScatterRegionResponse) GetHeader() *ResponseHeader {
 	if m != nil {
@@ -1392,6 +1435,8 @@ func init() {
 	proto.RegisterType((*RegionHeartbeatRequest)(nil), "pdpb.RegionHeartbeatRequest")
 	proto.RegisterType((*ChangePeer)(nil), "pdpb.ChangePeer")
 	proto.RegisterType((*TransferLeader)(nil), "pdpb.TransferLeader")
+	proto.RegisterType((*Merge)(nil), "pdpb.Merge")
+	proto.RegisterType((*SplitRegion)(nil), "pdpb.SplitRegion")
 	proto.RegisterType((*RegionHeartbeatResponse)(nil), "pdpb.RegionHeartbeatResponse")
 	proto.RegisterType((*AskSplitRequest)(nil), "pdpb.AskSplitRequest")
 	proto.RegisterType((*AskSplitResponse)(nil), "pdpb.AskSplitResponse")
@@ -3266,6 +3311,52 @@ func (m *TransferLeader) MarshalTo(dAtA []byte) (int, error) {
 	return i, nil
 }
 
+func (m *Merge) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *Merge) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if m.Target != nil {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintPdpb(dAtA, i, uint64(m.Target.Size()))
+		n42, err := m.Target.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n42
+	}
+	return i, nil
+}
+
+func (m *SplitRegion) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *SplitRegion) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	return i, nil
+}
+
 func (m *RegionHeartbeatResponse) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
@@ -3285,31 +3376,31 @@ func (m *RegionHeartbeatResponse) MarshalTo(dAtA []byte) (int, error) {
 		dAtA[i] = 0xa
 		i++
 		i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size()))
-		n42, err := m.Header.MarshalTo(dAtA[i:])
+		n43, err := m.Header.MarshalTo(dAtA[i:])
 		if err != nil {
 			return 0, err
 		}
-		i += n42
+		i += n43
 	}
 	if m.ChangePeer != nil {
 		dAtA[i] = 0x12
 		i++
 		i = encodeVarintPdpb(dAtA, i, uint64(m.ChangePeer.Size()))
-		n43, err := m.ChangePeer.MarshalTo(dAtA[i:])
+		n44, err := m.ChangePeer.MarshalTo(dAtA[i:])
 		if err != nil {
 			return 0, err
 		}
-		i += n43
+		i += n44
 	}
 	if m.TransferLeader != nil {
 		dAtA[i] = 0x1a
 		i++
 		i = encodeVarintPdpb(dAtA, i, uint64(m.TransferLeader.Size()))
-		n44, err := m.TransferLeader.MarshalTo(dAtA[i:])
+		n45, err := m.TransferLeader.MarshalTo(dAtA[i:])
 		if err != nil {
 			return 0, err
 		}
-		i += n44
+		i += n45
 	}
 	if m.RegionId != 0 {
 		dAtA[i] = 0x20
@@ -3320,21 +3411,41 @@ func (m *RegionHeartbeatResponse) MarshalTo(dAtA []byte) (int, error) {
 		dAtA[i] = 0x2a
 		i++
 		i = encodeVarintPdpb(dAtA, i, uint64(m.RegionEpoch.Size()))
-		n45, err := m.RegionEpoch.MarshalTo(dAtA[i:])
+		n46, err := m.RegionEpoch.MarshalTo(dAtA[i:])
 		if err != nil {
 			return 0, err
 		}
-		i += n45
+		i += n46
 	}
 	if m.TargetPeer != nil {
 		dAtA[i] = 0x32
 		i++
 		i = encodeVarintPdpb(dAtA, i, uint64(m.TargetPeer.Size()))
-		n46, err := m.TargetPeer.MarshalTo(dAtA[i:])
+		n47, err := m.TargetPeer.MarshalTo(dAtA[i:])
 		if err != nil {
 			return 0, err
 		}
-		i += n46
+		i += n47
+	}
+	if m.Merge != nil {
+		dAtA[i] = 0x3a
+		i++
+		i = encodeVarintPdpb(dAtA, i, uint64(m.Merge.Size()))
+		n48, err := m.Merge.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n48
+	}
+	if m.SplitRegion != nil {
+		dAtA[i] = 0x42
+		i++
+		i = encodeVarintPdpb(dAtA, i, uint64(m.SplitRegion.Size()))
+		n49, err := m.SplitRegion.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n49
 	}
 	return i, nil
 }
@@ -3358,21 +3469,21 @@ func (m *AskSplitRequest) MarshalTo(dAtA []byte) (int, error) {
 		dAtA[i] = 0xa
 		i++
 		i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size()))
-		n47, err := m.Header.MarshalTo(dAtA[i:])
+		n50, err := m.Header.MarshalTo(dAtA[i:])
 		if err != nil {
 			return 0, err
 		}
-		i += n47
+		i += n50
 	}
 	if m.Region != nil {
 		dAtA[i] = 0x12
 		i++
 		i = encodeVarintPdpb(dAtA, i, uint64(m.Region.Size()))
-		n48, err := m.Region.MarshalTo(dAtA[i:])
+		n51, err := m.Region.MarshalTo(dAtA[i:])
 		if err != nil {
 			return 0, err
 		}
-		i += n48
+		i += n51
 	}
 	return i, nil
 }
@@ -3396,11 +3507,11 @@ func (m *AskSplitResponse) MarshalTo(dAtA []byte) (int, error) {
 		dAtA[i] = 0xa
 		i++
 		i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size()))
-		n49, err := m.Header.MarshalTo(dAtA[i:])
+		n52, err := m.Header.MarshalTo(dAtA[i:])
 		if err != nil {
 			return 0, err
 		}
-		i += n49
+		i += n52
 	}
 	if m.NewRegionId != 0 {
 		dAtA[i] = 0x10
@@ -3408,21 +3519,21 @@ func (m *AskSplitResponse) MarshalTo(dAtA []byte) (int, error) {
 		i = encodeVarintPdpb(dAtA, i, uint64(m.NewRegionId))
 	}
 	if len(m.NewPeerIds) > 0 {
-		dAtA51 := make([]byte, len(m.NewPeerIds)*10)
-		var j50 int
+		dAtA54 := make([]byte, len(m.NewPeerIds)*10)
+		var j53 int
 		for _, num := range m.NewPeerIds {
 			for num >= 1<<7 {
-				dAtA51[j50] = uint8(uint64(num)&0x7f | 0x80)
+				dAtA54[j53] = uint8(uint64(num)&0x7f | 0x80)
 				num >>= 7
-				j50++
+				j53++
 			}
-			dAtA51[j50] = uint8(num)
-			j50++
+			dAtA54[j53] = uint8(num)
+			j53++
 		}
 		dAtA[i] = 0x1a
 		i++
-		i = encodeVarintPdpb(dAtA, i, uint64(j50))
-		i += copy(dAtA[i:], dAtA51[:j50])
+		i = encodeVarintPdpb(dAtA, i, uint64(j53))
+		i += copy(dAtA[i:], dAtA54[:j53])
 	}
 	return i, nil
 }
@@ -3446,31 +3557,31 @@ func (m *ReportSplitRequest) MarshalTo(dAtA []byte) (int, error) {
 		dAtA[i] = 0xa
 		i++
 		i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size()))
-		n52, err := m.Header.MarshalTo(dAtA[i:])
+		n55, err := m.Header.MarshalTo(dAtA[i:])
 		if err != nil {
 			return 0, err
 		}
-		i += n52
+		i += n55
 	}
 	if m.Left != nil {
 		dAtA[i] = 0x12
 		i++
 		i = encodeVarintPdpb(dAtA, i, uint64(m.Left.Size()))
-		n53, err := m.Left.MarshalTo(dAtA[i:])
+		n56, err := m.Left.MarshalTo(dAtA[i:])
 		if err != nil {
 			return 0, err
 		}
-		i += n53
+		i += n56
 	}
 	if m.Right != nil {
 		dAtA[i] = 0x1a
 		i++
 		i = encodeVarintPdpb(dAtA, i, uint64(m.Right.Size()))
-		n54, err := m.Right.MarshalTo(dAtA[i:])
+		n57, err := m.Right.MarshalTo(dAtA[i:])
 		if err != nil {
 			return 0, err
 		}
-		i += n54
+		i += n57
 	}
 	return i, nil
 }
@@ -3494,11 +3605,11 @@ func (m *ReportSplitResponse) MarshalTo(dAtA []byte) (int, error) {
 		dAtA[i] = 0xa
 		i++
 		i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size()))
-		n55, err := m.Header.MarshalTo(dAtA[i:])
+		n58, err := m.Header.MarshalTo(dAtA[i:])
 		if err != nil {
 			return 0, err
 		}
-		i += n55
+		i += n58
 	}
 	return i, nil
 }
@@ -3615,21 +3726,21 @@ func (m *StoreHeartbeatRequest) MarshalTo(dAtA []byte) (int, error) {
 		dAtA[i] = 0xa
 		i++
 		i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size()))
-		n56, err := m.Header.MarshalTo(dAtA[i:])
+		n59, err := m.Header.MarshalTo(dAtA[i:])
 		if err != nil {
 			return 0, err
 		}
-		i += n56
+		i += n59
 	}
 	if m.Stats != nil {
 		dAtA[i] = 0x12
 		i++
 		i = encodeVarintPdpb(dAtA, i, uint64(m.Stats.Size()))
-		n57, err := m.Stats.MarshalTo(dAtA[i:])
+		n60, err := m.Stats.MarshalTo(dAtA[i:])
 		if err != nil {
 			return 0, err
 		}
-		i += n57
+		i += n60
 	}
 	return i, nil
 }
@@ -3653,11 +3764,11 @@ func (m *StoreHeartbeatResponse) MarshalTo(dAtA []byte) (int, error) {
 		dAtA[i] = 0xa
 		i++
 		i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size()))
-		n58, err := m.Header.MarshalTo(dAtA[i:])
+		n61, err := m.Header.MarshalTo(dAtA[i:])
 		if err != nil {
 			return 0, err
 		}
-		i += n58
+		i += n61
 	}
 	return i, nil
 }
@@ -3681,11 +3792,11 @@ func (m *ScatterRegionRequest) MarshalTo(dAtA []byte) (int, error) {
 		dAtA[i] = 0xa
 		i++
 		i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size()))
-		n59, err := m.Header.MarshalTo(dAtA[i:])
+		n62, err := m.Header.MarshalTo(dAtA[i:])
 		if err != nil {
 			return 0, err
 		}
-		i += n59
+		i += n62
 	}
 	if m.RegionId != 0 {
 		dAtA[i] = 0x10
@@ -3696,21 +3807,21 @@ func (m *ScatterRegionRequest) MarshalTo(dAtA []byte) (int, error) {
 		dAtA[i] = 0x1a
 		i++
 		i = encodeVarintPdpb(dAtA, i, uint64(m.Region.Size()))
-		n60, err := m.Region.MarshalTo(dAtA[i:])
+		n63, err := m.Region.MarshalTo(dAtA[i:])
 		if err != nil {
 			return 0, err
 		}
-		i += n60
+		i += n63
 	}
 	if m.Leader != nil {
 		dAtA[i] = 0x22
 		i++
 		i = encodeVarintPdpb(dAtA, i, uint64(m.Leader.Size()))
-		n61, err := m.Leader.MarshalTo(dAtA[i:])
+		n64, err := m.Leader.MarshalTo(dAtA[i:])
 		if err != nil {
 			return 0, err
 		}
-		i += n61
+		i += n64
 	}
 	return i, nil
 }
@@ -3734,11 +3845,11 @@ func (m *ScatterRegionResponse) MarshalTo(dAtA []byte) (int, error) {
 		dAtA[i] = 0xa
 		i++
 		i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size()))
-		n62, err := m.Header.MarshalTo(dAtA[i:])
+		n65, err := m.Header.MarshalTo(dAtA[i:])
 		if err != nil {
 			return 0, err
 		}
-		i += n62
+		i += n65
 	}
 	return i, nil
 }
@@ -4237,6 +4348,22 @@ func (m *TransferLeader) Size() (n int) {
 	return n
 }
 
+func (m *Merge) Size() (n int) {
+	var l int
+	_ = l
+	if m.Target != nil {
+		l = m.Target.Size()
+		n += 1 + l + sovPdpb(uint64(l))
+	}
+	return n
+}
+
+func (m *SplitRegion) Size() (n int) {
+	var l int
+	_ = l
+	return n
+}
+
 func (m *RegionHeartbeatResponse) Size() (n int) {
 	var l int
 	_ = l
@@ -4263,6 +4390,14 @@ func (m *RegionHeartbeatResponse) Size() (n int) {
 		l = m.TargetPeer.Size()
 		n += 1 + l + sovPdpb(uint64(l))
 	}
+	if m.Merge != nil {
+		l = m.Merge.Size()
+		n += 1 + l + sovPdpb(uint64(l))
+	}
+	if m.SplitRegion != nil {
+		l = m.SplitRegion.Size()
+		n += 1 + l + sovPdpb(uint64(l))
+	}
 	return n
 }
 
@@ -8068,6 +8203,139 @@ func (m *TransferLeader) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
+func (m *Merge) 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 ErrIntOverflowPdpb
+			}
+			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: Merge: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: Merge: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Target", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowPdpb
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthPdpb
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Target == nil {
+				m.Target = &metapb.Region{}
+			}
+			if err := m.Target.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipPdpb(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthPdpb
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *SplitRegion) 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 ErrIntOverflowPdpb
+			}
+			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: SplitRegion: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: SplitRegion: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		default:
+			iNdEx = preIndex
+			skippy, err := skipPdpb(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthPdpb
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
 func (m *RegionHeartbeatResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
@@ -8281,6 +8549,72 @@ func (m *RegionHeartbeatResponse) Unmarshal(dAtA []byte) error {
 				return err
 			}
 			iNdEx = postIndex
+		case 7:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Merge", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowPdpb
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthPdpb
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Merge == nil {
+				m.Merge = &Merge{}
+			}
+			if err := m.Merge.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 8:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field SplitRegion", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowPdpb
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthPdpb
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.SplitRegion == nil {
+				m.SplitRegion = &SplitRegion{}
+			}
+			if err := m.SplitRegion.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipPdpb(dAtA[iNdEx:])
@@ -9689,123 +10023,127 @@ var (
 func init() { proto.RegisterFile("pdpb.proto", fileDescriptorPdpb) }
 
 var fileDescriptorPdpb = []byte{
-	// 1875 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xb4, 0x59, 0x4b, 0x73, 0x23, 0x49,
-	0x11, 0x1e, 0xbd, 0xa5, 0xd4, 0x73, 0xca, 0x1a, 0x4b, 0xd3, 0xf3, 0x60, 0xe8, 0xe1, 0xb1, 0xbb,
-	0x2c, 0x62, 0xd7, 0x44, 0x10, 0x1b, 0x41, 0x2c, 0x81, 0x5f, 0xb3, 0x6b, 0x66, 0xc7, 0x72, 0x94,
-	0xb4, 0xb1, 0xb1, 0x17, 0x9a, 0x96, 0x54, 0x96, 0x1b, 0x4b, 0xea, 0x9e, 0xee, 0xb2, 0x07, 0x71,
-	0xe2, 0xc4, 0x05, 0x22, 0xb8, 0x72, 0xe4, 0x4e, 0x04, 0xff, 0x80, 0xe0, 0xc0, 0x85, 0x23, 0x3f,
-	0x81, 0x80, 0x33, 0xff, 0x81, 0x7a, 0xf6, 0x4b, 0xb2, 0x31, 0x3d, 0xec, 0x41, 0xe1, 0xae, 0xcc,
-	0xac, 0xac, 0xcc, 0xac, 0xcc, 0xaf, 0xb2, 0xca, 0x00, 0xde, 0xcc, 0x9b, 0x0c, 0x3c, 0xdf, 0xa5,
-	0x2e, 0x2a, 0xf2, 0x6f, 0xa3, 0xb1, 0x24, 0xd4, 0xd6, 0x34, 0xa3, 0x49, 0x7c, 0xfb, 0x9c, 0x86,
-	0xc3, 0xee, 0xdc, 0x9d, 0xbb, 0xe2, 0xf3, 0x7b, 0xfc, 0x4b, 0x52, 0xcd, 0x01, 0x34, 0x31, 0x79,
-	0x7d, 0x45, 0x02, 0xfa, 0x29, 0xb1, 0x67, 0xc4, 0x47, 0x4f, 0x00, 0xa6, 0x8b, 0xab, 0x80, 0x12,
-	0xdf, 0x72, 0x66, 0xfd, 0xdc, 0xb3, 0xdc, 0x3b, 0x45, 0x5c, 0x53, 0x94, 0x93, 0x99, 0x89, 0xa1,
-	0x85, 0x49, 0xe0, 0xb9, 0xab, 0x80, 0xdc, 0x69, 0x02, 0xfa, 0x3a, 0x94, 0x88, 0xef, 0xbb, 0x7e,
-	0x3f, 0xcf, 0x38, 0xf5, 0xbd, 0xfa, 0x40, 0x58, 0x7d, 0xcc, 0x49, 0x58, 0x72, 0xcc, 0x17, 0x50,
-	0x12, 0x63, 0xf4, 0x1c, 0x8a, 0x74, 0xed, 0x11, 0xa1, 0xa4, 0xb5, 0xd7, 0x8e, 0x89, 0x8e, 0x19,
-	0x19, 0x0b, 0x26, 0xea, 0x43, 0x65, 0x49, 0x82, 0xc0, 0x9e, 0x13, 0xa1, 0xb2, 0x86, 0xf5, 0xd0,
-	0x1c, 0x02, 0x8c, 0x03, 0x57, 0xb9, 0x83, 0xbe, 0x03, 0xe5, 0x0b, 0x61, 0xa1, 0x50, 0x57, 0xdf,
-	0xdb, 0x91, 0xea, 0x12, 0xde, 0x62, 0x25, 0x82, 0xba, 0x50, 0x9a, 0xba, 0x57, 0x2b, 0x2a, 0x54,
-	0x36, 0xb1, 0x1c, 0x98, 0xfb, 0x50, 0x1b, 0x3b, 0x4c, 0x3b, 0xb5, 0x97, 0x1e, 0x32, 0xa0, 0xea,
-	0x5d, 0xac, 0x03, 0x67, 0x6a, 0x2f, 0x84, 0xc6, 0x02, 0x0e, 0xc7, 0xdc, 0xa6, 0x85, 0x3b, 0x17,
-	0xac, 0xbc, 0x60, 0xe9, 0xa1, 0xf9, 0xab, 0x1c, 0xd4, 0x85, 0x51, 0x32, 0x66, 0xe8, 0xfd, 0x94,
-	0x55, 0x5d, 0x6d, 0x55, 0x3c, 0xa6, 0xb7, 0x9b, 0x85, 0xbe, 0x0b, 0x35, 0xaa, 0xcd, 0xea, 0x17,
-	0x84, 0x1a, 0x15, 0xab, 0xd0, 0x5a, 0x1c, 0x49, 0x98, 0xbf, 0xcd, 0x41, 0xe7, 0xc0, 0x75, 0x69,
-	0x40, 0x7d, 0xdb, 0xcb, 0x14, 0x9d, 0xe7, 0x50, 0x0a, 0xa8, 0xeb, 0x13, 0xb5, 0x87, 0xcd, 0x81,
-	0xca, 0xb3, 0x11, 0x27, 0x62, 0xc9, 0x43, 0xdf, 0x82, 0xb2, 0x4f, 0xe6, 0x8e, 0xbb, 0x52, 0x26,
-	0xb5, 0xb4, 0x14, 0x16, 0x54, 0xac, 0xb8, 0x2c, 0xa8, 0xf7, 0x63, 0xd6, 0x64, 0x09, 0x8b, 0x79,
-	0x04, 0x0f, 0x4e, 0x82, 0x50, 0x89, 0x47, 0x66, 0x59, 0xbc, 0x32, 0x7f, 0x0e, 0xbb, 0x69, 0x2d,
-	0x99, 0x36, 0xc9, 0x84, 0xc6, 0x24, 0xa6, 0x45, 0x04, 0xa9, 0x8a, 0x13, 0x34, 0xf3, 0x63, 0x68,
-	0xed, 0x2f, 0x16, 0xee, 0xf4, 0xe4, 0x28, 0x93, 0xa9, 0x43, 0x68, 0x87, 0xd3, 0x33, 0xd9, 0xd8,
-	0x82, 0xbc, 0x23, 0x2d, 0x2b, 0x62, 0xf6, 0x65, 0x7e, 0x09, 0xed, 0x4f, 0x08, 0x95, 0xfb, 0x97,
-	0x25, 0x23, 0x1e, 0x42, 0x55, 0xec, 0xba, 0x15, 0x6a, 0xad, 0x88, 0x31, 0x43, 0x08, 0x02, 0x9d,
-	0x48, 0x75, 0x26, 0x63, 0xef, 0x92, 0x6e, 0xe6, 0x14, 0xda, 0x67, 0x57, 0x6f, 0xe1, 0xc1, 0x9d,
-	0x16, 0xf9, 0x31, 0x74, 0xa2, 0x45, 0x32, 0xa5, 0xea, 0x01, 0xec, 0xb0, 0x68, 0xb0, 0xcd, 0x13,
-	0x4a, 0x82, 0x4c, 0xbb, 0x7f, 0x09, 0xdd, 0xa4, 0x8e, 0x4c, 0x51, 0xfd, 0x26, 0x94, 0x85, 0x53,
-	0x01, 0xf3, 0xb8, 0xb0, 0xe9, 0xb1, 0x62, 0x9a, 0x3f, 0x15, 0xdb, 0xa7, 0x6a, 0x36, 0x4b, 0x60,
-	0xd9, 0x79, 0x20, 0x2b, 0xdd, 0xba, 0x24, 0x6b, 0x11, 0xdd, 0x06, 0xae, 0x49, 0xca, 0x4b, 0xb2,
-	0x36, 0x7f, 0x97, 0x83, 0xfb, 0xb1, 0x05, 0x32, 0xb9, 0x12, 0x41, 0x4d, 0xfe, 0x36, 0xa8, 0x41,
-	0xdf, 0x80, 0xf2, 0x42, 0x6a, 0x95, 0x90, 0xd4, 0xd0, 0x72, 0x67, 0x84, 0x6b, 0x93, 0x3c, 0xf3,
-	0x67, 0x22, 0xbc, 0x72, 0xea, 0xc1, 0x3a, 0x5b, 0x85, 0xa2, 0x47, 0xa0, 0x7c, 0x8c, 0x2a, 0xa2,
-	0x2a, 0x09, 0xac, 0x24, 0x5e, 0x40, 0x8f, 0xad, 0x70, 0x28, 0xcf, 0xc4, 0x43, 0x77, 0x75, 0xee,
-	0xcc, 0x33, 0x25, 0x42, 0x00, 0xfd, 0x4d, 0x3d, 0x99, 0x22, 0xf8, 0x2e, 0x54, 0xd4, 0x11, 0xad,
-	0x42, 0xd8, 0xd6, 0xa1, 0x51, 0xda, 0xb1, 0xe6, 0x9b, 0xaf, 0xa1, 0xc7, 0x6a, 0xe0, 0xad, 0x8d,
-	0xff, 0x5f, 0x96, 0xfc, 0x14, 0xfa, 0x9b, 0x4b, 0x66, 0x2a, 0xbf, 0x3f, 0xe4, 0xa0, 0xfc, 0x8a,
-	0x2c, 0x27, 0x6c, 0x7d, 0x04, 0xc5, 0x95, 0xbd, 0x94, 0xcd, 0x45, 0x0d, 0x8b, 0x6f, 0xbe, 0x6b,
-	0x4b, 0xc1, 0x8d, 0xed, 0x9a, 0x24, 0xb0, 0xce, 0x85, 0x31, 0x3d, 0x96, 0x27, 0xd6, 0x95, 0xbf,
-	0x08, 0x58, 0x02, 0x15, 0xd8, 0xac, 0x2a, 0x27, 0x7c, 0xce, 0xc6, 0xe8, 0x6b, 0x50, 0x9f, 0x2e,
-	0x1c, 0xb2, 0xa2, 0x92, 0x5d, 0x14, 0x6c, 0x90, 0x24, 0x21, 0xf0, 0x6d, 0x68, 0xcb, 0xfc, 0xb2,
-	0x3c, 0xdf, 0x71, 0x7d, 0x87, 0xae, 0xfb, 0x25, 0xb6, 0x40, 0x09, 0xb7, 0x24, 0xf9, 0x4c, 0x51,
-	0x19, 0xc6, 0xf0, 0x7a, 0x90, 0x46, 0x66, 0xc3, 0x87, 0xbf, 0xe4, 0x00, 0xc5, 0x55, 0x64, 0xac,
-	0xa9, 0x8a, 0xf4, 0x5c, 0xe3, 0x43, 0x43, 0x8a, 0x4b, 0xad, 0x58, 0x33, 0xb7, 0xd4, 0x54, 0x5c,
-	0x4c, 0xf1, 0x58, 0x8b, 0x52, 0x27, 0x74, 0x3a, 0xb3, 0x94, 0x68, 0x71, 0x8b, 0x28, 0x70, 0x81,
-	0xcf, 0xa4, 0x07, 0x67, 0x50, 0xe3, 0x25, 0x39, 0xa2, 0x36, 0x0d, 0xd0, 0x33, 0x28, 0xf2, 0x30,
-	0x2b, 0xab, 0x93, 0x35, 0x2b, 0x38, 0xac, 0xa7, 0x6c, 0xcc, 0xdc, 0x37, 0x2b, 0x2b, 0x20, 0x53,
-	0x77, 0x35, 0x0b, 0xd4, 0xce, 0xd5, 0x39, 0x6d, 0x24, 0x49, 0xe6, 0x5f, 0x0b, 0xb0, 0x2b, 0x4b,
-	0x9a, 0xf9, 0xe9, 0xd3, 0x09, 0xb1, 0x69, 0xa6, 0xac, 0xfd, 0xbf, 0x42, 0x0d, 0x1a, 0x00, 0x08,
-	0xc3, 0xb9, 0x17, 0x32, 0x69, 0xc2, 0xd6, 0x2d, 0xf4, 0x1f, 0xd7, 0xb8, 0x08, 0x1f, 0x06, 0xe8,
-	0x43, 0x68, 0x7a, 0x64, 0x35, 0x73, 0x56, 0x73, 0x35, 0xa5, 0xa4, 0xb6, 0x26, 0xae, 0xbc, 0xa1,
-	0x44, 0xe4, 0x94, 0xe7, 0xd0, 0x9c, 0xac, 0x29, 0x09, 0xac, 0x37, 0x2c, 0xbb, 0x28, 0x59, 0xf5,
-	0xcb, 0x22, 0x38, 0x0d, 0x41, 0xfc, 0x42, 0xd2, 0x38, 0x46, 0x4b, 0x21, 0x9f, 0xd9, 0xd5, 0xaf,
-	0xc8, 0x9e, 0x5d, 0x50, 0x30, 0x23, 0xf0, 0xf8, 0x32, 0xec, 0x8e, 0x54, 0x54, 0x65, 0x7c, 0x39,
-	0x4d, 0x6b, 0x60, 0xc5, 0x21, 0x44, 0x84, 0x82, 0x9a, 0xac, 0x1c, 0x4e, 0x10, 0xf3, 0xdf, 0x85,
-	0x0e, 0x6b, 0x7b, 0x7c, 0xf7, 0x17, 0xce, 0xd2, 0xa6, 0xc4, 0x0a, 0x9c, 0x5f, 0x92, 0x3e, 0x08,
-	0x99, 0x76, 0x8c, 0x3e, 0x62, 0x64, 0xf4, 0x38, 0xde, 0xcb, 0xd6, 0xa5, 0x21, 0x51, 0xeb, 0x7a,
-	0x01, 0x70, 0x78, 0x61, 0xaf, 0xe6, 0x84, 0xfb, 0x76, 0x87, 0xc4, 0xf8, 0x88, 0x55, 0xa5, 0x90,
-	0xb7, 0xc4, 0x3d, 0x22, 0x2f, 0xee, 0x11, 0xbd, 0x81, 0xbe, 0x08, 0x71, 0x28, 0x91, 0xfa, 0xc4,
-	0x7d, 0x02, 0xa6, 0xe1, 0xb7, 0xb9, 0x07, 0xad, 0xb1, 0x6f, 0xaf, 0x82, 0x73, 0xe2, 0xcb, 0x9c,
-	0xfc, 0xef, 0xab, 0x99, 0x7f, 0xce, 0x43, 0x6f, 0x23, 0xc7, 0x32, 0x15, 0xdf, 0x87, 0xa1, 0xdd,
-	0x62, 0x49, 0x99, 0x6a, 0x1d, 0x39, 0x25, 0x0a, 0x80, 0x36, 0x58, 0x04, 0xe3, 0x63, 0x68, 0x53,
-	0x65, 0xb0, 0x95, 0xc8, 0x3c, 0xb5, 0x52, 0xd2, 0x1b, 0xdc, 0xa2, 0x49, 0xef, 0x12, 0xe7, 0x55,
-	0x31, 0x79, 0x5e, 0xa1, 0x1f, 0x40, 0x43, 0x31, 0x89, 0xe7, 0x4e, 0x2f, 0x04, 0x70, 0xf1, 0x3a,
-	0x49, 0xa4, 0xfe, 0x31, 0x67, 0xe1, 0xba, 0x1f, 0x0d, 0x78, 0xd5, 0x53, 0xdb, 0x9f, 0x13, 0x2a,
-	0xdd, 0x28, 0x6f, 0x89, 0x1c, 0x48, 0x01, 0xfe, 0x6d, 0x9e, 0xb3, 0xae, 0x36, 0xb8, 0x1c, 0x79,
-	0x0b, 0xe7, 0x2b, 0xad, 0x4d, 0xf3, 0xd7, 0xec, 0x02, 0x14, 0x2d, 0x94, 0xb1, 0xc7, 0x6f, 0xae,
-	0xc8, 0x1b, 0x2b, 0x7d, 0xc4, 0xd7, 0x19, 0x11, 0xeb, 0xa8, 0x3d, 0x83, 0x06, 0x97, 0x11, 0x67,
-	0x86, 0x33, 0x93, 0x47, 0x46, 0x11, 0x03, 0xa3, 0x71, 0x6f, 0x4f, 0x18, 0x28, 0xfd, 0x86, 0x01,
-	0x35, 0x66, 0x21, 0xf5, 0x69, 0x76, 0xa7, 0x4d, 0x28, 0x2e, 0xc8, 0x39, 0xbd, 0xc1, 0x65, 0xc1,
-	0x63, 0x60, 0x54, 0xf2, 0x9d, 0xf9, 0x05, 0xbd, 0xe1, 0x26, 0x26, 0x99, 0xe6, 0x21, 0xec, 0x24,
-	0x8c, 0xc9, 0x74, 0xc0, 0xfe, 0xbb, 0x00, 0x20, 0x1a, 0x48, 0x89, 0xdd, 0xf1, 0x7b, 0x41, 0x2e,
-	0x71, 0x2f, 0xe0, 0xf7, 0xe7, 0xa9, 0xed, 0xd9, 0x53, 0x7e, 0x12, 0xaa, 0xa3, 0x56, 0x8f, 0x39,
-	0x0a, 0xd8, 0xd7, 0xb6, 0xb3, 0xb0, 0x27, 0x0b, 0x22, 0x8c, 0x66, 0x28, 0x10, 0x12, 0x38, 0x1c,
-	0xa9, 0xc0, 0xcb, 0xcb, 0x70, 0x51, 0x5c, 0x86, 0x55, 0xe6, 0x1d, 0x8a, 0x2b, 0xf1, 0xfb, 0x80,
-	0x02, 0x05, 0x94, 0xc1, 0xca, 0xf6, 0x94, 0x60, 0x49, 0x08, 0x76, 0x14, 0x67, 0xc4, 0x18, 0x52,
-	0xfa, 0x03, 0xe8, 0xfa, 0x64, 0x4a, 0x9c, 0xeb, 0x94, 0x7c, 0x59, 0xc8, 0xa3, 0x90, 0x17, 0xcd,
-	0x60, 0x80, 0xc9, 0x10, 0xc9, 0xa7, 0x16, 0xc7, 0x26, 0x01, 0x98, 0x4d, 0x5c, 0x13, 0x14, 0x7e,
-	0xe5, 0x66, 0xb8, 0xbe, 0xc3, 0x80, 0x6d, 0xb1, 0x4e, 0xe9, 0xab, 0x0a, 0xb9, 0xfb, 0x9a, 0x15,
-	0xa9, 0xeb, 0x41, 0xc5, 0x09, 0xac, 0xc9, 0x55, 0xb0, 0x16, 0xd8, 0x59, 0xc5, 0x65, 0x27, 0x38,
-	0x60, 0x23, 0x5e, 0x96, 0x57, 0x01, 0x99, 0xc5, 0x21, 0xb3, 0xca, 0x09, 0x02, 0x2b, 0x37, 0xa0,
-	0xbd, 0xbe, 0x05, 0xda, 0xd3, 0xd8, 0xdd, 0xd8, 0xc4, 0xee, 0x24, 0xfa, 0x37, 0xd3, 0xe8, 0x9f,
-	0x80, 0xf6, 0x56, 0x12, 0xda, 0xcd, 0x05, 0x3c, 0x10, 0xdb, 0xfd, 0xb6, 0xa7, 0x2a, 0xbb, 0x60,
-	0xb1, 0x7c, 0x49, 0x22, 0x5d, 0x94, 0x47, 0x58, 0xb2, 0x59, 0xe3, 0xbc, 0x9b, 0x5e, 0x2d, 0x53,
-	0x96, 0xfe, 0x29, 0x07, 0xdd, 0xd1, 0xd4, 0xa6, 0xbc, 0xcb, 0xcc, 0x7e, 0xb3, 0xb9, 0xad, 0xc7,
-	0xbf, 0xeb, 0xf3, 0x47, 0xac, 0x51, 0x28, 0xde, 0x72, 0x27, 0x39, 0x66, 0x61, 0x4e, 0xda, 0x9b,
-	0xc5, 0xef, 0xf7, 0x08, 0xd4, 0xc2, 0xe7, 0x33, 0x54, 0x86, 0xfc, 0xf0, 0x65, 0xe7, 0x1e, 0xaa,
-	0x43, 0xe5, 0xf3, 0xd3, 0x97, 0xa7, 0xc3, 0x2f, 0x4e, 0x3b, 0x39, 0xd4, 0x85, 0xce, 0xe9, 0x70,
-	0x6c, 0x1d, 0x0c, 0x87, 0xe3, 0xd1, 0x18, 0xef, 0x9f, 0x9d, 0x1d, 0x1f, 0x75, 0xf2, 0x68, 0x07,
-	0xda, 0xa3, 0xf1, 0x10, 0x1f, 0x5b, 0xe3, 0xe1, 0xab, 0x03, 0xf6, 0x75, 0x7a, 0xdc, 0x29, 0xa0,
-	0x3e, 0x74, 0xf7, 0x3f, 0xc3, 0xc7, 0xfb, 0x47, 0x5f, 0x26, 0xc5, 0x8b, 0x7b, 0x7f, 0xac, 0x41,
-	0xfe, 0xec, 0x08, 0xed, 0x03, 0x44, 0x6d, 0x28, 0xea, 0x49, 0xcb, 0x36, 0x7a, 0x5b, 0xa3, 0xbf,
-	0xc9, 0x90, 0xc6, 0x9b, 0xf7, 0x58, 0x65, 0x16, 0xc6, 0x81, 0x8b, 0x54, 0x42, 0x44, 0xaf, 0x79,
-	0xc6, 0xfd, 0x18, 0x45, 0x4b, 0xbf, 0x93, 0xfb, 0x20, 0x87, 0x7e, 0x04, 0xb5, 0xf0, 0x0d, 0x07,
-	0xed, 0x4a, 0xa9, 0xf4, 0x6b, 0x97, 0xd1, 0xdb, 0xa0, 0x87, 0x2b, 0xbe, 0x82, 0x56, 0xf2, 0x15,
-	0x08, 0x3d, 0x92, 0xc2, 0x5b, 0x5f, 0x98, 0x8c, 0xc7, 0xdb, 0x99, 0xa1, 0xba, 0x8f, 0xa0, 0xa2,
-	0x5e, 0x6a, 0x90, 0xda, 0x9a, 0xe4, 0xbb, 0x8f, 0xf1, 0x20, 0x45, 0x0d, 0x67, 0xfe, 0x10, 0xaa,
-	0xfa, 0xdd, 0x04, 0x3d, 0x08, 0x43, 0x14, 0x7f, 0xe0, 0x30, 0x76, 0xd3, 0xe4, 0xf8, 0x64, 0xfd,
-	0x50, 0xa1, 0x27, 0xa7, 0x5e, 0x47, 0xf4, 0xe4, 0xf4, 0x7b, 0x06, 0x9b, 0xfc, 0x09, 0x34, 0xe2,
-	0xef, 0x0b, 0xe8, 0x61, 0xb8, 0x4c, 0xfa, 0xdd, 0xc2, 0x30, 0xb6, 0xb1, 0xe2, 0xb1, 0x4c, 0x96,
-	0xab, 0x8e, 0xe5, 0x56, 0xc8, 0xd0, 0xb1, 0xdc, 0x5e, 0xe1, 0x4c, 0xdd, 0x18, 0xda, 0xa9, 0xf6,
-	0x0a, 0x3d, 0xd6, 0xe9, 0xbe, 0xad, 0xb3, 0x37, 0x9e, 0xdc, 0xc0, 0x4d, 0x27, 0x4c, 0x78, 0xdd,
-	0x47, 0x51, 0x44, 0x13, 0xb8, 0x60, 0xf4, 0x36, 0xe8, 0xa1, 0x55, 0x2f, 0xa0, 0x99, 0x78, 0x2e,
-	0x40, 0x46, 0x4a, 0x36, 0xf6, 0x86, 0x70, 0x9b, 0x1e, 0xb6, 0x65, 0xba, 0x29, 0xd1, 0x5b, 0x96,
-	0xea, 0x86, 0xf4, 0x96, 0xa5, 0x7b, 0x17, 0x36, 0xf9, 0x08, 0xea, 0xb1, 0xb3, 0x1b, 0xf5, 0xb5,
-	0xe3, 0xe9, 0xde, 0xc2, 0x78, 0xb8, 0x85, 0x13, 0x6a, 0x19, 0x89, 0xb7, 0x9e, 0xc4, 0x3d, 0x1b,
-	0x3d, 0x09, 0x2d, 0xde, 0x76, 0xe5, 0x37, 0x9e, 0xde, 0xc4, 0x8e, 0x2b, 0x4d, 0x5f, 0xde, 0xb5,
-	0xd2, 0x1b, 0xde, 0x11, 0xb4, 0xd2, 0x9b, 0xee, 0xfc, 0x4c, 0xe9, 0x4f, 0xa0, 0x99, 0xc0, 0x43,
-	0x1d, 0xf4, 0x6d, 0xa0, 0x6e, 0x3c, 0xda, 0xca, 0xd3, 0xba, 0x0e, 0xde, 0xfb, 0xdb, 0x3f, 0x9f,
-	0xe6, 0xfe, 0xce, 0x7e, 0xff, 0x60, 0xbf, 0xdf, 0xff, 0xeb, 0xe9, 0x3d, 0xe8, 0x4f, 0xdd, 0xe5,
-	0xc0, 0x63, 0x27, 0x34, 0x6b, 0x48, 0x06, 0xd4, 0xb9, 0xbc, 0x1e, 0x5c, 0x5e, 0x8b, 0x7f, 0x8f,
-	0x4c, 0xca, 0xe2, 0xcf, 0xf7, 0xff, 0x13, 0x00, 0x00, 0xff, 0xff, 0xab, 0x35, 0x0b, 0x39, 0x6c,
-	0x19, 0x00, 0x00,
+	// 1946 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x19, 0xcb, 0x72, 0x23, 0x49,
+	0xd1, 0xad, 0x97, 0xa5, 0xd4, 0x73, 0xca, 0x2f, 0x8d, 0x66, 0x6c, 0xbc, 0x35, 0x0b, 0x78, 0x97,
+	0x5d, 0xed, 0xac, 0x21, 0x88, 0x8d, 0xd8, 0x58, 0x62, 0xe5, 0xc7, 0xcc, 0x98, 0xd9, 0xb1, 0x14,
+	0x25, 0x6d, 0x6c, 0xec, 0x05, 0xd1, 0x96, 0xca, 0x72, 0x63, 0xa9, 0xbb, 0xb7, 0xab, 0x34, 0x46,
+	0x7b, 0xe2, 0xc4, 0x05, 0x22, 0xb8, 0x11, 0x1c, 0xb9, 0x13, 0xc1, 0x2f, 0x70, 0xe0, 0xc2, 0x91,
+	0x4f, 0x20, 0x86, 0x33, 0xff, 0x40, 0xd4, 0xa3, 0x9f, 0x92, 0x8d, 0xe9, 0x81, 0x93, 0xd5, 0x99,
+	0x59, 0x59, 0xf9, 0xce, 0xac, 0x34, 0x80, 0x3b, 0x76, 0x2f, 0xda, 0xae, 0xe7, 0x70, 0x07, 0xe5,
+	0xc4, 0xef, 0x56, 0x65, 0x46, 0xb9, 0xe9, 0xc3, 0x5a, 0x55, 0xea, 0x99, 0x97, 0x3c, 0xf8, 0xdc,
+	0x9c, 0x38, 0x13, 0x47, 0xfe, 0xfc, 0x48, 0xfc, 0x52, 0x50, 0xdc, 0x86, 0x2a, 0xa1, 0xdf, 0xcc,
+	0x29, 0xe3, 0x2f, 0xa8, 0x39, 0xa6, 0x1e, 0xda, 0x05, 0x18, 0x4d, 0xe7, 0x8c, 0x53, 0x6f, 0x68,
+	0x8d, 0x9b, 0xc6, 0xbe, 0x71, 0x90, 0x23, 0x25, 0x0d, 0x39, 0x1b, 0x63, 0x02, 0x35, 0x42, 0x99,
+	0xeb, 0xd8, 0x8c, 0xde, 0xeb, 0x00, 0x7a, 0x07, 0xf2, 0xd4, 0xf3, 0x1c, 0xaf, 0x99, 0xd9, 0x37,
+	0x0e, 0xca, 0x87, 0xe5, 0xb6, 0x94, 0xfa, 0x54, 0x80, 0x88, 0xc2, 0xe0, 0x67, 0x90, 0x97, 0xdf,
+	0xe8, 0x09, 0xe4, 0xf8, 0xc2, 0xa5, 0x92, 0x49, 0xed, 0xb0, 0x1e, 0x21, 0x1d, 0x2c, 0x5c, 0x4a,
+	0x24, 0x12, 0x35, 0x61, 0x7d, 0x46, 0x19, 0x33, 0x27, 0x54, 0xb2, 0x2c, 0x11, 0xff, 0x13, 0x77,
+	0x01, 0x06, 0xcc, 0xd1, 0xea, 0xa0, 0x1f, 0x40, 0xe1, 0x4a, 0x4a, 0x28, 0xd9, 0x95, 0x0f, 0x37,
+	0x14, 0xbb, 0x98, 0xb6, 0x44, 0x93, 0xa0, 0x4d, 0xc8, 0x8f, 0x9c, 0xb9, 0xcd, 0x25, 0xcb, 0x2a,
+	0x51, 0x1f, 0xb8, 0x03, 0xa5, 0x81, 0x35, 0xa3, 0x8c, 0x9b, 0x33, 0x17, 0xb5, 0xa0, 0xe8, 0x5e,
+	0x2d, 0x98, 0x35, 0x32, 0xa7, 0x92, 0x63, 0x96, 0x04, 0xdf, 0x42, 0xa6, 0xa9, 0x33, 0x91, 0xa8,
+	0x8c, 0x44, 0xf9, 0x9f, 0xf8, 0x57, 0x06, 0x94, 0xa5, 0x50, 0xca, 0x66, 0xe8, 0x83, 0x84, 0x54,
+	0x9b, 0xbe, 0x54, 0x51, 0x9b, 0xde, 0x2d, 0x16, 0xfa, 0x10, 0x4a, 0xdc, 0x17, 0xab, 0x99, 0x95,
+	0x6c, 0xb4, 0xad, 0x02, 0x69, 0x49, 0x48, 0x81, 0x7f, 0x6b, 0x40, 0xe3, 0xc8, 0x71, 0x38, 0xe3,
+	0x9e, 0xe9, 0xa6, 0xb2, 0xce, 0x13, 0xc8, 0x33, 0xee, 0x78, 0x54, 0xfb, 0xb0, 0xda, 0xd6, 0x71,
+	0xd6, 0x17, 0x40, 0xa2, 0x70, 0xe8, 0x7b, 0x50, 0xf0, 0xe8, 0xc4, 0x72, 0x6c, 0x2d, 0x52, 0xcd,
+	0xa7, 0x22, 0x12, 0x4a, 0x34, 0x16, 0x77, 0xe0, 0x41, 0x44, 0x9a, 0x34, 0x66, 0xc1, 0x27, 0xb0,
+	0x75, 0xc6, 0x02, 0x26, 0x2e, 0x1d, 0xa7, 0xd1, 0x0a, 0xff, 0x02, 0xb6, 0x93, 0x5c, 0x52, 0x39,
+	0x09, 0x43, 0xe5, 0x22, 0xc2, 0x45, 0x1a, 0xa9, 0x48, 0x62, 0x30, 0xfc, 0x19, 0xd4, 0x3a, 0xd3,
+	0xa9, 0x33, 0x3a, 0x3b, 0x49, 0x25, 0x6a, 0x17, 0xea, 0xc1, 0xf1, 0x54, 0x32, 0xd6, 0x20, 0x63,
+	0x29, 0xc9, 0x72, 0x24, 0x63, 0x8d, 0xf1, 0xd7, 0x50, 0x7f, 0x4e, 0xb9, 0xf2, 0x5f, 0x9a, 0x88,
+	0x78, 0x08, 0x45, 0xe9, 0xf5, 0x61, 0xc0, 0x75, 0x5d, 0x7e, 0x9f, 0x8d, 0x31, 0x85, 0x46, 0xc8,
+	0x3a, 0x95, 0xb0, 0xf7, 0x09, 0x37, 0x3c, 0x82, 0x7a, 0x6f, 0xfe, 0x16, 0x1a, 0xdc, 0xeb, 0x92,
+	0xcf, 0xa1, 0x11, 0x5e, 0x92, 0x2a, 0x54, 0x8f, 0x60, 0xe3, 0x39, 0xe5, 0x9d, 0xe9, 0x54, 0x32,
+	0x61, 0xa9, 0xbc, 0x7f, 0x0d, 0x9b, 0x71, 0x1e, 0xa9, 0xac, 0xfa, 0x5d, 0x28, 0x48, 0xa5, 0x58,
+	0x33, 0xb3, 0x9f, 0x5d, 0xd6, 0x58, 0x23, 0xf1, 0xcf, 0xa4, 0xfb, 0x74, 0xce, 0xa6, 0x31, 0xec,
+	0x2e, 0x80, 0xca, 0xf4, 0xe1, 0x35, 0x5d, 0x48, 0xeb, 0x56, 0x48, 0x49, 0x41, 0x5e, 0xd2, 0x05,
+	0xfe, 0x9d, 0x01, 0x0f, 0x22, 0x17, 0xa4, 0x52, 0x25, 0x2c, 0x35, 0x99, 0xbb, 0x4a, 0x0d, 0x7a,
+	0x17, 0x0a, 0x53, 0xc5, 0x55, 0x95, 0xa4, 0x8a, 0x4f, 0xd7, 0xa3, 0x82, 0x9b, 0xc2, 0xe1, 0x9f,
+	0x4b, 0xf3, 0xaa, 0xa3, 0x47, 0x8b, 0x74, 0x19, 0x8a, 0x1e, 0x81, 0xd6, 0x31, 0xcc, 0x88, 0xa2,
+	0x02, 0x9c, 0x8d, 0xf1, 0x33, 0xd8, 0x79, 0x4e, 0xf9, 0xb1, 0xea, 0x89, 0xc7, 0x8e, 0x7d, 0x69,
+	0x4d, 0x52, 0x05, 0x02, 0x83, 0xe6, 0x32, 0x9f, 0x54, 0x16, 0x7c, 0x0f, 0xd6, 0x75, 0x8b, 0xd6,
+	0x26, 0xac, 0xfb, 0xa6, 0xd1, 0xdc, 0x89, 0x8f, 0xc7, 0xdf, 0xc0, 0x4e, 0x6f, 0xfe, 0xf6, 0xc2,
+	0xff, 0x37, 0x57, 0xbe, 0x80, 0xe6, 0xf2, 0x95, 0xa9, 0xd2, 0xef, 0x8f, 0x06, 0x14, 0x5e, 0xd1,
+	0xd9, 0x05, 0xf5, 0x10, 0x82, 0x9c, 0x6d, 0xce, 0xd4, 0x70, 0x51, 0x22, 0xf2, 0xb7, 0xf0, 0xda,
+	0x4c, 0x62, 0x23, 0x5e, 0x53, 0x80, 0xb3, 0xb1, 0x40, 0xba, 0x94, 0x7a, 0xc3, 0xb9, 0x37, 0x65,
+	0xcd, 0xec, 0x7e, 0xf6, 0xa0, 0x44, 0x8a, 0x02, 0xf0, 0xa5, 0x37, 0x65, 0xe8, 0x3b, 0x50, 0x1e,
+	0x4d, 0x2d, 0x6a, 0x73, 0x85, 0xce, 0x49, 0x34, 0x28, 0x90, 0x24, 0xf8, 0x3e, 0xd4, 0x55, 0x7c,
+	0x0d, 0x5d, 0xcf, 0x72, 0x3c, 0x8b, 0x2f, 0x9a, 0xf9, 0x7d, 0xe3, 0x20, 0x4f, 0x6a, 0x0a, 0xdc,
+	0xd3, 0x50, 0xfc, 0xb9, 0xcc, 0x07, 0x25, 0x64, 0xba, 0xfa, 0xf0, 0x17, 0x03, 0x50, 0x94, 0x45,
+	0xca, 0x9c, 0x5a, 0x57, 0x9a, 0xfb, 0xf5, 0xa1, 0xa2, 0xc8, 0x15, 0x57, 0xe2, 0x23, 0x57, 0xe4,
+	0x54, 0x94, 0x4c, 0xe3, 0xd0, 0x87, 0x50, 0xa6, 0x7c, 0x34, 0x1e, 0x6a, 0xd2, 0xdc, 0x0a, 0x52,
+	0x10, 0x04, 0x5f, 0x28, 0x0d, 0x7a, 0x50, 0x12, 0x29, 0xd9, 0xe7, 0x26, 0x67, 0x68, 0x1f, 0x72,
+	0xc2, 0xcc, 0x5a, 0xea, 0x78, 0xce, 0x4a, 0x0c, 0x7a, 0x07, 0x2a, 0x63, 0xe7, 0xc6, 0x1e, 0x32,
+	0x3a, 0x72, 0xec, 0x31, 0xd3, 0x9e, 0x2b, 0x0b, 0x58, 0x5f, 0x81, 0xf0, 0x5f, 0xb3, 0xb0, 0xad,
+	0x52, 0xfa, 0x05, 0x35, 0x3d, 0x7e, 0x41, 0x4d, 0x9e, 0x2a, 0x6a, 0xff, 0xa7, 0xa5, 0x06, 0xb5,
+	0x01, 0xa4, 0xe0, 0x42, 0x0b, 0x15, 0x34, 0xc1, 0xe8, 0x16, 0xe8, 0x4f, 0x4a, 0x82, 0x44, 0x7c,
+	0x32, 0xf4, 0x31, 0x54, 0x5d, 0x6a, 0x8f, 0x2d, 0x7b, 0xa2, 0x8f, 0xe4, 0xb5, 0x6b, 0xa2, 0xcc,
+	0x2b, 0x9a, 0x44, 0x1d, 0x79, 0x02, 0xd5, 0x8b, 0x05, 0xa7, 0x6c, 0x78, 0xe3, 0x59, 0x9c, 0x53,
+	0xbb, 0x59, 0x90, 0xc6, 0xa9, 0x48, 0xe0, 0x57, 0x0a, 0x26, 0x6a, 0xb4, 0x22, 0xf2, 0xa8, 0x39,
+	0x6e, 0xae, 0xab, 0x99, 0x5d, 0x42, 0x08, 0x35, 0xc5, 0xcc, 0x5e, 0xb9, 0xa6, 0x8b, 0x90, 0x45,
+	0x51, 0xd9, 0x57, 0xc0, 0x7c, 0x0e, 0x8f, 0xa0, 0x24, 0x49, 0x24, 0x83, 0x92, 0xca, 0x1c, 0x01,
+	0x90, 0xe7, 0xdf, 0x83, 0x86, 0xe9, 0xba, 0x9e, 0xf3, 0x4b, 0x6b, 0x66, 0x72, 0x3a, 0x64, 0xd6,
+	0xb7, 0xb4, 0x09, 0x92, 0xa6, 0x1e, 0x81, 0xf7, 0xad, 0x6f, 0x29, 0x7a, 0x1c, 0x9d, 0x65, 0xcb,
+	0x4a, 0x90, 0x70, 0x74, 0xbd, 0x02, 0x38, 0xbe, 0x32, 0xed, 0x09, 0x15, 0xba, 0xdd, 0x23, 0x30,
+	0x3e, 0x81, 0xf2, 0x48, 0xd2, 0x0f, 0xe5, 0x3b, 0x22, 0x23, 0xdf, 0x11, 0x3b, 0x6d, 0xff, 0x21,
+	0x24, 0x4a, 0x89, 0xe2, 0x27, 0xdf, 0x13, 0x30, 0x0a, 0x7e, 0xe3, 0x43, 0xa8, 0x0d, 0x3c, 0xd3,
+	0x66, 0x97, 0xd4, 0x53, 0x31, 0xf9, 0x9f, 0x6f, 0xc3, 0x1f, 0x41, 0xfe, 0x15, 0xf5, 0x26, 0x72,
+	0xf4, 0xe5, 0xa6, 0x37, 0xa1, 0x5c, 0x13, 0x2f, 0x05, 0x89, 0xc2, 0xe2, 0x2a, 0x94, 0xfb, 0xee,
+	0xd4, 0xd2, 0xbd, 0x06, 0xff, 0x3e, 0x0b, 0x3b, 0x4b, 0x31, 0x9a, 0x2a, 0x79, 0x3f, 0x0e, 0xf4,
+	0x96, 0x22, 0xab, 0x50, 0x6d, 0xa8, 0x23, 0xa1, 0x01, 0x7d, 0x85, 0xa5, 0x31, 0x3f, 0x83, 0x3a,
+	0xd7, 0x0a, 0x0f, 0x63, 0x91, 0xab, 0x6f, 0x8a, 0x5b, 0x83, 0xd4, 0x78, 0xdc, 0x3a, 0xb1, 0x7e,
+	0x97, 0x8b, 0xf7, 0x3b, 0xf4, 0x63, 0xa8, 0x68, 0x24, 0x75, 0x9d, 0xd1, 0x95, 0x2c, 0x7c, 0x22,
+	0xcf, 0x62, 0x56, 0x39, 0x15, 0x28, 0x52, 0xf6, 0xc2, 0x0f, 0x51, 0x35, 0x94, 0xa5, 0x94, 0x1a,
+	0x85, 0x15, 0x96, 0x07, 0x45, 0xd0, 0x53, 0x65, 0x20, 0x3f, 0x13, 0xf6, 0x97, 0x01, 0x1c, 0x3c,
+	0x2d, 0xa5, 0x4b, 0x88, 0xc2, 0xa0, 0x1f, 0x41, 0x85, 0x09, 0x8b, 0x0f, 0x75, 0x12, 0x17, 0x25,
+	0xe5, 0x03, 0x45, 0x19, 0xf1, 0x05, 0x29, 0xb3, 0x88, 0x63, 0x2e, 0xa1, 0xde, 0x61, 0xd7, 0x1a,
+	0xfd, 0xff, 0x2b, 0x1a, 0xf8, 0xd7, 0x06, 0x34, 0xc2, 0x8b, 0x52, 0x3e, 0x3e, 0xaa, 0x36, 0xbd,
+	0x19, 0x26, 0x67, 0x8f, 0xb2, 0x4d, 0x6f, 0x88, 0xef, 0x8e, 0x7d, 0xa8, 0x08, 0x1a, 0xd9, 0xcc,
+	0xac, 0xb1, 0xea, 0x65, 0x39, 0x02, 0x36, 0xbd, 0x11, 0x66, 0x3c, 0x1b, 0x33, 0xfc, 0x1b, 0x03,
+	0x10, 0xa1, 0xae, 0xe3, 0xf1, 0xf4, 0x4a, 0x63, 0xc8, 0x4d, 0xe9, 0x25, 0xbf, 0x45, 0x65, 0x89,
+	0x43, 0xef, 0x42, 0xde, 0xb3, 0x26, 0x57, 0xfc, 0x96, 0x27, 0xa2, 0x42, 0xe2, 0x63, 0xd8, 0x88,
+	0x09, 0x93, 0xaa, 0xf3, 0xff, 0x2b, 0x0b, 0x20, 0x27, 0x5b, 0xd5, 0x54, 0xa2, 0x0f, 0x16, 0x23,
+	0xf6, 0x60, 0x11, 0x0f, 0xfb, 0x91, 0xe9, 0x9a, 0x23, 0xd1, 0xa2, 0xf5, 0x0c, 0xe0, 0x7f, 0x8b,
+	0xf2, 0x64, 0xbe, 0x36, 0xad, 0xa9, 0x79, 0x31, 0xa5, 0x52, 0xe8, 0x1c, 0x09, 0x01, 0xa2, 0x4e,
+	0x6a, 0xc3, 0xab, 0x57, 0x7a, 0x4e, 0xbe, 0xd2, 0x75, 0x48, 0x1f, 0xcb, 0xb7, 0xfa, 0x07, 0x80,
+	0x98, 0xae, 0xe0, 0xcc, 0x36, 0x5d, 0x4d, 0x98, 0x97, 0x84, 0x0d, 0x8d, 0xe9, 0xdb, 0xa6, 0xab,
+	0xa8, 0x9f, 0xc2, 0xa6, 0x47, 0x47, 0xd4, 0x7a, 0x9d, 0xa0, 0x2f, 0x48, 0x7a, 0x14, 0xe0, 0xc2,
+	0x13, 0xbb, 0x00, 0x8c, 0x9b, 0x1e, 0x1f, 0x8a, 0xa2, 0x29, 0x13, 0xa1, 0x4a, 0x4a, 0x12, 0x32,
+	0xb0, 0x66, 0x14, 0xb5, 0x61, 0xc3, 0x74, 0xdd, 0xe9, 0x22, 0xc1, 0xaf, 0x28, 0xe9, 0x1e, 0xf8,
+	0xa8, 0x90, 0xdd, 0x0e, 0xac, 0x5b, 0x6c, 0x78, 0x31, 0x67, 0x0b, 0x59, 0xd4, 0x8b, 0xa4, 0x60,
+	0xb1, 0xa3, 0x39, 0x5b, 0x88, 0x7c, 0x9f, 0x33, 0x3a, 0x8e, 0xd6, 0xf2, 0xa2, 0x00, 0xc8, 0x22,
+	0xbe, 0xd4, 0x73, 0xca, 0x2b, 0x7a, 0x4e, 0xb2, 0xa9, 0x54, 0x96, 0x9b, 0x4a, 0xbc, 0x2d, 0x55,
+	0x93, 0x6d, 0x29, 0xd6, 0x73, 0x6a, 0xf1, 0x9e, 0x83, 0xa7, 0xb0, 0x25, 0xdd, 0xfd, 0xb6, 0xed,
+	0x3e, 0xcf, 0x44, 0xbc, 0xc4, 0x4b, 0x68, 0x18, 0x47, 0x44, 0xa1, 0xf1, 0x33, 0xd8, 0x4e, 0xde,
+	0x96, 0x2a, 0x4a, 0xff, 0x6c, 0xc0, 0x66, 0x7f, 0x64, 0x72, 0x31, 0xfe, 0xa6, 0x7f, 0x72, 0xdd,
+	0xf5, 0xf8, 0xb8, 0xef, 0x5e, 0x26, 0x32, 0xc1, 0xe4, 0xee, 0x78, 0x2c, 0x9d, 0xc2, 0x56, 0x42,
+	0xde, 0x34, 0x7a, 0xbf, 0x4f, 0xa1, 0x14, 0xec, 0xf5, 0x50, 0x01, 0x32, 0xdd, 0x97, 0x8d, 0x35,
+	0x54, 0x86, 0xf5, 0x2f, 0xcf, 0x5f, 0x9e, 0x77, 0xbf, 0x3a, 0x6f, 0x18, 0x68, 0x13, 0x1a, 0xe7,
+	0xdd, 0xc1, 0xf0, 0xa8, 0xdb, 0x1d, 0xf4, 0x07, 0xa4, 0xd3, 0xeb, 0x9d, 0x9e, 0x34, 0x32, 0x68,
+	0x03, 0xea, 0xfd, 0x41, 0x97, 0x9c, 0x0e, 0x07, 0xdd, 0x57, 0x47, 0xfd, 0x41, 0xf7, 0xfc, 0xb4,
+	0x91, 0x45, 0x4d, 0xd8, 0xec, 0x7c, 0x41, 0x4e, 0x3b, 0x27, 0x5f, 0xc7, 0xc9, 0x73, 0x87, 0x7f,
+	0x2a, 0x41, 0xa6, 0x77, 0x82, 0x3a, 0x00, 0xe1, 0x7c, 0x8c, 0x76, 0x94, 0x64, 0x4b, 0x43, 0x77,
+	0xab, 0xb9, 0x8c, 0x50, 0xc2, 0xe3, 0x35, 0xf4, 0x14, 0xb2, 0x03, 0xe6, 0x20, 0x1d, 0x10, 0xe1,
+	0x9a, 0xb1, 0xf5, 0x20, 0x02, 0xf1, 0xa9, 0x0f, 0x8c, 0xa7, 0x06, 0xfa, 0x09, 0x94, 0x82, 0xe5,
+	0x12, 0xda, 0x56, 0x54, 0xc9, 0x35, 0x5c, 0x6b, 0x67, 0x09, 0x1e, 0xdc, 0xf8, 0x0a, 0x6a, 0xf1,
+	0xf5, 0x14, 0x7a, 0xa4, 0x88, 0x57, 0xae, 0xbe, 0x5a, 0x8f, 0x57, 0x23, 0x03, 0x76, 0x9f, 0xc0,
+	0xba, 0x5e, 0x21, 0x21, 0xed, 0x9a, 0xf8, 0x42, 0xaa, 0xb5, 0x95, 0x80, 0x06, 0x27, 0x3f, 0x85,
+	0xa2, 0xbf, 0xd0, 0x41, 0x5b, 0x81, 0x89, 0xa2, 0x9b, 0x97, 0xd6, 0x76, 0x12, 0x1c, 0x3d, 0xec,
+	0x6f, 0x50, 0xfc, 0xc3, 0x89, 0xb5, 0x8d, 0x7f, 0x38, 0xb9, 0x68, 0xc1, 0x6b, 0xe8, 0x39, 0x54,
+	0xa2, 0x8b, 0x0f, 0xf4, 0x30, 0xb8, 0x26, 0xb9, 0x50, 0x69, 0xb5, 0x56, 0xa1, 0xa2, 0xb6, 0x8c,
+	0xa7, 0xab, 0x6f, 0xcb, 0x95, 0x25, 0xc3, 0xb7, 0xe5, 0xea, 0x0c, 0xc7, 0x6b, 0x68, 0x00, 0xf5,
+	0xc4, 0xdc, 0x86, 0x1e, 0xfb, 0xe1, 0xbe, 0xea, 0xc9, 0xd1, 0xda, 0xbd, 0x05, 0x9b, 0x0c, 0x98,
+	0x60, 0x0f, 0x81, 0x42, 0x8b, 0xc6, 0xea, 0x42, 0x6b, 0x67, 0x09, 0x1e, 0x48, 0xf5, 0x0c, 0xaa,
+	0xb1, 0x3d, 0x06, 0x6a, 0x25, 0x68, 0x23, 0xcb, 0x8d, 0xbb, 0xf8, 0x7c, 0x0a, 0x45, 0x7f, 0x28,
+	0xf1, 0x5d, 0x96, 0x98, 0x86, 0x7c, 0x97, 0x25, 0x67, 0x17, 0xbc, 0x86, 0x4e, 0xa0, 0x1c, 0xe9,
+	0xdd, 0xa8, 0xe9, 0x2b, 0x9e, 0x9c, 0x2d, 0x5a, 0x0f, 0x57, 0x60, 0x02, 0x2e, 0x7d, 0xb9, 0x84,
+	0x8a, 0x2d, 0x00, 0xd0, 0x6e, 0x20, 0xf1, 0xaa, 0x5d, 0x44, 0x6b, 0xef, 0x36, 0x74, 0x94, 0x69,
+	0x72, 0xab, 0xe0, 0x33, 0xbd, 0x65, 0xc1, 0xe1, 0x33, 0xbd, 0x6d, 0x19, 0x81, 0xd7, 0xd0, 0x4f,
+	0xa1, 0x1a, 0xab, 0x87, 0xbe, 0xd1, 0x57, 0x15, 0xf5, 0xd6, 0xa3, 0x95, 0x38, 0x9f, 0xd7, 0xd1,
+	0xfb, 0x7f, 0x7b, 0xb3, 0x67, 0xfc, 0xfd, 0xcd, 0x9e, 0xf1, 0x8f, 0x37, 0x7b, 0xc6, 0x1f, 0xfe,
+	0xb9, 0xb7, 0x06, 0xcd, 0x91, 0x33, 0x6b, 0xbb, 0x96, 0x3d, 0x19, 0x99, 0x6e, 0x9b, 0x5b, 0xd7,
+	0xaf, 0xdb, 0xd7, 0xaf, 0xe5, 0xff, 0x6d, 0x2e, 0x0a, 0xf2, 0xcf, 0x0f, 0xff, 0x1d, 0x00, 0x00,
+	0xff, 0xff, 0x93, 0x54, 0x35, 0xa7, 0x05, 0x1a, 0x00, 0x00,
 }
diff --git a/vendor/github.com/pingcap/kvproto/pkg/raft_serverpb/raft_serverpb.pb.go b/vendor/github.com/pingcap/kvproto/pkg/raft_serverpb/raft_serverpb.pb.go
index 5ab294181037c..3f99653ca02a6 100644
--- a/vendor/github.com/pingcap/kvproto/pkg/raft_serverpb/raft_serverpb.pb.go
+++ b/vendor/github.com/pingcap/kvproto/pkg/raft_serverpb/raft_serverpb.pb.go
@@ -20,6 +20,7 @@
 		StoreIdent
 		RaftLocalState
 		RaftApplyState
+		MergeState
 		RegionLocalState
 */
 package raft_serverpb
@@ -53,17 +54,20 @@ const (
 	PeerState_Normal    PeerState = 0
 	PeerState_Applying  PeerState = 1
 	PeerState_Tombstone PeerState = 2
+	PeerState_Merging   PeerState = 3
 )
 
 var PeerState_name = map[int32]string{
 	0: "Normal",
 	1: "Applying",
 	2: "Tombstone",
+	3: "Merging",
 }
 var PeerState_value = map[string]int32{
 	"Normal":    0,
 	"Applying":  1,
 	"Tombstone": 2,
+	"Merging":   3,
 }
 
 func (x PeerState) String() string {
@@ -82,6 +86,8 @@ type RaftMessage struct {
 	// Region key range [start_key, end_key).
 	StartKey []byte `protobuf:"bytes,7,opt,name=start_key,json=startKey,proto3" json:"start_key,omitempty"`
 	EndKey   []byte `protobuf:"bytes,8,opt,name=end_key,json=endKey,proto3" json:"end_key,omitempty"`
+	// If it has value, to_peer should be removed if merge is never going to complete.
+	MergeTarget *metapb.Region `protobuf:"bytes,9,opt,name=merge_target,json=mergeTarget" json:"merge_target,omitempty"`
 }
 
 func (m *RaftMessage) Reset()                    { *m = RaftMessage{} }
@@ -145,6 +151,13 @@ func (m *RaftMessage) GetEndKey() []byte {
 	return nil
 }
 
+func (m *RaftMessage) GetMergeTarget() *metapb.Region {
+	if m != nil {
+		return m.MergeTarget
+	}
+	return nil
+}
+
 type RaftTruncatedState struct {
 	Index uint64 `protobuf:"varint,1,opt,name=index,proto3" json:"index,omitempty"`
 	Term  uint64 `protobuf:"varint,2,opt,name=term,proto3" json:"term,omitempty"`
@@ -393,15 +406,48 @@ func (m *RaftApplyState) GetTruncatedState() *RaftTruncatedState {
 	return nil
 }
 
+type MergeState struct {
+	MinIndex uint64         `protobuf:"varint,1,opt,name=min_index,json=minIndex,proto3" json:"min_index,omitempty"`
+	Target   *metapb.Region `protobuf:"bytes,2,opt,name=target" json:"target,omitempty"`
+	Commit   uint64         `protobuf:"varint,3,opt,name=commit,proto3" json:"commit,omitempty"`
+}
+
+func (m *MergeState) Reset()                    { *m = MergeState{} }
+func (m *MergeState) String() string            { return proto.CompactTextString(m) }
+func (*MergeState) ProtoMessage()               {}
+func (*MergeState) Descriptor() ([]byte, []int) { return fileDescriptorRaftServerpb, []int{11} }
+
+func (m *MergeState) GetMinIndex() uint64 {
+	if m != nil {
+		return m.MinIndex
+	}
+	return 0
+}
+
+func (m *MergeState) GetTarget() *metapb.Region {
+	if m != nil {
+		return m.Target
+	}
+	return nil
+}
+
+func (m *MergeState) GetCommit() uint64 {
+	if m != nil {
+		return m.Commit
+	}
+	return 0
+}
+
 type RegionLocalState struct {
-	State  PeerState      `protobuf:"varint,1,opt,name=state,proto3,enum=raft_serverpb.PeerState" json:"state,omitempty"`
-	Region *metapb.Region `protobuf:"bytes,2,opt,name=region" json:"region,omitempty"`
+	State      PeerState      `protobuf:"varint,1,opt,name=state,proto3,enum=raft_serverpb.PeerState" json:"state,omitempty"`
+	Region     *metapb.Region `protobuf:"bytes,2,opt,name=region" json:"region,omitempty"`
+	MergeState *MergeState    `protobuf:"bytes,3,opt,name=merge_state,json=mergeState" json:"merge_state,omitempty"`
 }
 
 func (m *RegionLocalState) Reset()                    { *m = RegionLocalState{} }
 func (m *RegionLocalState) String() string            { return proto.CompactTextString(m) }
 func (*RegionLocalState) ProtoMessage()               {}
-func (*RegionLocalState) Descriptor() ([]byte, []int) { return fileDescriptorRaftServerpb, []int{11} }
+func (*RegionLocalState) Descriptor() ([]byte, []int) { return fileDescriptorRaftServerpb, []int{12} }
 
 func (m *RegionLocalState) GetState() PeerState {
 	if m != nil {
@@ -417,6 +463,13 @@ func (m *RegionLocalState) GetRegion() *metapb.Region {
 	return nil
 }
 
+func (m *RegionLocalState) GetMergeState() *MergeState {
+	if m != nil {
+		return m.MergeState
+	}
+	return nil
+}
+
 func init() {
 	proto.RegisterType((*RaftMessage)(nil), "raft_serverpb.RaftMessage")
 	proto.RegisterType((*RaftTruncatedState)(nil), "raft_serverpb.RaftTruncatedState")
@@ -429,6 +482,7 @@ func init() {
 	proto.RegisterType((*StoreIdent)(nil), "raft_serverpb.StoreIdent")
 	proto.RegisterType((*RaftLocalState)(nil), "raft_serverpb.RaftLocalState")
 	proto.RegisterType((*RaftApplyState)(nil), "raft_serverpb.RaftApplyState")
+	proto.RegisterType((*MergeState)(nil), "raft_serverpb.MergeState")
 	proto.RegisterType((*RegionLocalState)(nil), "raft_serverpb.RegionLocalState")
 	proto.RegisterEnum("raft_serverpb.PeerState", PeerState_name, PeerState_value)
 }
@@ -514,6 +568,16 @@ func (m *RaftMessage) MarshalTo(dAtA []byte) (int, error) {
 		i = encodeVarintRaftServerpb(dAtA, i, uint64(len(m.EndKey)))
 		i += copy(dAtA[i:], m.EndKey)
 	}
+	if m.MergeTarget != nil {
+		dAtA[i] = 0x4a
+		i++
+		i = encodeVarintRaftServerpb(dAtA, i, uint64(m.MergeTarget.Size()))
+		n5, err := m.MergeTarget.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n5
+	}
 	return i, nil
 }
 
@@ -628,11 +692,11 @@ func (m *SnapshotChunk) MarshalTo(dAtA []byte) (int, error) {
 		dAtA[i] = 0xa
 		i++
 		i = encodeVarintRaftServerpb(dAtA, i, uint64(m.Message.Size()))
-		n5, err := m.Message.MarshalTo(dAtA[i:])
+		n6, err := m.Message.MarshalTo(dAtA[i:])
 		if err != nil {
 			return 0, err
 		}
-		i += n5
+		i += n6
 	}
 	if len(m.Data) > 0 {
 		dAtA[i] = 0x12
@@ -710,11 +774,11 @@ func (m *RaftSnapshotData) MarshalTo(dAtA []byte) (int, error) {
 		dAtA[i] = 0xa
 		i++
 		i = encodeVarintRaftServerpb(dAtA, i, uint64(m.Region.Size()))
-		n6, err := m.Region.MarshalTo(dAtA[i:])
+		n7, err := m.Region.MarshalTo(dAtA[i:])
 		if err != nil {
 			return 0, err
 		}
-		i += n6
+		i += n7
 	}
 	if m.FileSize != 0 {
 		dAtA[i] = 0x10
@@ -742,11 +806,11 @@ func (m *RaftSnapshotData) MarshalTo(dAtA []byte) (int, error) {
 		dAtA[i] = 0x2a
 		i++
 		i = encodeVarintRaftServerpb(dAtA, i, uint64(m.Meta.Size()))
-		n7, err := m.Meta.MarshalTo(dAtA[i:])
+		n8, err := m.Meta.MarshalTo(dAtA[i:])
 		if err != nil {
 			return 0, err
 		}
-		i += n7
+		i += n8
 	}
 	return i, nil
 }
@@ -798,11 +862,11 @@ func (m *RaftLocalState) MarshalTo(dAtA []byte) (int, error) {
 		dAtA[i] = 0xa
 		i++
 		i = encodeVarintRaftServerpb(dAtA, i, uint64(m.HardState.Size()))
-		n8, err := m.HardState.MarshalTo(dAtA[i:])
+		n9, err := m.HardState.MarshalTo(dAtA[i:])
 		if err != nil {
 			return 0, err
 		}
-		i += n8
+		i += n9
 	}
 	if m.LastIndex != 0 {
 		dAtA[i] = 0x10
@@ -836,11 +900,49 @@ func (m *RaftApplyState) MarshalTo(dAtA []byte) (int, error) {
 		dAtA[i] = 0x12
 		i++
 		i = encodeVarintRaftServerpb(dAtA, i, uint64(m.TruncatedState.Size()))
-		n9, err := m.TruncatedState.MarshalTo(dAtA[i:])
+		n10, err := m.TruncatedState.MarshalTo(dAtA[i:])
 		if err != nil {
 			return 0, err
 		}
-		i += n9
+		i += n10
+	}
+	return i, nil
+}
+
+func (m *MergeState) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *MergeState) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if m.MinIndex != 0 {
+		dAtA[i] = 0x8
+		i++
+		i = encodeVarintRaftServerpb(dAtA, i, uint64(m.MinIndex))
+	}
+	if m.Target != nil {
+		dAtA[i] = 0x12
+		i++
+		i = encodeVarintRaftServerpb(dAtA, i, uint64(m.Target.Size()))
+		n11, err := m.Target.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n11
+	}
+	if m.Commit != 0 {
+		dAtA[i] = 0x18
+		i++
+		i = encodeVarintRaftServerpb(dAtA, i, uint64(m.Commit))
 	}
 	return i, nil
 }
@@ -869,11 +971,21 @@ func (m *RegionLocalState) MarshalTo(dAtA []byte) (int, error) {
 		dAtA[i] = 0x12
 		i++
 		i = encodeVarintRaftServerpb(dAtA, i, uint64(m.Region.Size()))
-		n10, err := m.Region.MarshalTo(dAtA[i:])
+		n12, err := m.Region.MarshalTo(dAtA[i:])
 		if err != nil {
 			return 0, err
 		}
-		i += n10
+		i += n12
+	}
+	if m.MergeState != nil {
+		dAtA[i] = 0x1a
+		i++
+		i = encodeVarintRaftServerpb(dAtA, i, uint64(m.MergeState.Size()))
+		n13, err := m.MergeState.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n13
 	}
 	return i, nil
 }
@@ -938,6 +1050,10 @@ func (m *RaftMessage) Size() (n int) {
 	if l > 0 {
 		n += 1 + l + sovRaftServerpb(uint64(l))
 	}
+	if m.MergeTarget != nil {
+		l = m.MergeTarget.Size()
+		n += 1 + l + sovRaftServerpb(uint64(l))
+	}
 	return n
 }
 
@@ -1079,6 +1195,22 @@ func (m *RaftApplyState) Size() (n int) {
 	return n
 }
 
+func (m *MergeState) Size() (n int) {
+	var l int
+	_ = l
+	if m.MinIndex != 0 {
+		n += 1 + sovRaftServerpb(uint64(m.MinIndex))
+	}
+	if m.Target != nil {
+		l = m.Target.Size()
+		n += 1 + l + sovRaftServerpb(uint64(l))
+	}
+	if m.Commit != 0 {
+		n += 1 + sovRaftServerpb(uint64(m.Commit))
+	}
+	return n
+}
+
 func (m *RegionLocalState) Size() (n int) {
 	var l int
 	_ = l
@@ -1089,6 +1221,10 @@ func (m *RegionLocalState) Size() (n int) {
 		l = m.Region.Size()
 		n += 1 + l + sovRaftServerpb(uint64(l))
 	}
+	if m.MergeState != nil {
+		l = m.MergeState.Size()
+		n += 1 + l + sovRaftServerpb(uint64(l))
+	}
 	return n
 }
 
@@ -1367,6 +1503,39 @@ func (m *RaftMessage) Unmarshal(dAtA []byte) error {
 				m.EndKey = []byte{}
 			}
 			iNdEx = postIndex
+		case 9:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field MergeTarget", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRaftServerpb
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRaftServerpb
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.MergeTarget == nil {
+				m.MergeTarget = &metapb.Region{}
+			}
+			if err := m.MergeTarget.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipRaftServerpb(dAtA[iNdEx:])
@@ -2427,6 +2596,127 @@ func (m *RaftApplyState) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
+func (m *MergeState) 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 ErrIntOverflowRaftServerpb
+			}
+			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: MergeState: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: MergeState: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field MinIndex", wireType)
+			}
+			m.MinIndex = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRaftServerpb
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.MinIndex |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Target", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRaftServerpb
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRaftServerpb
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Target == nil {
+				m.Target = &metapb.Region{}
+			}
+			if err := m.Target.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 3:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Commit", wireType)
+			}
+			m.Commit = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRaftServerpb
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Commit |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRaftServerpb(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRaftServerpb
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
 func (m *RegionLocalState) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
@@ -2508,6 +2798,39 @@ func (m *RegionLocalState) Unmarshal(dAtA []byte) error {
 				return err
 			}
 			iNdEx = postIndex
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field MergeState", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRaftServerpb
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRaftServerpb
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.MergeState == nil {
+				m.MergeState = &MergeState{}
+			}
+			if err := m.MergeState.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipRaftServerpb(dAtA[iNdEx:])
@@ -2637,53 +2960,60 @@ var (
 func init() { proto.RegisterFile("raft_serverpb.proto", fileDescriptorRaftServerpb) }
 
 var fileDescriptorRaftServerpb = []byte{
-	// 762 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x7c, 0x54, 0xdb, 0x6e, 0xd3, 0x4c,
-	0x10, 0xae, 0x93, 0x34, 0xb1, 0x27, 0x4e, 0xfe, 0x68, 0xfb, 0x4b, 0x35, 0xa9, 0x5a, 0x51, 0x23,
-	0x10, 0x14, 0xc9, 0x88, 0x52, 0x21, 0xae, 0x90, 0x80, 0x52, 0xb5, 0x40, 0x51, 0xb5, 0xa9, 0x90,
-	0xb8, 0xb2, 0x36, 0xf6, 0xa6, 0x31, 0xf1, 0x49, 0xde, 0x4d, 0x44, 0xb9, 0xe3, 0x2d, 0x78, 0x15,
-	0xde, 0x80, 0x3b, 0x78, 0x04, 0x04, 0x2f, 0xc2, 0x1e, 0xec, 0x1c, 0xaa, 0xc2, 0x45, 0xe2, 0x99,
-	0xf9, 0xe6, 0xf8, 0xed, 0xec, 0xc2, 0x46, 0x41, 0x46, 0xdc, 0x67, 0xb4, 0x98, 0xd1, 0x22, 0x1f,
-	0x7a, 0x79, 0x91, 0xf1, 0x0c, 0x75, 0x56, 0x8c, 0xfd, 0x0e, 0x95, 0x7a, 0x85, 0xf6, 0xed, 0x84,
-	0x72, 0x52, 0x69, 0xee, 0xd7, 0x1a, 0xb4, 0xb1, 0x80, 0x4f, 0x29, 0x63, 0xe4, 0x82, 0xa2, 0x2d,
-	0xb0, 0x0a, 0x7a, 0x11, 0x65, 0xa9, 0x1f, 0x85, 0x8e, 0x71, 0xd3, 0xb8, 0xdb, 0xc0, 0xa6, 0x36,
-	0x9c, 0x84, 0xe8, 0x1e, 0x58, 0xa3, 0x22, 0x4b, 0xfc, 0x9c, 0xd2, 0xc2, 0xa9, 0x09, 0xb0, 0xbd,
-	0x6f, 0x7b, 0x65, 0xba, 0x33, 0x61, 0xc3, 0xa6, 0x84, 0xa5, 0x84, 0x6e, 0x43, 0x8b, 0x67, 0xda,
-	0xb1, 0x7e, 0x8d, 0x63, 0x93, 0x67, 0xca, 0x6d, 0x0f, 0x5a, 0x89, 0xae, 0xec, 0x34, 0x94, 0x5b,
-	0xcf, 0xab, 0xba, 0x2d, 0x3b, 0xc2, 0x95, 0x03, 0x7a, 0x0c, 0x76, 0xd9, 0x1a, 0xcd, 0xb3, 0x60,
-	0xec, 0xac, 0xab, 0x80, 0x8d, 0x2a, 0x2f, 0x56, 0xd8, 0x4b, 0x09, 0xe1, 0x76, 0xb1, 0x50, 0xd0,
-	0x2e, 0xd8, 0x11, 0xf3, 0x79, 0x96, 0x0c, 0x19, 0xcf, 0x52, 0xea, 0x34, 0x45, 0x9c, 0x89, 0xdb,
-	0x11, 0x3b, 0xaf, 0x4c, 0x72, 0x6a, 0xc6, 0x49, 0xc1, 0xfd, 0x09, 0xbd, 0x74, 0x5a, 0x02, 0xb7,
-	0xb1, 0xa9, 0x0c, 0xaf, 0xe9, 0x25, 0xda, 0x84, 0x16, 0x4d, 0x43, 0x05, 0x99, 0x0a, 0x6a, 0x0a,
-	0x55, 0x00, 0xee, 0x53, 0x40, 0x92, 0xba, 0xf3, 0x62, 0x9a, 0x06, 0x84, 0xd3, 0x70, 0xc0, 0xc5,
-	0x3f, 0xfa, 0x1f, 0xd6, 0xa3, 0x34, 0xa4, 0x1f, 0x4b, 0xf6, 0xb4, 0x82, 0x10, 0x34, 0x38, 0x2d,
-	0x12, 0xc5, 0x5a, 0x03, 0x2b, 0xd9, 0x3d, 0x83, 0xee, 0x20, 0x25, 0x39, 0x1b, 0x67, 0xfc, 0xc5,
-	0xd1, 0x51, 0x14, 0x53, 0xd4, 0x85, 0x5a, 0x30, 0x52, 0x81, 0x16, 0x16, 0x92, 0x8c, 0x62, 0xd1,
-	0x27, 0x5a, 0x45, 0x49, 0x19, 0xf5, 0xc1, 0x0c, 0xc6, 0x34, 0x98, 0xb0, 0x69, 0xa2, 0xa8, 0xed,
-	0xe0, 0xb9, 0xee, 0x1e, 0x83, 0x5d, 0x65, 0x3c, 0x15, 0xac, 0xa0, 0x27, 0xc2, 0x77, 0xe4, 0x8f,
-	0x44, 0x6a, 0x26, 0xb2, 0xd6, 0x05, 0x5d, 0xdb, 0xde, 0xea, 0xc6, 0xac, 0x36, 0x80, 0x5b, 0xc1,
-	0x48, 0x7e, 0x99, 0xfb, 0x1e, 0x3a, 0x73, 0x68, 0x3c, 0x4d, 0x27, 0xe8, 0x60, 0x71, 0x52, 0x86,
-	0x22, 0xbe, 0x7f, 0x25, 0xd3, 0xd2, 0x16, 0x2d, 0xce, 0x4c, 0x0c, 0x10, 0x12, 0x4e, 0xd4, 0x00,
-	0x36, 0x56, 0xb2, 0xdb, 0x84, 0xc6, 0xa1, 0x20, 0xdd, 0xdd, 0x07, 0x53, 0xb0, 0xf8, 0x8e, 0xc4,
-	0x53, 0x8a, 0x7a, 0x50, 0x97, 0xfc, 0x1a, 0xca, 0x4d, 0x8a, 0x92, 0xc6, 0x99, 0x84, 0xca, 0x50,
-	0xad, 0xb8, 0xdf, 0x0d, 0xe8, 0xc9, 0x42, 0x55, 0x6f, 0x87, 0x22, 0x21, 0xba, 0x03, 0x4d, 0x7d,
-	0xde, 0x65, 0x67, 0xdd, 0xd5, 0x95, 0xc0, 0x25, 0x2a, 0x4f, 0x59, 0x52, 0xe1, 0x2f, 0x51, 0x6a,
-	0x4a, 0xc3, 0x40, 0xd2, 0x7a, 0xbf, 0xec, 0xb4, 0xae, 0x68, 0xda, 0xbc, 0x32, 0x5c, 0xd5, 0xa8,
-	0x1e, 0x01, 0x39, 0xd0, 0x12, 0x76, 0x26, 0x4b, 0x36, 0x54, 0x9e, 0x4a, 0x45, 0x0f, 0xa0, 0x21,
-	0x8b, 0x97, 0xcb, 0xb9, 0xf5, 0x17, 0xb6, 0xe5, 0xe1, 0x60, 0xe5, 0xe8, 0x1e, 0x01, 0x0c, 0x78,
-	0x56, 0xd0, 0x93, 0x90, 0xa6, 0x1c, 0x6d, 0x03, 0x04, 0xf1, 0x94, 0x89, 0xf5, 0x58, 0xdc, 0x3f,
-	0xab, 0xb4, 0x88, 0x0b, 0x78, 0x03, 0xc4, 0x5a, 0x0a, 0x67, 0x09, 0xea, 0x01, 0x5a, 0x4c, 0x07,
-	0xbb, 0x43, 0xe8, 0x4a, 0x62, 0xde, 0x64, 0x01, 0x89, 0xf5, 0x22, 0x3e, 0x04, 0x18, 0x93, 0x22,
-	0xf4, 0x99, 0xd4, 0x4a, 0x6a, 0xd0, 0xfc, 0x7a, 0x1d, 0x0b, 0x48, 0xf9, 0x61, 0x6b, 0x5c, 0x89,
-	0xb2, 0x7c, 0x4c, 0x18, 0xf7, 0xf5, 0x02, 0xeb, 0x0a, 0x96, 0xb4, 0x9c, 0x48, 0x83, 0xfb, 0xd9,
-	0xd0, 0x45, 0x9e, 0xe5, 0x79, 0x7c, 0xa9, 0x23, 0x6e, 0x41, 0x87, 0x08, 0x2d, 0xa2, 0xa1, 0xbf,
-	0xbc, 0xf5, 0x76, 0x69, 0x54, 0x71, 0xe8, 0x15, 0xfc, 0xc7, 0xab, 0x4b, 0x52, 0xb6, 0xa3, 0x5f,
-	0x8f, 0xdd, 0x6b, 0x76, 0x68, 0xf5, 0x3a, 0xe1, 0x2e, 0x5f, 0xd1, 0xdd, 0x0f, 0x62, 0x01, 0xd4,
-	0x71, 0x2e, 0x4d, 0xea, 0xc1, 0xfa, 0x62, 0xc8, 0xee, 0xbe, 0x73, 0x25, 0xab, 0x7c, 0x69, 0x74,
-	0x32, 0xed, 0xb6, 0xb4, 0x30, 0xb5, 0x7f, 0x2d, 0xcc, 0xde, 0x01, 0x58, 0xf3, 0x58, 0x04, 0xd0,
-	0x7c, 0x9b, 0x15, 0x09, 0x89, 0x7b, 0x6b, 0xc8, 0x06, 0x53, 0x71, 0x10, 0xa5, 0x17, 0x3d, 0x03,
-	0x75, 0xc0, 0x9a, 0x3f, 0x25, 0xbd, 0xda, 0xf3, 0xbd, 0x6f, 0xbf, 0x76, 0x8c, 0x1f, 0xe2, 0xf7,
-	0x53, 0xfc, 0xbe, 0xfc, 0xde, 0x59, 0x03, 0x27, 0xc8, 0x12, 0x2f, 0x17, 0xce, 0x01, 0xc9, 0x3d,
-	0x1e, 0x4d, 0x66, 0xde, 0x64, 0xa6, 0x9e, 0xdf, 0x61, 0x53, 0x7d, 0x1e, 0xfd, 0x09, 0x00, 0x00,
-	0xff, 0xff, 0x13, 0x81, 0xd5, 0xd2, 0xc8, 0x05, 0x00, 0x00,
+	// 866 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x55, 0xdd, 0x6e, 0xe3, 0x44,
+	0x14, 0x5e, 0x27, 0xae, 0x63, 0x9f, 0x38, 0x21, 0x9a, 0x45, 0xac, 0xb7, 0xd5, 0x56, 0x59, 0x23,
+	0x56, 0xa1, 0x48, 0x41, 0x5b, 0x10, 0x42, 0x5c, 0x20, 0x2d, 0x2c, 0xd5, 0x96, 0xa5, 0xa8, 0x9a,
+	0x56, 0x48, 0x5c, 0x59, 0x53, 0xfb, 0x38, 0xb1, 0xe2, 0x3f, 0xcd, 0x4c, 0x22, 0xc2, 0x1d, 0x6f,
+	0xc1, 0x13, 0xf0, 0x2c, 0xdc, 0xc1, 0x23, 0xa0, 0x72, 0xcb, 0x43, 0xa0, 0x99, 0xb1, 0xf3, 0xa7,
+	0xc2, 0x95, 0xe7, 0xfc, 0xcd, 0x39, 0xe7, 0x3b, 0xdf, 0x19, 0xc3, 0x63, 0xce, 0x52, 0x19, 0x09,
+	0xe4, 0x2b, 0xe4, 0xf5, 0xdd, 0xb4, 0xe6, 0x95, 0xac, 0xc8, 0x60, 0x4f, 0x79, 0x3c, 0x40, 0x25,
+	0xb7, 0xd6, 0x63, 0xbf, 0x40, 0xc9, 0x5a, 0x29, 0xfc, 0xa7, 0x03, 0x7d, 0xca, 0x52, 0x79, 0x85,
+	0x42, 0xb0, 0x19, 0x92, 0x13, 0xf0, 0x38, 0xce, 0xb2, 0xaa, 0x8c, 0xb2, 0x24, 0xb0, 0xc6, 0xd6,
+	0xc4, 0xa6, 0xae, 0x51, 0x5c, 0x26, 0xe4, 0x43, 0xf0, 0x52, 0x5e, 0x15, 0x51, 0x8d, 0xc8, 0x83,
+	0xce, 0xd8, 0x9a, 0xf4, 0xcf, 0xfd, 0x69, 0x73, 0xdd, 0x35, 0x22, 0xa7, 0xae, 0x32, 0xab, 0x13,
+	0xf9, 0x00, 0x7a, 0xb2, 0x32, 0x8e, 0xdd, 0x07, 0x1c, 0x1d, 0x59, 0x69, 0xb7, 0x33, 0xe8, 0x15,
+	0x26, 0x73, 0x60, 0x6b, 0xb7, 0xd1, 0xb4, 0xad, 0xb6, 0xa9, 0x88, 0xb6, 0x0e, 0xe4, 0x33, 0xf0,
+	0x9b, 0xd2, 0xb0, 0xae, 0xe2, 0x79, 0x70, 0xa4, 0x03, 0x1e, 0xb7, 0xf7, 0x52, 0x6d, 0xfb, 0x46,
+	0x99, 0x68, 0x9f, 0x6f, 0x05, 0xf2, 0x1c, 0xfc, 0x4c, 0x44, 0xb2, 0x2a, 0xee, 0x84, 0xac, 0x4a,
+	0x0c, 0x9c, 0xb1, 0x35, 0x71, 0x69, 0x3f, 0x13, 0xb7, 0xad, 0x4a, 0x75, 0x2d, 0x24, 0xe3, 0x32,
+	0x5a, 0xe0, 0x3a, 0xe8, 0x8d, 0xad, 0x89, 0x4f, 0x5d, 0xad, 0x78, 0x8b, 0x6b, 0xf2, 0x04, 0x7a,
+	0x58, 0x26, 0xda, 0xe4, 0x6a, 0x93, 0x83, 0x65, 0xa2, 0x0c, 0x2f, 0xc1, 0x2f, 0x90, 0xcf, 0x30,
+	0x92, 0x8c, 0xcf, 0x50, 0x06, 0x9e, 0x2e, 0x68, 0xb8, 0x5f, 0x10, 0xed, 0x6b, 0x9f, 0x5b, 0xed,
+	0x12, 0x7e, 0x09, 0x44, 0xa1, 0x7d, 0xcb, 0x97, 0x65, 0xcc, 0x24, 0x26, 0x37, 0x92, 0x49, 0x24,
+	0xef, 0xc2, 0x51, 0x56, 0x26, 0xf8, 0x53, 0x03, 0xb8, 0x11, 0x08, 0x01, 0x5b, 0x22, 0x2f, 0x34,
+	0xd0, 0x36, 0xd5, 0xe7, 0xf0, 0x1a, 0x86, 0x37, 0x25, 0xab, 0xc5, 0xbc, 0x92, 0x5f, 0x5f, 0x5c,
+	0x64, 0x39, 0x92, 0x21, 0x74, 0xe2, 0x54, 0x07, 0x7a, 0xb4, 0x13, 0xa7, 0x2a, 0x4a, 0x64, 0x3f,
+	0x63, 0x1b, 0xa5, 0xce, 0xe4, 0x18, 0xdc, 0x78, 0x8e, 0xf1, 0x42, 0x2c, 0x0b, 0x3d, 0x8d, 0x01,
+	0xdd, 0xc8, 0xe1, 0x1b, 0xf0, 0xdb, 0x1b, 0xaf, 0x50, 0x32, 0xf2, 0x39, 0xb8, 0x71, 0x1a, 0xa5,
+	0x59, 0x8e, 0x22, 0xb0, 0xc6, 0xdd, 0x49, 0xff, 0xfc, 0xd9, 0x74, 0x9f, 0x64, 0xfb, 0x05, 0xd0,
+	0x5e, 0x9c, 0xaa, 0xaf, 0x08, 0x7f, 0x84, 0xc1, 0xc6, 0x34, 0x5f, 0x96, 0x0b, 0xf2, 0xe9, 0x76,
+	0xb8, 0x96, 0x86, 0xe6, 0xf8, 0xe0, 0xa6, 0x1d, 0xe2, 0x6d, 0xc7, 0x4c, 0xc0, 0x4e, 0x98, 0x64,
+	0xba, 0x01, 0x9f, 0xea, 0x73, 0xe8, 0x80, 0xfd, 0xba, 0x2a, 0x31, 0x3c, 0x07, 0xf7, 0x2d, 0xae,
+	0x7f, 0x60, 0xf9, 0x12, 0xc9, 0x08, 0xba, 0x6a, 0x24, 0x96, 0x76, 0x53, 0x47, 0x05, 0xe3, 0x4a,
+	0x99, 0x9a, 0x50, 0x23, 0x84, 0x7f, 0x58, 0x30, 0x52, 0x89, 0xda, 0xda, 0x5e, 0x33, 0xc9, 0xc8,
+	0x0b, 0x70, 0x0c, 0x45, 0x9a, 0xca, 0x0e, 0x87, 0xd6, 0x58, 0x15, 0x31, 0x14, 0x14, 0xd1, 0x0e,
+	0xa4, 0xae, 0x52, 0xdc, 0x28, 0x58, 0x3f, 0x6a, 0x2a, 0xed, 0x6a, 0x98, 0x9e, 0x1c, 0x34, 0xd7,
+	0x16, 0x6a, 0x5a, 0x20, 0x01, 0xf4, 0x56, 0xc8, 0x85, 0x4a, 0x69, 0xeb, 0x7b, 0x5a, 0x91, 0x7c,
+	0x0c, 0xb6, 0x4a, 0xde, 0xf0, 0xf9, 0xe4, 0x3f, 0xd0, 0x56, 0xc3, 0xa1, 0xda, 0x31, 0xbc, 0x00,
+	0xb8, 0x91, 0x15, 0xc7, 0xcb, 0x04, 0x4b, 0x49, 0x9e, 0x01, 0xc4, 0xf9, 0x52, 0x48, 0xe4, 0xdb,
+	0x95, 0xf5, 0x1a, 0xcd, 0x65, 0x42, 0x9e, 0x82, 0x2b, 0x94, 0xb3, 0x32, 0x9a, 0x06, 0x7a, 0xc2,
+	0x04, 0x87, 0x77, 0x30, 0x54, 0xc0, 0x7c, 0x57, 0xc5, 0x2c, 0x37, 0x44, 0x7c, 0x09, 0x30, 0x67,
+	0x3c, 0x89, 0x84, 0x92, 0x1a, 0x68, 0xc8, 0x66, 0x23, 0xdf, 0x30, 0x6e, 0x08, 0x4b, 0xbd, 0x79,
+	0x7b, 0x54, 0xe9, 0x73, 0x26, 0x64, 0x64, 0x08, 0x6c, 0x32, 0x78, 0x4a, 0x73, 0xa9, 0x14, 0xe1,
+	0x2f, 0x96, 0x49, 0xf2, 0xaa, 0xae, 0xf3, 0xb5, 0x89, 0x78, 0x1f, 0x06, 0xac, 0xae, 0xf3, 0x0c,
+	0x93, 0x68, 0x97, 0xf5, 0x7e, 0xa3, 0xd4, 0x71, 0xe4, 0x5b, 0x78, 0x47, 0xb6, 0x4b, 0xd2, 0x94,
+	0x63, 0x1e, 0x9c, 0xe7, 0x0f, 0x70, 0x68, 0x7f, 0x9d, 0xe8, 0x50, 0xee, 0xc9, 0x61, 0x06, 0x70,
+	0xa5, 0x76, 0xd0, 0xa4, 0x3f, 0x01, 0xaf, 0xc8, 0xca, 0xbd, 0xd4, 0x6e, 0x91, 0x95, 0x26, 0xed,
+	0x0b, 0x70, 0x9a, 0x65, 0xee, 0x3c, 0xcc, 0x0b, 0x63, 0x25, 0xef, 0x81, 0x13, 0x57, 0x45, 0x91,
+	0x49, 0xbd, 0x4f, 0x36, 0x6d, 0xa4, 0xf0, 0x37, 0x45, 0x36, 0xed, 0xba, 0x83, 0xea, 0x14, 0x8e,
+	0xb6, 0x80, 0x0e, 0xcf, 0x83, 0x83, 0x0e, 0xd4, 0x43, 0x68, 0x0a, 0x37, 0x6e, 0x3b, 0xe4, 0xec,
+	0xfc, 0x2f, 0x39, 0xbf, 0x00, 0xf3, 0xb6, 0x34, 0xf8, 0x98, 0x77, 0xf6, 0xe9, 0xc1, 0xed, 0xdb,
+	0xce, 0x29, 0x14, 0x9b, 0xf3, 0xd9, 0x2b, 0xf0, 0x36, 0x79, 0x09, 0x80, 0xf3, 0x7d, 0xc5, 0x0b,
+	0x96, 0x8f, 0x1e, 0x11, 0x1f, 0x5c, 0x3d, 0xab, 0xac, 0x9c, 0x8d, 0x2c, 0x32, 0x00, 0x6f, 0xf3,
+	0x4a, 0x8e, 0x3a, 0xa4, 0x0f, 0x3d, 0x75, 0x9f, 0xb2, 0x75, 0xbf, 0x3a, 0xfb, 0xfd, 0xfe, 0xd4,
+	0xfa, 0xf3, 0xfe, 0xd4, 0xfa, 0xeb, 0xfe, 0xd4, 0xfa, 0xf5, 0xef, 0xd3, 0x47, 0x10, 0xc4, 0x55,
+	0x31, 0xad, 0xb3, 0x72, 0x16, 0xb3, 0x7a, 0x2a, 0xb3, 0xc5, 0x6a, 0xba, 0x58, 0xe9, 0xdf, 0xcc,
+	0x9d, 0xa3, 0x3f, 0x9f, 0xfc, 0x1b, 0x00, 0x00, 0xff, 0xff, 0x6d, 0xac, 0x3c, 0x58, 0xb0, 0x06,
+	0x00, 0x00,
 }
diff --git a/vendor/github.com/pingcap/kvproto/pkg/tikvpb/tikvpb.pb.go b/vendor/github.com/pingcap/kvproto/pkg/tikvpb/tikvpb.pb.go
index 47239e8a9ce28..05dd50e6906d9 100644
--- a/vendor/github.com/pingcap/kvproto/pkg/tikvpb/tikvpb.pb.go
+++ b/vendor/github.com/pingcap/kvproto/pkg/tikvpb/tikvpb.pb.go
@@ -66,10 +66,14 @@ type TikvClient interface {
 	KvDeleteRange(ctx context.Context, in *kvrpcpb.DeleteRangeRequest, opts ...grpc.CallOption) (*kvrpcpb.DeleteRangeResponse, error)
 	// RawKV commands.
 	RawGet(ctx context.Context, in *kvrpcpb.RawGetRequest, opts ...grpc.CallOption) (*kvrpcpb.RawGetResponse, error)
+	RawBatchGet(ctx context.Context, in *kvrpcpb.RawBatchGetRequest, opts ...grpc.CallOption) (*kvrpcpb.RawBatchGetResponse, error)
 	RawPut(ctx context.Context, in *kvrpcpb.RawPutRequest, opts ...grpc.CallOption) (*kvrpcpb.RawPutResponse, error)
+	RawBatchPut(ctx context.Context, in *kvrpcpb.RawBatchPutRequest, opts ...grpc.CallOption) (*kvrpcpb.RawBatchPutResponse, error)
 	RawDelete(ctx context.Context, in *kvrpcpb.RawDeleteRequest, opts ...grpc.CallOption) (*kvrpcpb.RawDeleteResponse, error)
+	RawBatchDelete(ctx context.Context, in *kvrpcpb.RawBatchDeleteRequest, opts ...grpc.CallOption) (*kvrpcpb.RawBatchDeleteResponse, error)
 	RawScan(ctx context.Context, in *kvrpcpb.RawScanRequest, opts ...grpc.CallOption) (*kvrpcpb.RawScanResponse, error)
 	RawDeleteRange(ctx context.Context, in *kvrpcpb.RawDeleteRangeRequest, opts ...grpc.CallOption) (*kvrpcpb.RawDeleteRangeResponse, error)
+	RawBatchScan(ctx context.Context, in *kvrpcpb.RawBatchScanRequest, opts ...grpc.CallOption) (*kvrpcpb.RawBatchScanResponse, error)
 	// SQL push down commands.
 	Coprocessor(ctx context.Context, in *coprocessor.Request, opts ...grpc.CallOption) (*coprocessor.Response, error)
 	CoprocessorStream(ctx context.Context, in *coprocessor.Request, opts ...grpc.CallOption) (Tikv_CoprocessorStreamClient, error)
@@ -208,6 +212,15 @@ func (c *tikvClient) RawGet(ctx context.Context, in *kvrpcpb.RawGetRequest, opts
 	return out, nil
 }
 
+func (c *tikvClient) RawBatchGet(ctx context.Context, in *kvrpcpb.RawBatchGetRequest, opts ...grpc.CallOption) (*kvrpcpb.RawBatchGetResponse, error) {
+	out := new(kvrpcpb.RawBatchGetResponse)
+	err := grpc.Invoke(ctx, "/tikvpb.Tikv/RawBatchGet", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 func (c *tikvClient) RawPut(ctx context.Context, in *kvrpcpb.RawPutRequest, opts ...grpc.CallOption) (*kvrpcpb.RawPutResponse, error) {
 	out := new(kvrpcpb.RawPutResponse)
 	err := grpc.Invoke(ctx, "/tikvpb.Tikv/RawPut", in, out, c.cc, opts...)
@@ -217,6 +230,15 @@ func (c *tikvClient) RawPut(ctx context.Context, in *kvrpcpb.RawPutRequest, opts
 	return out, nil
 }
 
+func (c *tikvClient) RawBatchPut(ctx context.Context, in *kvrpcpb.RawBatchPutRequest, opts ...grpc.CallOption) (*kvrpcpb.RawBatchPutResponse, error) {
+	out := new(kvrpcpb.RawBatchPutResponse)
+	err := grpc.Invoke(ctx, "/tikvpb.Tikv/RawBatchPut", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 func (c *tikvClient) RawDelete(ctx context.Context, in *kvrpcpb.RawDeleteRequest, opts ...grpc.CallOption) (*kvrpcpb.RawDeleteResponse, error) {
 	out := new(kvrpcpb.RawDeleteResponse)
 	err := grpc.Invoke(ctx, "/tikvpb.Tikv/RawDelete", in, out, c.cc, opts...)
@@ -226,6 +248,15 @@ func (c *tikvClient) RawDelete(ctx context.Context, in *kvrpcpb.RawDeleteRequest
 	return out, nil
 }
 
+func (c *tikvClient) RawBatchDelete(ctx context.Context, in *kvrpcpb.RawBatchDeleteRequest, opts ...grpc.CallOption) (*kvrpcpb.RawBatchDeleteResponse, error) {
+	out := new(kvrpcpb.RawBatchDeleteResponse)
+	err := grpc.Invoke(ctx, "/tikvpb.Tikv/RawBatchDelete", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 func (c *tikvClient) RawScan(ctx context.Context, in *kvrpcpb.RawScanRequest, opts ...grpc.CallOption) (*kvrpcpb.RawScanResponse, error) {
 	out := new(kvrpcpb.RawScanResponse)
 	err := grpc.Invoke(ctx, "/tikvpb.Tikv/RawScan", in, out, c.cc, opts...)
@@ -244,6 +275,15 @@ func (c *tikvClient) RawDeleteRange(ctx context.Context, in *kvrpcpb.RawDeleteRa
 	return out, nil
 }
 
+func (c *tikvClient) RawBatchScan(ctx context.Context, in *kvrpcpb.RawBatchScanRequest, opts ...grpc.CallOption) (*kvrpcpb.RawBatchScanResponse, error) {
+	out := new(kvrpcpb.RawBatchScanResponse)
+	err := grpc.Invoke(ctx, "/tikvpb.Tikv/RawBatchScan", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 func (c *tikvClient) Coprocessor(ctx context.Context, in *coprocessor.Request, opts ...grpc.CallOption) (*coprocessor.Response, error) {
 	out := new(coprocessor.Response)
 	err := grpc.Invoke(ctx, "/tikvpb.Tikv/Coprocessor", in, out, c.cc, opts...)
@@ -398,10 +438,14 @@ type TikvServer interface {
 	KvDeleteRange(context.Context, *kvrpcpb.DeleteRangeRequest) (*kvrpcpb.DeleteRangeResponse, error)
 	// RawKV commands.
 	RawGet(context.Context, *kvrpcpb.RawGetRequest) (*kvrpcpb.RawGetResponse, error)
+	RawBatchGet(context.Context, *kvrpcpb.RawBatchGetRequest) (*kvrpcpb.RawBatchGetResponse, error)
 	RawPut(context.Context, *kvrpcpb.RawPutRequest) (*kvrpcpb.RawPutResponse, error)
+	RawBatchPut(context.Context, *kvrpcpb.RawBatchPutRequest) (*kvrpcpb.RawBatchPutResponse, error)
 	RawDelete(context.Context, *kvrpcpb.RawDeleteRequest) (*kvrpcpb.RawDeleteResponse, error)
+	RawBatchDelete(context.Context, *kvrpcpb.RawBatchDeleteRequest) (*kvrpcpb.RawBatchDeleteResponse, error)
 	RawScan(context.Context, *kvrpcpb.RawScanRequest) (*kvrpcpb.RawScanResponse, error)
 	RawDeleteRange(context.Context, *kvrpcpb.RawDeleteRangeRequest) (*kvrpcpb.RawDeleteRangeResponse, error)
+	RawBatchScan(context.Context, *kvrpcpb.RawBatchScanRequest) (*kvrpcpb.RawBatchScanResponse, error)
 	// SQL push down commands.
 	Coprocessor(context.Context, *coprocessor.Request) (*coprocessor.Response, error)
 	CoprocessorStream(*coprocessor.Request, Tikv_CoprocessorStreamServer) error
@@ -653,6 +697,24 @@ func _Tikv_RawGet_Handler(srv interface{}, ctx context.Context, dec func(interfa
 	return interceptor(ctx, in, info, handler)
 }
 
+func _Tikv_RawBatchGet_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(kvrpcpb.RawBatchGetRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(TikvServer).RawBatchGet(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/tikvpb.Tikv/RawBatchGet",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(TikvServer).RawBatchGet(ctx, req.(*kvrpcpb.RawBatchGetRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 func _Tikv_RawPut_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 	in := new(kvrpcpb.RawPutRequest)
 	if err := dec(in); err != nil {
@@ -671,6 +733,24 @@ func _Tikv_RawPut_Handler(srv interface{}, ctx context.Context, dec func(interfa
 	return interceptor(ctx, in, info, handler)
 }
 
+func _Tikv_RawBatchPut_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(kvrpcpb.RawBatchPutRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(TikvServer).RawBatchPut(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/tikvpb.Tikv/RawBatchPut",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(TikvServer).RawBatchPut(ctx, req.(*kvrpcpb.RawBatchPutRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 func _Tikv_RawDelete_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 	in := new(kvrpcpb.RawDeleteRequest)
 	if err := dec(in); err != nil {
@@ -689,6 +769,24 @@ func _Tikv_RawDelete_Handler(srv interface{}, ctx context.Context, dec func(inte
 	return interceptor(ctx, in, info, handler)
 }
 
+func _Tikv_RawBatchDelete_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(kvrpcpb.RawBatchDeleteRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(TikvServer).RawBatchDelete(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/tikvpb.Tikv/RawBatchDelete",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(TikvServer).RawBatchDelete(ctx, req.(*kvrpcpb.RawBatchDeleteRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 func _Tikv_RawScan_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 	in := new(kvrpcpb.RawScanRequest)
 	if err := dec(in); err != nil {
@@ -725,6 +823,24 @@ func _Tikv_RawDeleteRange_Handler(srv interface{}, ctx context.Context, dec func
 	return interceptor(ctx, in, info, handler)
 }
 
+func _Tikv_RawBatchScan_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(kvrpcpb.RawBatchScanRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(TikvServer).RawBatchScan(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/tikvpb.Tikv/RawBatchScan",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(TikvServer).RawBatchScan(ctx, req.(*kvrpcpb.RawBatchScanRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 func _Tikv_Coprocessor_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 	in := new(coprocessor.Request)
 	if err := dec(in); err != nil {
@@ -926,14 +1042,26 @@ var _Tikv_serviceDesc = grpc.ServiceDesc{
 			MethodName: "RawGet",
 			Handler:    _Tikv_RawGet_Handler,
 		},
+		{
+			MethodName: "RawBatchGet",
+			Handler:    _Tikv_RawBatchGet_Handler,
+		},
 		{
 			MethodName: "RawPut",
 			Handler:    _Tikv_RawPut_Handler,
 		},
+		{
+			MethodName: "RawBatchPut",
+			Handler:    _Tikv_RawBatchPut_Handler,
+		},
 		{
 			MethodName: "RawDelete",
 			Handler:    _Tikv_RawDelete_Handler,
 		},
+		{
+			MethodName: "RawBatchDelete",
+			Handler:    _Tikv_RawBatchDelete_Handler,
+		},
 		{
 			MethodName: "RawScan",
 			Handler:    _Tikv_RawScan_Handler,
@@ -942,6 +1070,10 @@ var _Tikv_serviceDesc = grpc.ServiceDesc{
 			MethodName: "RawDeleteRange",
 			Handler:    _Tikv_RawDeleteRange_Handler,
 		},
+		{
+			MethodName: "RawBatchScan",
+			Handler:    _Tikv_RawBatchScan_Handler,
+		},
 		{
 			MethodName: "Coprocessor",
 			Handler:    _Tikv_Coprocessor_Handler,
@@ -982,45 +1114,48 @@ var _Tikv_serviceDesc = grpc.ServiceDesc{
 func init() { proto.RegisterFile("tikvpb.proto", fileDescriptorTikvpb) }
 
 var fileDescriptorTikvpb = []byte{
-	// 626 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x94, 0x95, 0xdd, 0x6e, 0xd3, 0x3e,
-	0x18, 0xc6, 0x37, 0xa9, 0xff, 0xfe, 0xb7, 0x77, 0x1d, 0x30, 0x77, 0x40, 0x17, 0xb6, 0xf2, 0x71,
-	0x84, 0x38, 0x28, 0x9f, 0x12, 0x07, 0x7c, 0x08, 0x9a, 0x4a, 0x08, 0xb2, 0x4a, 0x53, 0xb3, 0x13,
-	0x8e, 0x90, 0x1b, 0x99, 0xb4, 0x6a, 0x1a, 0x07, 0xc7, 0xcd, 0xb4, 0x3b, 0xe1, 0x92, 0x38, 0xe4,
-	0x12, 0x10, 0xdc, 0x03, 0xc7, 0xbc, 0x49, 0x6a, 0xc7, 0x6e, 0x5a, 0x24, 0x0e, 0xaa, 0xc6, 0xbf,
-	0xe7, 0x7d, 0x1e, 0x5b, 0xf6, 0x1b, 0x07, 0x5a, 0x72, 0x3a, 0xcb, 0x92, 0x71, 0x2f, 0x11, 0x5c,
-	0x72, 0xd2, 0x2c, 0x47, 0xce, 0x41, 0xc0, 0x11, 0x04, 0x2c, 0x4d, 0xb9, 0x28, 0x25, 0x67, 0x7f,
-	0x96, 0x89, 0x24, 0x50, 0x95, 0x4e, 0x5b, 0xd0, 0xcf, 0xf2, 0x53, 0xca, 0x44, 0xc6, 0x84, 0x86,
-	0x87, 0x21, 0x0f, 0x79, 0xf1, 0xf8, 0x30, 0x7f, 0x2a, 0xe9, 0x93, 0xdf, 0x2d, 0x68, 0x9c, 0x63,
-	0x2e, 0x79, 0x06, 0xff, 0x79, 0xd9, 0x3b, 0x26, 0x49, 0xbb, 0xa7, 0xc2, 0x70, 0x34, 0x62, 0x5f,
-	0x16, 0x2c, 0x95, 0xce, 0xa1, 0x0d, 0xd3, 0x84, 0xc7, 0x29, 0xbb, 0xb7, 0x45, 0x9e, 0x43, 0xd3,
-	0xcb, 0xfc, 0x80, 0xc6, 0xa4, 0xaa, 0xc8, 0x87, 0xca, 0x77, 0x7d, 0x85, 0x6a, 0xa3, 0x0b, 0xe0,
-	0x65, 0x67, 0x82, 0x5d, 0x88, 0xa9, 0x64, 0xa4, 0xa3, 0xcb, 0x14, 0x52, 0x01, 0x47, 0x6b, 0x14,
-	0x1d, 0xf2, 0x0a, 0x76, 0xbc, 0xcc, 0xe5, 0xf3, 0xf9, 0x54, 0x92, 0x1b, 0xba, 0xb0, 0x04, 0x2a,
-	0xe0, 0x66, 0x8d, 0xdb, 0xf6, 0xf7, 0xf3, 0x84, 0x0b, 0xd3, 0x5e, 0x82, 0xba, 0x5d, 0x71, 0x6d,
-	0x7f, 0x03, 0xbb, 0x38, 0x7b, 0xc4, 0x68, 0xbc, 0x48, 0x88, 0x31, 0x4d, 0x49, 0x54, 0x40, 0xa7,
-	0x2e, 0xd8, 0x9b, 0xd0, 0xa7, 0x32, 0x98, 0xe4, 0x1b, 0x5f, 0x55, 0x2a, 0x54, 0xdf, 0x84, 0x4a,
-	0xd1, 0x21, 0x23, 0xb8, 0xba, 0x0c, 0x19, 0xf1, 0x28, 0x1a, 0xd3, 0x60, 0x46, 0x4e, 0xec, 0x7a,
-	0xc5, 0x55, 0x5c, 0x77, 0x93, 0x6c, 0x2f, 0x2c, 0x3f, 0xb1, 0x53, 0x8e, 0x71, 0x1d, 0xeb, 0x10,
-	0x73, 0x54, 0x5f, 0x58, 0xa5, 0xe8, 0x90, 0x53, 0xd8, 0xf7, 0x32, 0x1c, 0xf3, 0x28, 0x63, 0x45,
-	0xce, 0x2d, 0x5d, 0x6d, 0x50, 0x15, 0x75, 0xbc, 0x5e, 0xd4, 0x69, 0x8f, 0xa1, 0x81, 0xfd, 0xe9,
-	0x12, 0x52, 0x75, 0xa2, 0xab, 0xbc, 0x6d, 0x8b, 0xd9, 0x0b, 0x18, 0xb0, 0x88, 0x61, 0xd3, 0xd0,
-	0x38, 0x64, 0xc6, 0x02, 0x0c, 0x5a, 0x5f, 0x80, 0x25, 0xea, 0xb4, 0x17, 0xd0, 0x1c, 0xd1, 0x8b,
-	0xfc, 0xa0, 0xaa, 0x5e, 0x29, 0x41, 0xbd, 0x57, 0x14, 0x5f, 0x31, 0x9f, 0x2d, 0x56, 0xcc, 0x08,
-	0xd6, 0x9a, 0x0b, 0xae, 0xcd, 0x03, 0xd8, 0x45, 0x56, 0xae, 0x8a, 0x1c, 0x99, 0x75, 0xcb, 0x95,
-	0x2e, 0x23, 0x9c, 0x75, 0x92, 0x4e, 0x79, 0x0d, 0xff, 0x23, 0x2e, 0xde, 0x55, 0x6b, 0x2e, 0xf3,
-	0x75, 0xed, 0xd4, 0x05, 0xed, 0xf7, 0xe1, 0x4a, 0x15, 0x5b, 0x6c, 0x67, 0x77, 0xcd, 0x7c, 0xe6,
-	0x8e, 0xde, 0xde, 0xa8, 0xeb, 0xd0, 0x97, 0xb0, 0xe7, 0x56, 0xb7, 0x19, 0x5e, 0x22, 0xe6, 0xdd,
-	0x56, 0x5d, 0x22, 0x36, 0x35, 0x36, 0xe6, 0xc0, 0x70, 0xfb, 0x52, 0x30, 0x3a, 0xff, 0xc7, 0x8c,
-	0x47, 0xdb, 0x78, 0x36, 0x8d, 0x11, 0xde, 0x97, 0xc4, 0xe9, 0xd9, 0xd7, 0x66, 0x0e, 0x87, 0x58,
-	0x4f, 0x43, 0x86, 0x1d, 0x66, 0x6b, 0x03, 0x1e, 0xa3, 0xf9, 0xfe, 0x36, 0x79, 0x0b, 0x3b, 0x7e,
-	0x4c, 0x93, 0x74, 0xc2, 0x25, 0x39, 0x5e, 0x29, 0x52, 0x82, 0x3b, 0x59, 0xc4, 0xb3, 0xcd, 0x11,
-	0x1f, 0x60, 0xcf, 0x4f, 0xa2, 0xfc, 0x66, 0x0a, 0xa7, 0x3c, 0x36, 0x9a, 0xd4, 0xa0, 0xf5, 0x26,
-	0xb5, 0x44, 0xbd, 0x23, 0x43, 0x68, 0x0d, 0xb3, 0x20, 0xc0, 0xe6, 0xeb, 0x5f, 0x7a, 0xec, 0x92,
-	0x54, 0xf5, 0x26, 0x56, 0x69, 0x27, 0x1b, 0x54, 0x1d, 0xf7, 0x11, 0xae, 0x69, 0xc5, 0x97, 0x54,
-	0xc8, 0xf3, 0x94, 0xdc, 0xa9, 0x9b, 0x96, 0x92, 0x8a, 0xbd, 0xfb, 0x97, 0x0a, 0x15, 0xdd, 0x7f,
-	0xf0, 0xed, 0x67, 0x77, 0xfb, 0x3b, 0xfe, 0x7e, 0xe0, 0xef, 0xeb, 0xaf, 0xee, 0x16, 0x74, 0x02,
-	0x3e, 0xef, 0x25, 0xd3, 0x38, 0x0c, 0x68, 0xd2, 0xcb, 0xbf, 0x75, 0x18, 0x53, 0x7c, 0xa4, 0xc6,
-	0xcd, 0xe2, 0xef, 0xe9, 0x9f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x42, 0x1e, 0x29, 0x02, 0x10, 0x07,
-	0x00, 0x00,
+	// 682 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x96, 0xdf, 0x4e, 0xd4, 0x40,
+	0x14, 0xc6, 0xd9, 0x04, 0x57, 0x18, 0x40, 0x64, 0x16, 0x75, 0x29, 0x4b, 0x51, 0xae, 0x8c, 0x17,
+	0xf5, 0x6f, 0xe2, 0x05, 0x6a, 0x94, 0x92, 0x6c, 0xa4, 0x90, 0x90, 0x96, 0x1b, 0xaf, 0xcc, 0xd0,
+	0x0c, 0xa5, 0x69, 0xb7, 0x53, 0xa7, 0xb3, 0xb3, 0xe1, 0x4d, 0x7c, 0x0e, 0x9f, 0xc2, 0x4b, 0x1f,
+	0xc1, 0xe0, 0x8b, 0x98, 0xb6, 0x3b, 0xd3, 0x99, 0x4e, 0xd7, 0xc4, 0x2b, 0xda, 0xef, 0x3b, 0xe7,
+	0xd7, 0x8f, 0x39, 0x93, 0x99, 0x05, 0xeb, 0x2c, 0x4e, 0x78, 0x7e, 0xe9, 0xe4, 0x94, 0x30, 0x02,
+	0xfb, 0xf5, 0x9b, 0xb5, 0x15, 0x92, 0x9c, 0x92, 0x10, 0x17, 0x05, 0xa1, 0xb5, 0x65, 0x6d, 0x24,
+	0x9c, 0xe6, 0xa1, 0xa8, 0xb4, 0x06, 0x14, 0x5d, 0xb1, 0xaf, 0x05, 0xa6, 0x1c, 0x53, 0x29, 0x6e,
+	0x47, 0x24, 0x22, 0xd5, 0xe3, 0xf3, 0xf2, 0xa9, 0x56, 0x5f, 0xfd, 0xd8, 0x04, 0xcb, 0x17, 0x71,
+	0xc2, 0xe1, 0x1b, 0x70, 0xc7, 0xe3, 0x63, 0xcc, 0xe0, 0xc0, 0x11, 0xb0, 0x31, 0x66, 0x3e, 0xfe,
+	0x36, 0xc5, 0x05, 0xb3, 0xb6, 0x75, 0xb1, 0xc8, 0x49, 0x56, 0xe0, 0x83, 0x25, 0xf8, 0x16, 0xf4,
+	0x3d, 0x1e, 0x84, 0x28, 0x83, 0x4d, 0x45, 0xf9, 0x2a, 0xfa, 0x1e, 0xb4, 0x54, 0xd9, 0xe8, 0x02,
+	0xe0, 0xf1, 0x73, 0x8a, 0x67, 0x34, 0x66, 0x18, 0x0e, 0x65, 0x99, 0x90, 0x04, 0x60, 0xa7, 0xc3,
+	0x91, 0x90, 0xf7, 0x60, 0xc5, 0xe3, 0x2e, 0x99, 0x4c, 0x62, 0x06, 0x1f, 0xca, 0xc2, 0x5a, 0x10,
+	0x80, 0x47, 0x86, 0xae, 0xb7, 0x7f, 0x9e, 0xe4, 0x84, 0xaa, 0xed, 0xb5, 0x60, 0xb6, 0x0b, 0x5d,
+	0xb6, 0x7f, 0x04, 0xab, 0x1e, 0x77, 0x53, 0x8c, 0xb2, 0x69, 0x0e, 0x95, 0xcf, 0xd4, 0x8a, 0x00,
+	0x0c, 0x4d, 0x43, 0x5f, 0x84, 0x23, 0xc4, 0xc2, 0xeb, 0x72, 0xe1, 0x9b, 0x4a, 0x21, 0x99, 0x8b,
+	0xd0, 0x38, 0x12, 0xe2, 0x83, 0xcd, 0x39, 0xc4, 0x27, 0x69, 0x7a, 0x89, 0xc2, 0x04, 0xee, 0xe9,
+	0xf5, 0x42, 0x17, 0x38, 0x7b, 0x91, 0xad, 0x07, 0x2b, 0x27, 0x76, 0x4a, 0xc2, 0x44, 0x09, 0x26,
+	0x24, 0x33, 0x58, 0xe3, 0x48, 0xc8, 0x29, 0xd8, 0xf0, 0xb8, 0x8f, 0x0b, 0x92, 0x72, 0x5c, 0x71,
+	0x76, 0x65, 0xb5, 0xa2, 0x0a, 0xd4, 0xa8, 0xdb, 0x94, 0xb4, 0x97, 0x60, 0xd9, 0xe3, 0x63, 0x17,
+	0xc2, 0x66, 0x27, 0xba, 0xa2, 0x77, 0xa0, 0x69, 0x7a, 0x80, 0x63, 0x9c, 0x62, 0x86, 0x7d, 0x94,
+	0x45, 0x58, 0x09, 0xa0, 0xa8, 0x66, 0x00, 0xcd, 0x94, 0xb4, 0x43, 0xd0, 0xf7, 0xd1, 0xac, 0x1c,
+	0x54, 0xb3, 0x57, 0x6a, 0xc1, 0xdc, 0x2b, 0x42, 0x97, 0xcd, 0x27, 0x60, 0xcd, 0x47, 0x33, 0x39,
+	0xea, 0x5d, 0xb5, 0xb2, 0x3d, 0xed, 0x51, 0xb7, 0xd9, 0x0a, 0x72, 0x3e, 0x6d, 0x05, 0x39, 0x9f,
+	0x76, 0x07, 0xa9, 0xf4, 0xae, 0x20, 0x25, 0xc1, 0x0c, 0xa2, 0x60, 0x46, 0xdd, 0xa6, 0x64, 0x1d,
+	0x83, 0x55, 0x1f, 0xcd, 0xea, 0xd5, 0x82, 0x3b, 0x6a, 0xf1, 0x7c, 0x05, 0xe7, 0x1c, 0xab, 0xcb,
+	0x92, 0x94, 0x00, 0xdc, 0x13, 0xf8, 0x39, 0xca, 0x36, 0xbe, 0xab, 0xf3, 0xf6, 0x17, 0xfa, 0x12,
+	0xfa, 0x01, 0xdc, 0xf5, 0xd1, 0xac, 0x3a, 0x98, 0xb4, 0xc5, 0x50, 0xcf, 0xa6, 0xa1, 0x69, 0xb4,
+	0x42, 0xa9, 0x7b, 0xc7, 0xee, 0xf8, 0x27, 0xd4, 0xed, 0xb3, 0xbf, 0xd0, 0x97, 0xd0, 0x33, 0xb0,
+	0x2e, 0x02, 0x57, 0xc9, 0xcc, 0xf5, 0x55, 0xe3, 0xed, 0x2d, 0x70, 0x25, 0xee, 0x1d, 0x58, 0x73,
+	0x9b, 0x9b, 0x00, 0x6e, 0x3b, 0xea, 0xbd, 0xd0, 0x1c, 0xc0, 0xba, 0xaa, 0x0c, 0x6f, 0x4b, 0xe9,
+	0x0e, 0x18, 0xc5, 0x68, 0xf2, 0x9f, 0x8c, 0x17, 0x3d, 0x78, 0x08, 0x96, 0x7d, 0x74, 0xc5, 0xa0,
+	0xe5, 0xe8, 0x57, 0x4e, 0x29, 0x9e, 0xe1, 0xa2, 0x40, 0x11, 0xb6, 0x06, 0x2d, 0xef, 0x98, 0x64,
+	0xf8, 0x60, 0xe9, 0x69, 0x0f, 0x7e, 0x02, 0x2b, 0x41, 0x86, 0xf2, 0xe2, 0x9a, 0x30, 0x38, 0x6a,
+	0x15, 0x09, 0xc3, 0xbd, 0x9e, 0x66, 0xc9, 0x62, 0xc4, 0x09, 0x58, 0x0b, 0xf2, 0xb4, 0x3c, 0xd5,
+	0xa3, 0x98, 0x64, 0xca, 0x76, 0x56, 0x54, 0x73, 0x3b, 0x6b, 0xa6, 0x3a, 0x9e, 0x33, 0x1e, 0x86,
+	0x63, 0xcc, 0x8e, 0x6e, 0x3c, 0x7c, 0xa3, 0x8c, 0x47, 0x95, 0xcd, 0xf1, 0xe8, 0xae, 0xc4, 0x7d,
+	0x01, 0xf7, 0xa5, 0x13, 0x30, 0x44, 0xd9, 0x45, 0x01, 0x1f, 0x9b, 0x4d, 0x73, 0x4b, 0x60, 0x9f,
+	0xfc, 0xa3, 0x42, 0xa0, 0x8f, 0x9e, 0xfd, 0xbc, 0xb5, 0x7b, 0xbf, 0x6e, 0xed, 0xde, 0xef, 0x5b,
+	0xbb, 0xf7, 0xfd, 0x8f, 0xbd, 0x04, 0x86, 0x21, 0x99, 0x38, 0x79, 0x9c, 0x45, 0x21, 0xca, 0x9d,
+	0xf2, 0x77, 0x82, 0x93, 0xf0, 0xea, 0x82, 0xbf, 0xec, 0x57, 0x7f, 0x5e, 0xff, 0x0d, 0x00, 0x00,
+	0xff, 0xff, 0x1e, 0x48, 0x64, 0x89, 0x4c, 0x08, 0x00, 0x00,
 }