diff --git a/pkg/configpb/configpb.pb.gw.go b/pkg/configpb/configpb.pb.gw.go
index 9b4675b32..c0385b0e4 100644
--- a/pkg/configpb/configpb.pb.gw.go
+++ b/pkg/configpb/configpb.pb.gw.go
@@ -20,7 +20,6 @@ import (
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/grpclog"
-	"google.golang.org/grpc/metadata"
 	"google.golang.org/grpc/status"
 )
 
@@ -31,7 +30,6 @@ var _ status.Status
 var _ = runtime.String
 var _ = utilities.NewDoubleArray
 var _ = descriptor.ForMessage
-var _ = metadata.Join
 
 var (
 	filter_Config_Get_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)}
@@ -57,10 +55,7 @@ func local_request_Config_Get_0(ctx context.Context, marshaler runtime.Marshaler
 	var protoReq GetRequest
 	var metadata runtime.ServerMetadata
 
-	if err := req.ParseForm(); err != nil {
-		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
-	}
-	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Config_Get_0); err != nil {
+	if err := runtime.PopulateQueryParameters(&protoReq, req.URL.Query(), filter_Config_Get_0); err != nil {
 		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
 	}
 
@@ -127,10 +122,7 @@ func local_request_Config_Delete_0(ctx context.Context, marshaler runtime.Marsha
 	var protoReq DeleteRequest
 	var metadata runtime.ServerMetadata
 
-	if err := req.ParseForm(); err != nil {
-		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
-	}
-	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Config_Delete_0); err != nil {
+	if err := runtime.PopulateQueryParameters(&protoReq, req.URL.Query(), filter_Config_Delete_0); err != nil {
 		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
 	}
 
@@ -142,14 +134,11 @@ func local_request_Config_Delete_0(ctx context.Context, marshaler runtime.Marsha
 // RegisterConfigHandlerServer registers the http handlers for service Config to "mux".
 // UnaryRPC     :call ConfigServer directly.
 // StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906.
-// Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterConfigHandlerFromEndpoint instead.
 func RegisterConfigHandlerServer(ctx context.Context, mux *runtime.ServeMux, server ConfigServer) error {
 
 	mux.Handle("GET", pattern_Config_Get_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
 		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
-		var stream runtime.ServerTransportStream
-		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
 		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
 		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
 		if err != nil {
@@ -157,7 +146,6 @@ func RegisterConfigHandlerServer(ctx context.Context, mux *runtime.ServeMux, ser
 			return
 		}
 		resp, md, err := local_request_Config_Get_0(rctx, inboundMarshaler, server, req, pathParams)
-		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
 		ctx = runtime.NewServerMetadataContext(ctx, md)
 		if err != nil {
 			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
@@ -171,8 +159,6 @@ func RegisterConfigHandlerServer(ctx context.Context, mux *runtime.ServeMux, ser
 	mux.Handle("POST", pattern_Config_Update_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
 		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
-		var stream runtime.ServerTransportStream
-		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
 		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
 		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
 		if err != nil {
@@ -180,7 +166,6 @@ func RegisterConfigHandlerServer(ctx context.Context, mux *runtime.ServeMux, ser
 			return
 		}
 		resp, md, err := local_request_Config_Update_0(rctx, inboundMarshaler, server, req, pathParams)
-		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
 		ctx = runtime.NewServerMetadataContext(ctx, md)
 		if err != nil {
 			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
@@ -194,8 +179,6 @@ func RegisterConfigHandlerServer(ctx context.Context, mux *runtime.ServeMux, ser
 	mux.Handle("DELETE", pattern_Config_Delete_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
 		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
-		var stream runtime.ServerTransportStream
-		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
 		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
 		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
 		if err != nil {
@@ -203,7 +186,6 @@ func RegisterConfigHandlerServer(ctx context.Context, mux *runtime.ServeMux, ser
 			return
 		}
 		resp, md, err := local_request_Config_Delete_0(rctx, inboundMarshaler, server, req, pathParams)
-		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
 		ctx = runtime.NewServerMetadataContext(ctx, md)
 		if err != nil {
 			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
diff --git a/pkg/import_sstpb/import_sstpb.pb.go b/pkg/import_sstpb/import_sstpb.pb.go
index 8c077a5d8..15ecb8dd1 100644
--- a/pkg/import_sstpb/import_sstpb.pb.go
+++ b/pkg/import_sstpb/import_sstpb.pb.go
@@ -106,7 +106,7 @@ func (x Pair_OP) String() string {
 }
 
 func (Pair_OP) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_4d076b7935cfab6b, []int{21, 0}
+	return fileDescriptor_4d076b7935cfab6b, []int{26, 0}
 }
 
 type SuspendImportRPCRequest struct {
@@ -405,6 +405,290 @@ func (m *GetModeResponse) GetMode() SwitchMode {
 	return SwitchMode_Normal
 }
 
+type Lease struct {
+	Region *metapb.Region `protobuf:"bytes,1,opt,name=region,proto3" json:"region,omitempty"`
+	// A Random (Version 4) UUID.
+	// This is used by SSTMeta to prevent interference between concurrent imports.
+	Uuid                 []byte   `protobuf:"bytes,3,opt,name=uuid,proto3" json:"uuid,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *Lease) Reset()         { *m = Lease{} }
+func (m *Lease) String() string { return proto.CompactTextString(m) }
+func (*Lease) ProtoMessage()    {}
+func (*Lease) Descriptor() ([]byte, []int) {
+	return fileDescriptor_4d076b7935cfab6b, []int{6}
+}
+func (m *Lease) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *Lease) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_Lease.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *Lease) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Lease.Merge(m, src)
+}
+func (m *Lease) XXX_Size() int {
+	return m.Size()
+}
+func (m *Lease) XXX_DiscardUnknown() {
+	xxx_messageInfo_Lease.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Lease proto.InternalMessageInfo
+
+func (m *Lease) GetRegion() *metapb.Region {
+	if m != nil {
+		return m.Region
+	}
+	return nil
+}
+
+func (m *Lease) GetUuid() []byte {
+	if m != nil {
+		return m.Uuid
+	}
+	return nil
+}
+
+// AcquireLease notify TiKV to allow importing data that are described in the
+// request.
+// The allowance is effective during the time span [now, now+lease].
+type AcquireLease struct {
+	Lease *Lease `protobuf:"bytes,1,opt,name=lease,proto3" json:"lease,omitempty"`
+	// Time to alive in seconds.
+	Ttl                  uint64   `protobuf:"varint,2,opt,name=ttl,proto3" json:"ttl,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *AcquireLease) Reset()         { *m = AcquireLease{} }
+func (m *AcquireLease) String() string { return proto.CompactTextString(m) }
+func (*AcquireLease) ProtoMessage()    {}
+func (*AcquireLease) Descriptor() ([]byte, []int) {
+	return fileDescriptor_4d076b7935cfab6b, []int{7}
+}
+func (m *AcquireLease) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *AcquireLease) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_AcquireLease.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *AcquireLease) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_AcquireLease.Merge(m, src)
+}
+func (m *AcquireLease) XXX_Size() int {
+	return m.Size()
+}
+func (m *AcquireLease) XXX_DiscardUnknown() {
+	xxx_messageInfo_AcquireLease.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_AcquireLease proto.InternalMessageInfo
+
+func (m *AcquireLease) GetLease() *Lease {
+	if m != nil {
+		return m.Lease
+	}
+	return nil
+}
+
+func (m *AcquireLease) GetTtl() uint64 {
+	if m != nil {
+		return m.Ttl
+	}
+	return 0
+}
+
+// ReleaseLease expires leases immediately.
+type ReleaseLease struct {
+	Lease                *Lease   `protobuf:"bytes,1,opt,name=lease,proto3" json:"lease,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *ReleaseLease) Reset()         { *m = ReleaseLease{} }
+func (m *ReleaseLease) String() string { return proto.CompactTextString(m) }
+func (*ReleaseLease) ProtoMessage()    {}
+func (*ReleaseLease) Descriptor() ([]byte, []int) {
+	return fileDescriptor_4d076b7935cfab6b, []int{8}
+}
+func (m *ReleaseLease) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *ReleaseLease) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_ReleaseLease.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *ReleaseLease) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ReleaseLease.Merge(m, src)
+}
+func (m *ReleaseLease) XXX_Size() int {
+	return m.Size()
+}
+func (m *ReleaseLease) XXX_DiscardUnknown() {
+	xxx_messageInfo_ReleaseLease.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ReleaseLease proto.InternalMessageInfo
+
+func (m *ReleaseLease) GetLease() *Lease {
+	if m != nil {
+		return m.Lease
+	}
+	return nil
+}
+
+type LeaseRequest struct {
+	Acquire              []*AcquireLease `protobuf:"bytes,1,rep,name=acquire,proto3" json:"acquire,omitempty"`
+	Release              []*ReleaseLease `protobuf:"bytes,2,rep,name=release,proto3" json:"release,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
+	XXX_unrecognized     []byte          `json:"-"`
+	XXX_sizecache        int32           `json:"-"`
+}
+
+func (m *LeaseRequest) Reset()         { *m = LeaseRequest{} }
+func (m *LeaseRequest) String() string { return proto.CompactTextString(m) }
+func (*LeaseRequest) ProtoMessage()    {}
+func (*LeaseRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptor_4d076b7935cfab6b, []int{9}
+}
+func (m *LeaseRequest) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *LeaseRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_LeaseRequest.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *LeaseRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_LeaseRequest.Merge(m, src)
+}
+func (m *LeaseRequest) XXX_Size() int {
+	return m.Size()
+}
+func (m *LeaseRequest) XXX_DiscardUnknown() {
+	xxx_messageInfo_LeaseRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_LeaseRequest proto.InternalMessageInfo
+
+func (m *LeaseRequest) GetAcquire() []*AcquireLease {
+	if m != nil {
+		return m.Acquire
+	}
+	return nil
+}
+
+func (m *LeaseRequest) GetRelease() []*ReleaseLease {
+	if m != nil {
+		return m.Release
+	}
+	return nil
+}
+
+type LeaseResponse struct {
+	// The timestamp when the leases take effect (starting from the unix epoch
+	// in seconds)
+	Timestamp            uint64   `protobuf:"varint,1,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
+	Acquired             []*Lease `protobuf:"bytes,2,rep,name=acquired,proto3" json:"acquired,omitempty"`
+	Released             []*Lease `protobuf:"bytes,3,rep,name=released,proto3" json:"released,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *LeaseResponse) Reset()         { *m = LeaseResponse{} }
+func (m *LeaseResponse) String() string { return proto.CompactTextString(m) }
+func (*LeaseResponse) ProtoMessage()    {}
+func (*LeaseResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor_4d076b7935cfab6b, []int{10}
+}
+func (m *LeaseResponse) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *LeaseResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_LeaseResponse.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *LeaseResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_LeaseResponse.Merge(m, src)
+}
+func (m *LeaseResponse) XXX_Size() int {
+	return m.Size()
+}
+func (m *LeaseResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_LeaseResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_LeaseResponse proto.InternalMessageInfo
+
+func (m *LeaseResponse) GetTimestamp() uint64 {
+	if m != nil {
+		return m.Timestamp
+	}
+	return 0
+}
+
+func (m *LeaseResponse) GetAcquired() []*Lease {
+	if m != nil {
+		return m.Acquired
+	}
+	return nil
+}
+
+func (m *LeaseResponse) GetReleased() []*Lease {
+	if m != nil {
+		return m.Released
+	}
+	return nil
+}
+
 type Range struct {
 	Start                []byte   `protobuf:"bytes,1,opt,name=start,proto3" json:"start,omitempty"`
 	End                  []byte   `protobuf:"bytes,2,opt,name=end,proto3" json:"end,omitempty"`
@@ -417,7 +701,7 @@ func (m *Range) Reset()         { *m = Range{} }
 func (m *Range) String() string { return proto.CompactTextString(m) }
 func (*Range) ProtoMessage()    {}
 func (*Range) Descriptor() ([]byte, []int) {
-	return fileDescriptor_4d076b7935cfab6b, []int{6}
+	return fileDescriptor_4d076b7935cfab6b, []int{11}
 }
 func (m *Range) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -486,7 +770,7 @@ func (m *SSTMeta) Reset()         { *m = SSTMeta{} }
 func (m *SSTMeta) String() string { return proto.CompactTextString(m) }
 func (*SSTMeta) ProtoMessage()    {}
 func (*SSTMeta) Descriptor() ([]byte, []int) {
-	return fileDescriptor_4d076b7935cfab6b, []int{7}
+	return fileDescriptor_4d076b7935cfab6b, []int{12}
 }
 func (m *SSTMeta) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -614,7 +898,7 @@ func (m *RewriteRule) Reset()         { *m = RewriteRule{} }
 func (m *RewriteRule) String() string { return proto.CompactTextString(m) }
 func (*RewriteRule) ProtoMessage()    {}
 func (*RewriteRule) Descriptor() ([]byte, []int) {
-	return fileDescriptor_4d076b7935cfab6b, []int{8}
+	return fileDescriptor_4d076b7935cfab6b, []int{13}
 }
 func (m *RewriteRule) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -678,7 +962,7 @@ func (m *UploadRequest) Reset()         { *m = UploadRequest{} }
 func (m *UploadRequest) String() string { return proto.CompactTextString(m) }
 func (*UploadRequest) ProtoMessage()    {}
 func (*UploadRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_4d076b7935cfab6b, []int{9}
+	return fileDescriptor_4d076b7935cfab6b, []int{14}
 }
 func (m *UploadRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -753,16 +1037,17 @@ func (*UploadRequest) XXX_OneofWrappers() []interface{} {
 }
 
 type UploadResponse struct {
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
+	Error                *errorpb.Error `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
+	XXX_unrecognized     []byte         `json:"-"`
+	XXX_sizecache        int32          `json:"-"`
 }
 
 func (m *UploadResponse) Reset()         { *m = UploadResponse{} }
 func (m *UploadResponse) String() string { return proto.CompactTextString(m) }
 func (*UploadResponse) ProtoMessage()    {}
 func (*UploadResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_4d076b7935cfab6b, []int{10}
+	return fileDescriptor_4d076b7935cfab6b, []int{15}
 }
 func (m *UploadResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -791,6 +1076,13 @@ func (m *UploadResponse) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_UploadResponse proto.InternalMessageInfo
 
+func (m *UploadResponse) GetError() *errorpb.Error {
+	if m != nil {
+		return m.Error
+	}
+	return nil
+}
+
 type IngestRequest struct {
 	Context              *kvrpcpb.Context `protobuf:"bytes,1,opt,name=context,proto3" json:"context,omitempty"`
 	Sst                  *SSTMeta         `protobuf:"bytes,2,opt,name=sst,proto3" json:"sst,omitempty"`
@@ -803,7 +1095,7 @@ func (m *IngestRequest) Reset()         { *m = IngestRequest{} }
 func (m *IngestRequest) String() string { return proto.CompactTextString(m) }
 func (*IngestRequest) ProtoMessage()    {}
 func (*IngestRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_4d076b7935cfab6b, []int{11}
+	return fileDescriptor_4d076b7935cfab6b, []int{16}
 }
 func (m *IngestRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -858,7 +1150,7 @@ func (m *MultiIngestRequest) Reset()         { *m = MultiIngestRequest{} }
 func (m *MultiIngestRequest) String() string { return proto.CompactTextString(m) }
 func (*MultiIngestRequest) ProtoMessage()    {}
 func (*MultiIngestRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_4d076b7935cfab6b, []int{12}
+	return fileDescriptor_4d076b7935cfab6b, []int{17}
 }
 func (m *MultiIngestRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -912,7 +1204,7 @@ func (m *IngestResponse) Reset()         { *m = IngestResponse{} }
 func (m *IngestResponse) String() string { return proto.CompactTextString(m) }
 func (*IngestResponse) ProtoMessage()    {}
 func (*IngestResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_4d076b7935cfab6b, []int{13}
+	return fileDescriptor_4d076b7935cfab6b, []int{18}
 }
 func (m *IngestResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -964,7 +1256,7 @@ func (m *CompactRequest) Reset()         { *m = CompactRequest{} }
 func (m *CompactRequest) String() string { return proto.CompactTextString(m) }
 func (*CompactRequest) ProtoMessage()    {}
 func (*CompactRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_4d076b7935cfab6b, []int{14}
+	return fileDescriptor_4d076b7935cfab6b, []int{19}
 }
 func (m *CompactRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1024,7 +1316,7 @@ func (m *CompactResponse) Reset()         { *m = CompactResponse{} }
 func (m *CompactResponse) String() string { return proto.CompactTextString(m) }
 func (*CompactResponse) ProtoMessage()    {}
 func (*CompactResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_4d076b7935cfab6b, []int{15}
+	return fileDescriptor_4d076b7935cfab6b, []int{20}
 }
 func (m *CompactResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1100,7 +1392,7 @@ func (m *DownloadRequest) Reset()         { *m = DownloadRequest{} }
 func (m *DownloadRequest) String() string { return proto.CompactTextString(m) }
 func (*DownloadRequest) ProtoMessage()    {}
 func (*DownloadRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_4d076b7935cfab6b, []int{16}
+	return fileDescriptor_4d076b7935cfab6b, []int{21}
 }
 func (m *DownloadRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1221,7 +1513,7 @@ func (m *Error) Reset()         { *m = Error{} }
 func (m *Error) String() string { return proto.CompactTextString(m) }
 func (*Error) ProtoMessage()    {}
 func (*Error) Descriptor() ([]byte, []int) {
-	return fileDescriptor_4d076b7935cfab6b, []int{17}
+	return fileDescriptor_4d076b7935cfab6b, []int{22}
 }
 func (m *Error) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1290,7 +1582,7 @@ func (m *DownloadResponse) Reset()         { *m = DownloadResponse{} }
 func (m *DownloadResponse) String() string { return proto.CompactTextString(m) }
 func (*DownloadResponse) ProtoMessage()    {}
 func (*DownloadResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_4d076b7935cfab6b, []int{18}
+	return fileDescriptor_4d076b7935cfab6b, []int{23}
 }
 func (m *DownloadResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1373,7 +1665,7 @@ func (m *SetDownloadSpeedLimitRequest) Reset()         { *m = SetDownloadSpeedLi
 func (m *SetDownloadSpeedLimitRequest) String() string { return proto.CompactTextString(m) }
 func (*SetDownloadSpeedLimitRequest) ProtoMessage()    {}
 func (*SetDownloadSpeedLimitRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_4d076b7935cfab6b, []int{19}
+	return fileDescriptor_4d076b7935cfab6b, []int{24}
 }
 func (m *SetDownloadSpeedLimitRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1419,7 +1711,7 @@ func (m *SetDownloadSpeedLimitResponse) Reset()         { *m = SetDownloadSpeedL
 func (m *SetDownloadSpeedLimitResponse) String() string { return proto.CompactTextString(m) }
 func (*SetDownloadSpeedLimitResponse) ProtoMessage()    {}
 func (*SetDownloadSpeedLimitResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_4d076b7935cfab6b, []int{20}
+	return fileDescriptor_4d076b7935cfab6b, []int{25}
 }
 func (m *SetDownloadSpeedLimitResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1461,7 +1753,7 @@ func (m *Pair) Reset()         { *m = Pair{} }
 func (m *Pair) String() string { return proto.CompactTextString(m) }
 func (*Pair) ProtoMessage()    {}
 func (*Pair) Descriptor() ([]byte, []int) {
-	return fileDescriptor_4d076b7935cfab6b, []int{21}
+	return fileDescriptor_4d076b7935cfab6b, []int{26}
 }
 func (m *Pair) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1523,7 +1815,7 @@ func (m *WriteBatch) Reset()         { *m = WriteBatch{} }
 func (m *WriteBatch) String() string { return proto.CompactTextString(m) }
 func (*WriteBatch) ProtoMessage()    {}
 func (*WriteBatch) Descriptor() ([]byte, []int) {
-	return fileDescriptor_4d076b7935cfab6b, []int{22}
+	return fileDescriptor_4d076b7935cfab6b, []int{27}
 }
 func (m *WriteBatch) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1581,7 +1873,7 @@ func (m *WriteRequest) Reset()         { *m = WriteRequest{} }
 func (m *WriteRequest) String() string { return proto.CompactTextString(m) }
 func (*WriteRequest) ProtoMessage()    {}
 func (*WriteRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_4d076b7935cfab6b, []int{23}
+	return fileDescriptor_4d076b7935cfab6b, []int{28}
 }
 func (m *WriteRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1674,7 +1966,7 @@ func (m *WriteResponse) Reset()         { *m = WriteResponse{} }
 func (m *WriteResponse) String() string { return proto.CompactTextString(m) }
 func (*WriteResponse) ProtoMessage()    {}
 func (*WriteResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_4d076b7935cfab6b, []int{24}
+	return fileDescriptor_4d076b7935cfab6b, []int{29}
 }
 func (m *WriteResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1735,7 +2027,7 @@ func (m *RawWriteBatch) Reset()         { *m = RawWriteBatch{} }
 func (m *RawWriteBatch) String() string { return proto.CompactTextString(m) }
 func (*RawWriteBatch) ProtoMessage()    {}
 func (*RawWriteBatch) Descriptor() ([]byte, []int) {
-	return fileDescriptor_4d076b7935cfab6b, []int{25}
+	return fileDescriptor_4d076b7935cfab6b, []int{30}
 }
 func (m *RawWriteBatch) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1800,7 +2092,7 @@ func (m *RawWriteRequest) Reset()         { *m = RawWriteRequest{} }
 func (m *RawWriteRequest) String() string { return proto.CompactTextString(m) }
 func (*RawWriteRequest) ProtoMessage()    {}
 func (*RawWriteRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_4d076b7935cfab6b, []int{26}
+	return fileDescriptor_4d076b7935cfab6b, []int{31}
 }
 func (m *RawWriteRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1893,7 +2185,7 @@ func (m *RawWriteResponse) Reset()         { *m = RawWriteResponse{} }
 func (m *RawWriteResponse) String() string { return proto.CompactTextString(m) }
 func (*RawWriteResponse) ProtoMessage()    {}
 func (*RawWriteResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_4d076b7935cfab6b, []int{27}
+	return fileDescriptor_4d076b7935cfab6b, []int{32}
 }
 func (m *RawWriteResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1953,7 +2245,7 @@ func (m *DuplicateDetectRequest) Reset()         { *m = DuplicateDetectRequest{}
 func (m *DuplicateDetectRequest) String() string { return proto.CompactTextString(m) }
 func (*DuplicateDetectRequest) ProtoMessage()    {}
 func (*DuplicateDetectRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_4d076b7935cfab6b, []int{28}
+	return fileDescriptor_4d076b7935cfab6b, []int{33}
 }
 func (m *DuplicateDetectRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -2030,7 +2322,7 @@ func (m *KvPair) Reset()         { *m = KvPair{} }
 func (m *KvPair) String() string { return proto.CompactTextString(m) }
 func (*KvPair) ProtoMessage()    {}
 func (*KvPair) Descriptor() ([]byte, []int) {
-	return fileDescriptor_4d076b7935cfab6b, []int{29}
+	return fileDescriptor_4d076b7935cfab6b, []int{34}
 }
 func (m *KvPair) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -2103,7 +2395,7 @@ func (m *DuplicateDetectResponse) Reset()         { *m = DuplicateDetectResponse
 func (m *DuplicateDetectResponse) String() string { return proto.CompactTextString(m) }
 func (*DuplicateDetectResponse) ProtoMessage()    {}
 func (*DuplicateDetectResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_4d076b7935cfab6b, []int{30}
+	return fileDescriptor_4d076b7935cfab6b, []int{35}
 }
 func (m *DuplicateDetectResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -2189,7 +2481,7 @@ func (m *KVMeta) Reset()         { *m = KVMeta{} }
 func (m *KVMeta) String() string { return proto.CompactTextString(m) }
 func (*KVMeta) ProtoMessage()    {}
 func (*KVMeta) Descriptor() ([]byte, []int) {
-	return fileDescriptor_4d076b7935cfab6b, []int{31}
+	return fileDescriptor_4d076b7935cfab6b, []int{36}
 }
 func (m *KVMeta) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -2344,7 +2636,7 @@ func (m *ApplyRequest) Reset()         { *m = ApplyRequest{} }
 func (m *ApplyRequest) String() string { return proto.CompactTextString(m) }
 func (*ApplyRequest) ProtoMessage()    {}
 func (*ApplyRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_4d076b7935cfab6b, []int{32}
+	return fileDescriptor_4d076b7935cfab6b, []int{37}
 }
 func (m *ApplyRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -2443,7 +2735,7 @@ func (m *ApplyResponse) Reset()         { *m = ApplyResponse{} }
 func (m *ApplyResponse) String() string { return proto.CompactTextString(m) }
 func (*ApplyResponse) ProtoMessage()    {}
 func (*ApplyResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_4d076b7935cfab6b, []int{33}
+	return fileDescriptor_4d076b7935cfab6b, []int{38}
 }
 func (m *ApplyResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -2498,7 +2790,7 @@ func (m *ClearRequest) Reset()         { *m = ClearRequest{} }
 func (m *ClearRequest) String() string { return proto.CompactTextString(m) }
 func (*ClearRequest) ProtoMessage()    {}
 func (*ClearRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_4d076b7935cfab6b, []int{34}
+	return fileDescriptor_4d076b7935cfab6b, []int{39}
 }
 func (m *ClearRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -2545,7 +2837,7 @@ func (m *ClearResponse) Reset()         { *m = ClearResponse{} }
 func (m *ClearResponse) String() string { return proto.CompactTextString(m) }
 func (*ClearResponse) ProtoMessage()    {}
 func (*ClearResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_4d076b7935cfab6b, []int{35}
+	return fileDescriptor_4d076b7935cfab6b, []int{40}
 }
 func (m *ClearResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -2591,6 +2883,11 @@ func init() {
 	proto.RegisterType((*SwitchModeResponse)(nil), "import_sstpb.SwitchModeResponse")
 	proto.RegisterType((*GetModeRequest)(nil), "import_sstpb.GetModeRequest")
 	proto.RegisterType((*GetModeResponse)(nil), "import_sstpb.GetModeResponse")
+	proto.RegisterType((*Lease)(nil), "import_sstpb.Lease")
+	proto.RegisterType((*AcquireLease)(nil), "import_sstpb.AcquireLease")
+	proto.RegisterType((*ReleaseLease)(nil), "import_sstpb.ReleaseLease")
+	proto.RegisterType((*LeaseRequest)(nil), "import_sstpb.LeaseRequest")
+	proto.RegisterType((*LeaseResponse)(nil), "import_sstpb.LeaseResponse")
 	proto.RegisterType((*Range)(nil), "import_sstpb.Range")
 	proto.RegisterType((*SSTMeta)(nil), "import_sstpb.SSTMeta")
 	proto.RegisterType((*RewriteRule)(nil), "import_sstpb.RewriteRule")
@@ -2627,145 +2924,154 @@ func init() {
 func init() { proto.RegisterFile("import_sstpb.proto", fileDescriptor_4d076b7935cfab6b) }
 
 var fileDescriptor_4d076b7935cfab6b = []byte{
-	// 2197 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x59, 0x4b, 0x73, 0xdb, 0xc8,
-	0x11, 0x16, 0xf8, 0x66, 0x13, 0x7c, 0x78, 0xac, 0x95, 0x69, 0xfa, 0x8d, 0x78, 0xbd, 0xb2, 0x94,
-	0xc8, 0x8e, 0xbc, 0x71, 0xa5, 0x36, 0x55, 0x71, 0xad, 0x1e, 0xb1, 0x15, 0xf9, 0xa1, 0x80, 0x8a,
-	0x73, 0xc8, 0x01, 0x05, 0x81, 0x23, 0x09, 0x21, 0x08, 0x20, 0x98, 0x21, 0x65, 0x5e, 0xf2, 0x03,
-	0x72, 0xcb, 0x2d, 0xb7, 0x54, 0x72, 0xda, 0xca, 0x39, 0x97, 0xfc, 0x83, 0x3d, 0xe6, 0x98, 0x53,
-	0x2a, 0xe5, 0xfc, 0x90, 0x4d, 0x4d, 0xcf, 0x00, 0x04, 0x60, 0x4a, 0xb4, 0x55, 0xc9, 0x89, 0x98,
-	0xee, 0x9e, 0x9e, 0x9e, 0x7e, 0x7c, 0xd3, 0x33, 0x04, 0xe2, 0x8e, 0xc2, 0x20, 0xe2, 0x16, 0x63,
-	0x3c, 0x3c, 0xda, 0x08, 0xa3, 0x80, 0x07, 0x44, 0x4f, 0xd3, 0x7a, 0xfa, 0x88, 0x72, 0x3b, 0xe6,
-	0xf5, 0x9a, 0x34, 0x8a, 0x82, 0x68, 0x36, 0x1c, 0x4e, 0xa2, 0xd0, 0x49, 0x86, 0xcb, 0x27, 0xc1,
-	0x49, 0x80, 0x9f, 0x8f, 0xc4, 0x97, 0xa2, 0xb6, 0xa3, 0x31, 0xe3, 0xf8, 0xa9, 0x08, 0x70, 0x94,
-	0x68, 0x30, 0xfe, 0xa0, 0xc1, 0xb5, 0xfe, 0x98, 0x85, 0xd4, 0x1f, 0xec, 0xe1, 0xb2, 0xe6, 0xc1,
-	0xb6, 0x49, 0x7f, 0x3b, 0xa6, 0x8c, 0x93, 0x2f, 0x61, 0x85, 0x9d, 0x06, 0x63, 0x6f, 0x60, 0x31,
-	0x29, 0x61, 0x49, 0xcb, 0x58, 0x57, 0xbb, 0xab, 0xad, 0xd6, 0xcc, 0x65, 0xc9, 0xcd, 0x4c, 0x67,
-	0x64, 0x15, 0x3a, 0x83, 0x71, 0x64, 0x73, 0x37, 0xf0, 0x2d, 0xd7, 0xb7, 0x18, 0x75, 0x58, 0xb7,
-	0x70, 0x57, 0x5b, 0x2d, 0x99, 0xad, 0x98, 0xbe, 0xe7, 0xf7, 0xa9, 0xc3, 0xc8, 0x0a, 0x54, 0x1c,
-	0xdb, 0xf3, 0x68, 0xd4, 0x2d, 0xde, 0xd5, 0x56, 0xeb, 0xa6, 0x1a, 0x19, 0xcf, 0xa1, 0xfb, 0xa1,
-	0x49, 0x2c, 0x0c, 0x7c, 0x46, 0xc9, 0x3a, 0x5c, 0xb1, 0xbd, 0x88, 0xda, 0x83, 0x69, 0x6c, 0x14,
-	0x1d, 0x28, 0x73, 0x3a, 0x8a, 0xd1, 0x8f, 0xe9, 0x86, 0x0f, 0x57, 0xfa, 0x67, 0x2e, 0x77, 0x4e,
-	0x5f, 0x05, 0x03, 0x1a, 0xef, 0xea, 0xfb, 0x50, 0x1a, 0x05, 0x03, 0x8a, 0x93, 0x5a, 0x9b, 0xdd,
-	0x8d, 0x4c, 0x04, 0x52, 0xe2, 0x28, 0x45, 0xd6, 0xa1, 0x12, 0xd9, 0xfe, 0x09, 0x15, 0x7b, 0x28,
-	0xae, 0x36, 0x36, 0xaf, 0x66, 0xe5, 0x4d, 0xc1, 0x33, 0x95, 0x88, 0xb1, 0x0c, 0x24, 0xbd, 0x9e,
-	0x34, 0xd9, 0xe8, 0x40, 0xeb, 0x39, 0xe5, 0x29, 0x13, 0x8c, 0x67, 0xd0, 0x4e, 0x28, 0x6a, 0x5f,
-	0x9f, 0x64, 0x95, 0xf1, 0x08, 0xca, 0xb8, 0x32, 0x59, 0x86, 0x32, 0xe3, 0x76, 0xc4, 0x71, 0x9e,
-	0x6e, 0xca, 0x01, 0xe9, 0x40, 0x91, 0xfa, 0x03, 0xf4, 0xba, 0x6e, 0x8a, 0x4f, 0xe3, 0xcf, 0x45,
-	0xa8, 0xf6, 0xfb, 0x87, 0xaf, 0x28, 0xb7, 0x09, 0x81, 0xd2, 0x78, 0xec, 0x0e, 0xd4, 0x14, 0xfc,
-	0x26, 0x0f, 0xa1, 0x8c, 0x7b, 0xc0, 0x39, 0xe7, 0xec, 0x52, 0x4a, 0x88, 0x25, 0x9d, 0xc8, 0x79,
-	0xb2, 0x89, 0x41, 0x6b, 0x9a, 0x72, 0x20, 0x62, 0xe9, 0x51, 0xff, 0x84, 0x9f, 0x76, 0x4b, 0x18,
-	0x6b, 0x35, 0x22, 0xd7, 0xa0, 0xea, 0x1c, 0x5b, 0xbe, 0x3d, 0xa2, 0xdd, 0xb2, 0x0a, 0xf2, 0xf1,
-	0x6b, 0x7b, 0x44, 0xc9, 0x0d, 0xa8, 0x47, 0xf4, 0x04, 0x93, 0x64, 0xd0, 0xad, 0xe0, 0x9c, 0x9a,
-	0x24, 0xec, 0x0d, 0xc8, 0x53, 0xd0, 0x15, 0x93, 0x86, 0x81, 0x73, 0xda, 0xad, 0x2a, 0xab, 0x54,
-	0x2d, 0x98, 0xc8, 0xdb, 0x15, 0x2c, 0xb3, 0x11, 0xcd, 0x06, 0x64, 0x0d, 0xae, 0x88, 0x34, 0x1d,
-	0xd2, 0xa9, 0x45, 0xdf, 0x39, 0xde, 0x98, 0xb9, 0x13, 0xda, 0xad, 0x61, 0x76, 0xb4, 0xa9, 0x3f,
-	0xd8, 0xa7, 0xd3, 0xdd, 0x98, 0x2c, 0x0c, 0xe0, 0x01, 0xb7, 0x3d, 0x6b, 0x38, 0x61, 0xdd, 0xba,
-	0x34, 0x00, 0x09, 0xfb, 0x13, 0x46, 0xee, 0x40, 0x43, 0x32, 0x8f, 0xa6, 0x9c, 0xb2, 0x2e, 0x20,
-	0x1b, 0x90, 0xb4, 0x25, 0x28, 0xe4, 0x4b, 0x68, 0xd8, 0xa1, 0x6b, 0x4d, 0x68, 0xc4, 0xdc, 0xc0,
-	0xef, 0x36, 0x30, 0x6c, 0x57, 0x37, 0xe2, 0x7a, 0xfc, 0xfa, 0x60, 0xef, 0xad, 0x64, 0x99, 0x60,
-	0x87, 0xae, 0xfa, 0x16, 0x6b, 0x3a, 0x6e, 0x78, 0x4a, 0x23, 0xcb, 0x9d, 0x74, 0x75, 0xf4, 0x7f,
-	0x4d, 0x12, 0xf6, 0x26, 0xc6, 0xef, 0xa0, 0x61, 0xd2, 0xb3, 0xc8, 0xe5, 0xd4, 0x1c, 0x7b, 0x94,
-	0xdc, 0x87, 0x56, 0xe0, 0xc9, 0xbd, 0x84, 0x11, 0x3d, 0x76, 0xdf, 0xa9, 0x80, 0xe9, 0x81, 0x27,
-	0x36, 0x72, 0x80, 0x34, 0x21, 0xe5, 0xd3, 0xb3, 0xb4, 0x94, 0x8c, 0xba, 0xee, 0xd3, 0xb3, 0x99,
-	0xd4, 0xf7, 0xa0, 0x29, 0xa4, 0xb8, 0x3b, 0xa2, 0x8c, 0xdb, 0xa3, 0x10, 0x63, 0x57, 0x42, 0xa1,
-	0xc3, 0x98, 0x66, 0xfc, 0x1a, 0x9a, 0xbf, 0x0c, 0xbd, 0xc0, 0x1e, 0xc4, 0x95, 0xb2, 0x0e, 0x25,
-	0xe1, 0x70, 0x5c, 0xb7, 0xb1, 0xf9, 0x59, 0x2e, 0x27, 0x65, 0x36, 0xbd, 0x58, 0x32, 0x51, 0x88,
-	0x2c, 0x43, 0x69, 0x60, 0x73, 0x5b, 0x2e, 0x2f, 0xa8, 0x62, 0xb4, 0x55, 0x85, 0xb2, 0x73, 0x3a,
-	0xf6, 0x87, 0xa2, 0x08, 0x62, 0xe5, 0xaa, 0x2c, 0x06, 0xd0, 0xdc, 0x13, 0x55, 0xc3, 0xe3, 0xe5,
-	0xd6, 0xa0, 0xea, 0x04, 0x3e, 0xa7, 0xef, 0xb8, 0x5a, 0xb1, 0x93, 0xb8, 0x73, 0x5b, 0xd2, 0xcd,
-	0x58, 0x80, 0x7c, 0x01, 0x45, 0xc6, 0xb8, 0xca, 0xd6, 0xf9, 0x96, 0x99, 0x42, 0xc2, 0x18, 0x02,
-	0x79, 0x35, 0xf6, 0xb8, 0x7b, 0xf9, 0xa5, 0x1e, 0x42, 0x89, 0x31, 0x1e, 0xd7, 0xff, 0x39, 0x6b,
-	0xa1, 0x88, 0xf1, 0x14, 0x5a, 0xf1, 0x3a, 0xaa, 0xac, 0xef, 0x43, 0x19, 0x11, 0x5b, 0x2d, 0xd3,
-	0xda, 0x88, 0xf1, 0x7b, 0x57, 0xfc, 0x9a, 0x92, 0x69, 0xfc, 0x5e, 0x83, 0xd6, 0x76, 0x30, 0x0a,
-	0x6d, 0x27, 0xb1, 0x30, 0x29, 0x48, 0x6d, 0x61, 0x41, 0xde, 0x03, 0x3d, 0x18, 0xf3, 0x70, 0xcc,
-	0x2d, 0x8f, 0x4e, 0xa8, 0x87, 0x4e, 0x29, 0x9b, 0x0d, 0x49, 0x7b, 0x29, 0x48, 0xe9, 0xfd, 0x16,
-	0x17, 0xec, 0xd7, 0xb8, 0x02, 0xed, 0xc4, 0x16, 0x15, 0xaa, 0xef, 0x4a, 0xd0, 0xde, 0x09, 0xce,
-	0xfc, 0x74, 0x72, 0xfc, 0x44, 0xb9, 0x45, 0x43, 0xb7, 0x7c, 0x91, 0xb5, 0x2f, 0x27, 0xbc, 0xd1,
-	0x67, 0x9c, 0xed, 0xfa, 0x3c, 0x9a, 0x4a, 0x47, 0x89, 0xf2, 0x8a, 0x28, 0x0b, 0xbc, 0x09, 0x1d,
-	0x58, 0x9c, 0xa9, 0x6c, 0x84, 0x98, 0x74, 0xc8, 0xc8, 0x0f, 0x16, 0xc7, 0x77, 0xab, 0xf4, 0xed,
-	0xbf, 0xee, 0x2c, 0x61, 0x94, 0x05, 0xa4, 0x21, 0xc4, 0xd4, 0x11, 0x62, 0xf0, 0x9b, 0x6c, 0x09,
-	0x0c, 0xc1, 0x72, 0xb2, 0xa2, 0xb1, 0x47, 0xbb, 0x4d, 0xd4, 0x75, 0x3d, 0xe7, 0xc8, 0x59, 0xc1,
-	0x29, 0x7d, 0x8d, 0x28, 0x55, 0x83, 0xcf, 0xa0, 0xcd, 0x78, 0x10, 0xd9, 0x27, 0xd4, 0x3a, 0xb2,
-	0x9d, 0xa1, 0x00, 0xd5, 0x16, 0xaa, 0x59, 0xd9, 0x10, 0xe3, 0x71, 0xb8, 0xd1, 0x97, 0xec, 0x2d,
-	0xc9, 0x35, 0x5b, 0x2c, 0x33, 0x16, 0x87, 0x61, 0xac, 0xc0, 0xb1, 0x9d, 0x53, 0x2a, 0xc0, 0xee,
-	0x0a, 0x1a, 0x19, 0x4b, 0x6e, 0x0b, 0xf2, 0xde, 0x80, 0xf4, 0xa0, 0xee, 0x32, 0x2b, 0xb2, 0xcf,
-	0xac, 0xe1, 0xa4, 0xdb, 0x46, 0xc8, 0xaa, 0xba, 0xcc, 0xb4, 0xcf, 0xf6, 0x27, 0xe4, 0x09, 0x34,
-	0x62, 0xd8, 0xf0, 0x8f, 0x83, 0x6e, 0x07, 0x4d, 0x20, 0xb1, 0x09, 0xdb, 0x12, 0x40, 0xfc, 0xe3,
-	0xc0, 0x04, 0x27, 0xf9, 0x26, 0x3b, 0x62, 0xff, 0xe8, 0x7e, 0x8b, 0x4f, 0x43, 0xda, 0x25, 0x08,
-	0x51, 0xf7, 0x2e, 0x0c, 0xd4, 0xe1, 0x34, 0xa4, 0xc2, 0x03, 0xc9, 0x20, 0x9d, 0x39, 0x57, 0x17,
-	0x64, 0x4e, 0xef, 0x35, 0xd4, 0x93, 0x40, 0x8b, 0x33, 0x68, 0x48, 0xa7, 0x98, 0xbe, 0x75, 0x53,
-	0x7c, 0x92, 0x75, 0x28, 0x4f, 0x6c, 0x6f, 0x4c, 0x2f, 0xae, 0x5a, 0x29, 0xf3, 0x55, 0xe1, 0xc7,
-	0xda, 0xcf, 0x4b, 0xb5, 0x5a, 0xa7, 0x6e, 0x16, 0xc7, 0x91, 0x67, 0x98, 0x50, 0xc6, 0x8a, 0x21,
-	0x5d, 0xa8, 0x8e, 0x28, 0x63, 0xb6, 0xaa, 0x8c, 0xba, 0x19, 0x0f, 0xc9, 0x23, 0x68, 0x08, 0x97,
-	0x52, 0x4b, 0x16, 0x5c, 0x61, 0x6e, 0xc1, 0x01, 0x8a, 0xe0, 0xb7, 0xf1, 0x5e, 0x83, 0xce, 0x6c,
-	0xff, 0xaa, 0x60, 0x1f, 0x2d, 0xae, 0x3b, 0x95, 0x28, 0xaa, 0xfa, 0xae, 0x43, 0xcd, 0x65, 0x16,
-	0x1d, 0x85, 0x7c, 0x8a, 0x6b, 0x62, 0xd8, 0x76, 0xc5, 0x50, 0xd4, 0xb0, 0xb4, 0xa5, 0x38, 0x4f,
-	0x57, 0x1a, 0x01, 0x66, 0x87, 0x6a, 0x69, 0xfe, 0xa1, 0x5a, 0xce, 0x1c, 0xaa, 0x31, 0x24, 0x55,
-	0x16, 0x43, 0xd2, 0x33, 0xb8, 0xd9, 0xa7, 0x3c, 0xde, 0x66, 0x3f, 0xa4, 0x74, 0xf0, 0xd2, 0x1d,
-	0xb9, 0x09, 0xce, 0xdc, 0x81, 0x06, 0x13, 0x44, 0xcb, 0x13, 0x54, 0xdc, 0x75, 0xc9, 0x04, 0x96,
-	0xc8, 0x19, 0x77, 0xe0, 0xd6, 0x39, 0x0a, 0x14, 0x38, 0x84, 0x50, 0x3a, 0xb0, 0xdd, 0x28, 0x1d,
-	0x70, 0x5d, 0x06, 0x7c, 0x39, 0x1d, 0x70, 0x5d, 0x45, 0x96, 0x7c, 0x0e, 0x85, 0x40, 0x1e, 0x40,
-	0xad, 0xbc, 0xe9, 0x42, 0xcf, 0xc6, 0x9b, 0x03, 0xb3, 0x10, 0x84, 0xc6, 0x75, 0x28, 0xbc, 0x39,
-	0x20, 0x55, 0x28, 0x1e, 0x8c, 0x79, 0x67, 0x89, 0x00, 0x54, 0x76, 0xa8, 0x47, 0x39, 0xed, 0x68,
-	0x46, 0x1f, 0xe0, 0x57, 0xa2, 0x44, 0xb7, 0x6c, 0xee, 0x9c, 0xe2, 0x99, 0x1a, 0x8c, 0x46, 0x2e,
-	0xb7, 0x54, 0x63, 0x5a, 0x32, 0x6b, 0x92, 0x70, 0x28, 0x9a, 0xd1, 0x72, 0x68, 0xbb, 0x51, 0x8c,
-	0xde, 0xe4, 0xc3, 0xf5, 0x4c, 0x29, 0x60, 0xfc, 0x45, 0x03, 0x1d, 0xb5, 0x5e, 0xea, 0xf4, 0x7b,
-	0x0c, 0xe5, 0x23, 0x61, 0x8d, 0x4a, 0xbb, 0x5c, 0xff, 0x36, 0xb3, 0xf6, 0xc5, 0x92, 0x29, 0x05,
-	0x3f, 0x05, 0x92, 0x67, 0xa7, 0xe8, 0x09, 0x34, 0x95, 0x8d, 0x2a, 0x5d, 0x1f, 0x66, 0xcf, 0x97,
-	0x8b, 0x52, 0x6c, 0x1d, 0xca, 0xc2, 0xd4, 0x05, 0x07, 0x99, 0x94, 0x11, 0xbd, 0x80, 0x69, 0x9f,
-	0xa5, 0xbc, 0xdc, 0x81, 0x22, 0xe7, 0x9e, 0xf2, 0xaf, 0xf8, 0xfc, 0x78, 0xd7, 0x92, 0x16, 0x14,
-	0x12, 0x90, 0x2f, 0x70, 0x66, 0x7c, 0xa3, 0x41, 0x3b, 0xd6, 0x7e, 0x29, 0x6f, 0x3f, 0xc9, 0x7a,
-	0xfb, 0x46, 0xbe, 0x48, 0xcf, 0xfe, 0x67, 0x0e, 0xff, 0x0d, 0x74, 0x66, 0x96, 0xfe, 0x9f, 0x7d,
-	0xfe, 0x77, 0x0d, 0x56, 0x76, 0xc6, 0xa1, 0xe7, 0x3a, 0x36, 0xa7, 0x3b, 0x94, 0x53, 0xe7, 0x52,
-	0xfd, 0xca, 0x0d, 0xa8, 0xe3, 0x2d, 0x40, 0xf4, 0x84, 0xaa, 0xf2, 0x6a, 0x48, 0xd8, 0xa7, 0x53,
-	0xd1, 0x8e, 0xab, 0x06, 0x19, 0x9d, 0xa0, 0x9b, 0x15, 0xd9, 0x16, 0x0b, 0x18, 0x13, 0x3d, 0x64,
-	0xe0, 0x7b, 0x53, 0xc4, 0xa0, 0x9a, 0x59, 0x1d, 0xd2, 0xe9, 0x1b, 0xdf, 0x9b, 0x12, 0x03, 0x9a,
-	0x23, 0xd7, 0xb7, 0x66, 0x45, 0x26, 0xc1, 0xa8, 0x31, 0x72, 0xfd, 0x6d, 0x55, 0x67, 0xc6, 0x2b,
-	0xa8, 0xec, 0x4f, 0x3e, 0x09, 0x06, 0x32, 0x65, 0x5b, 0xcc, 0x96, 0xad, 0xf1, 0x57, 0x0d, 0xae,
-	0x7d, 0xe0, 0x0a, 0xe5, 0xfe, 0x1f, 0xce, 0xee, 0x06, 0x17, 0x74, 0x56, 0xf1, 0xb5, 0x00, 0xc3,
-	0xf0, 0x18, 0xea, 0x78, 0x25, 0x48, 0x1d, 0x0c, 0x73, 0xa3, 0x26, 0x5c, 0x20, 0x67, 0xac, 0xc5,
-	0xc9, 0x5d, 0xc4, 0xc0, 0x2d, 0x67, 0xa5, 0xe5, 0x56, 0x63, 0xe4, 0xf8, 0x53, 0x11, 0x2a, 0xfb,
-	0x6f, 0xe3, 0xab, 0x15, 0xf6, 0x21, 0x5a, 0xaa, 0x0f, 0xb9, 0x07, 0x3a, 0x9e, 0x14, 0x56, 0x70,
-	0x7c, 0xcc, 0x28, 0xc7, 0xab, 0x42, 0xc9, 0x6c, 0x20, 0xed, 0x0d, 0x92, 0x52, 0x38, 0x5f, 0xc8,
-	0xe0, 0x7c, 0x32, 0x55, 0x71, 0xf5, 0xd4, 0xd4, 0x97, 0x52, 0xa4, 0x05, 0x05, 0xe7, 0x58, 0xdd,
-	0x9f, 0x0b, 0xce, 0xb1, 0x70, 0xab, 0xcb, 0xac, 0x01, 0x42, 0xa5, 0x0a, 0x64, 0xcd, 0x65, 0x12,
-	0x3a, 0x45, 0x90, 0x65, 0x6a, 0xf0, 0xf8, 0x4a, 0x53, 0xc5, 0xf1, 0x21, 0x23, 0xb7, 0x40, 0xb4,
-	0x5f, 0x78, 0x7e, 0x26, 0x11, 0xae, 0x2b, 0xca, 0x21, 0xcb, 0x26, 0x55, 0xe5, 0xfc, 0xa4, 0xaa,
-	0x66, 0x92, 0x6a, 0x05, 0x2a, 0xec, 0xd4, 0xde, 0xfc, 0xd1, 0x53, 0xbc, 0x83, 0xe9, 0xa6, 0x1a,
-	0x89, 0x6b, 0x9a, 0xd4, 0xc6, 0x7c, 0x3b, 0x64, 0xa7, 0x01, 0x1a, 0x24, 0xaf, 0x60, 0x6d, 0x64,
-	0xf4, 0x15, 0xfd, 0x90, 0x91, 0x2d, 0xe8, 0x38, 0xc1, 0x28, 0x8c, 0x28, 0x13, 0x37, 0x28, 0xd9,
-	0xca, 0x34, 0xf1, 0xf0, 0xb8, 0x96, 0x34, 0x40, 0x33, 0x3e, 0x36, 0x30, 0x6d, 0x27, 0x4b, 0x30,
-	0xfe, 0x56, 0x04, 0xfd, 0xeb, 0x30, 0xf4, 0xa6, 0x71, 0x3d, 0xad, 0x66, 0xd0, 0x26, 0x1f, 0xdd,
-	0xb7, 0xf2, 0xfc, 0x44, 0xa8, 0x59, 0x8b, 0x2b, 0x58, 0x9f, 0x9b, 0x08, 0x6f, 0x53, 0x05, 0xfc,
-	0x41, 0xc7, 0x59, 0xb8, 0x44, 0xc7, 0xf9, 0x53, 0x68, 0xa6, 0x75, 0xb0, 0x6e, 0x13, 0xd7, 0x3d,
-	0x5f, 0x89, 0xa9, 0xa7, 0xa6, 0xb3, 0xb9, 0x0d, 0x67, 0x79, 0x6e, 0xc3, 0x39, 0xa7, 0xb7, 0x2d,
-	0x7e, 0x52, 0x6f, 0x9b, 0x02, 0xa5, 0xd2, 0x22, 0x50, 0xca, 0x75, 0xb0, 0x8d, 0x8f, 0xe9, 0x60,
-	0x8d, 0x21, 0x34, 0x55, 0xd4, 0x2e, 0xdb, 0x9c, 0x25, 0x50, 0x5d, 0x58, 0x04, 0xd5, 0xc6, 0x03,
-	0xd0, 0xb7, 0x3d, 0x6a, 0x47, 0x71, 0x8a, 0xac, 0x40, 0x25, 0x75, 0xed, 0xae, 0x9b, 0x6a, 0x64,
-	0x7c, 0x05, 0x4d, 0x25, 0xf7, 0xc9, 0xc7, 0xc1, 0xda, 0x7d, 0x80, 0xd9, 0x53, 0x8e, 0x68, 0x69,
-	0x5e, 0x07, 0xd1, 0xc8, 0xf6, 0x64, 0x7b, 0x23, 0xdf, 0xba, 0x3a, 0xda, 0xda, 0x23, 0xb8, 0x3a,
-	0xa7, 0x2d, 0x17, 0x22, 0x2f, 0xe9, 0x89, 0xed, 0x4c, 0x3b, 0x4b, 0x44, 0x87, 0xda, 0x3e, 0x9d,
-	0xb2, 0xd0, 0x76, 0x68, 0x47, 0xdb, 0xfc, 0xae, 0x06, 0x75, 0x39, 0xbb, 0xdf, 0x3f, 0x24, 0xbf,
-	0xc8, 0x2c, 0x72, 0xe7, 0xdc, 0x97, 0x24, 0xa9, 0xba, 0x77, 0xf7, 0x7c, 0x01, 0xd5, 0xe0, 0x2d,
-	0x91, 0x17, 0x50, 0x55, 0xef, 0x55, 0xe4, 0x66, 0x56, 0x3c, 0xfb, 0xb0, 0xd5, 0xbb, 0x75, 0x0e,
-	0x37, 0xd1, 0xf4, 0x1c, 0x2a, 0xf2, 0x19, 0x80, 0xe4, 0x0e, 0xed, 0xcc, 0xcb, 0x43, 0xef, 0xe6,
-	0x7c, 0x66, 0xac, 0x66, 0x55, 0x23, 0xbb, 0x50, 0x91, 0x57, 0xed, 0xbc, 0xa2, 0xcc, 0x45, 0x3f,
-	0xaf, 0x28, 0x7b, 0x3b, 0x97, 0x3b, 0x53, 0x97, 0xdd, 0xfc, 0xce, 0xb2, 0xf7, 0xf1, 0xfc, 0xce,
-	0xf2, 0x37, 0xe4, 0x25, 0x12, 0xc1, 0x67, 0x73, 0xfb, 0x64, 0xb2, 0x96, 0x73, 0xf0, 0x05, 0xdd,
-	0x78, 0x6f, 0xfd, 0xa3, 0x64, 0x93, 0x35, 0xf7, 0xa1, 0x16, 0xf3, 0xc9, 0xad, 0x0b, 0x2f, 0x76,
-	0xbd, 0xdb, 0xe7, 0xb1, 0x13, 0x65, 0x3b, 0x50, 0xc6, 0x3e, 0x87, 0xf4, 0xe6, 0x34, 0xaf, 0xb1,
-	0x9a, 0x1b, 0x73, 0x79, 0xa9, 0xb8, 0xbc, 0x82, 0x5a, 0xdc, 0x30, 0xe5, 0x4d, 0xca, 0xb5, 0x7c,
-	0x79, 0x93, 0xf2, 0x7d, 0x16, 0xaa, 0x7b, 0x03, 0x8d, 0xd4, 0xf3, 0x0d, 0xc9, 0x25, 0xeb, 0x87,
-	0x2f, 0x3b, 0x0b, 0x03, 0x7e, 0x04, 0xed, 0x5c, 0x63, 0x41, 0xee, 0xe7, 0x5c, 0x33, 0xb7, 0x05,
-	0xeb, 0x7d, 0xbe, 0x40, 0x2a, 0x5e, 0xe1, 0xb1, 0x46, 0xb6, 0xa0, 0x8c, 0xb8, 0x95, 0xf7, 0x64,
-	0xfa, 0x08, 0xca, 0x7b, 0x32, 0x03, 0x74, 0x58, 0x28, 0x80, 0x30, 0xf3, 0x33, 0x57, 0xa0, 0x7a,
-	0x4e, 0x51, 0x1a, 0xa8, 0xf2, 0x8a, 0x32, 0xe0, 0x64, 0x2c, 0x11, 0x07, 0x3a, 0xf9, 0xc7, 0x74,
-	0x92, 0xdb, 0xcb, 0x39, 0xef, 0xff, 0xbd, 0x07, 0x8b, 0xc4, 0xe2, 0x45, 0xb6, 0x1e, 0xfc, 0xf3,
-	0x9b, 0x9a, 0xf6, 0xed, 0xfb, 0xdb, 0xda, 0x3f, 0xde, 0xdf, 0xd6, 0xfe, 0xfd, 0xfe, 0xb6, 0xf6,
-	0xc7, 0xff, 0xdc, 0x5e, 0x82, 0x4e, 0x10, 0x9d, 0x6c, 0x70, 0x77, 0x38, 0xd9, 0x18, 0x4e, 0xf0,
-	0xdf, 0x86, 0xa3, 0x0a, 0xfe, 0x3c, 0xf9, 0x6f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xe2, 0x3f, 0xff,
-	0xb2, 0xf7, 0x18, 0x00, 0x00,
+	// 2349 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x59, 0x4b, 0x73, 0x1b, 0x4b,
+	0x15, 0xf6, 0xe8, 0xad, 0xa3, 0xd1, 0x23, 0x1d, 0x5f, 0x47, 0x57, 0x79, 0x0f, 0xb9, 0xb9, 0x8e,
+	0x0d, 0x76, 0x70, 0x2e, 0x29, 0xb8, 0x54, 0x91, 0x8a, 0x1f, 0x24, 0xc6, 0x79, 0x98, 0x96, 0x09,
+	0x0b, 0x16, 0x53, 0xe3, 0x51, 0xdb, 0x1a, 0x34, 0x9a, 0x99, 0x3b, 0xdd, 0x92, 0x23, 0x16, 0xfc,
+	0x00, 0x36, 0x14, 0x3b, 0x76, 0x14, 0xac, 0x6e, 0xb1, 0x66, 0xc3, 0x9a, 0xcd, 0x5d, 0xb2, 0x64,
+	0x45, 0x51, 0xe1, 0x87, 0x40, 0xf5, 0x63, 0x46, 0x33, 0x63, 0xc9, 0x8a, 0x5d, 0xb0, 0xd2, 0xf4,
+	0xe9, 0xd3, 0xa7, 0x4f, 0x9f, 0xc7, 0x77, 0x4e, 0xb7, 0x00, 0x39, 0xc3, 0xc0, 0x0f, 0x99, 0x49,
+	0x29, 0x0b, 0x8e, 0x37, 0x82, 0xd0, 0x67, 0x3e, 0xd2, 0x93, 0xb4, 0x8e, 0x3e, 0x24, 0xcc, 0x8a,
+	0xe6, 0x3a, 0x75, 0x12, 0x86, 0x7e, 0x38, 0x1d, 0x0e, 0xc6, 0x61, 0x60, 0xc7, 0xc3, 0xe5, 0x53,
+	0xff, 0xd4, 0x17, 0x9f, 0x9b, 0xfc, 0x4b, 0x51, 0x9b, 0xe1, 0x88, 0x32, 0xf1, 0xa9, 0x08, 0x70,
+	0x1c, 0x4b, 0x30, 0x7e, 0xa7, 0xc1, 0x8d, 0xee, 0x88, 0x06, 0xc4, 0xeb, 0xed, 0x8b, 0x6d, 0xf1,
+	0xe1, 0x0e, 0x26, 0x5f, 0x8d, 0x08, 0x65, 0xe8, 0x0b, 0x58, 0xa1, 0x7d, 0x7f, 0xe4, 0xf6, 0x4c,
+	0x2a, 0x39, 0x4c, 0xa9, 0x19, 0x6d, 0x6b, 0xf7, 0xb4, 0xd5, 0x0a, 0x5e, 0x96, 0xb3, 0xa9, 0xe5,
+	0x14, 0xad, 0x42, 0xab, 0x37, 0x0a, 0x2d, 0xe6, 0xf8, 0x9e, 0xe9, 0x78, 0x26, 0x25, 0x36, 0x6d,
+	0xe7, 0xee, 0x69, 0xab, 0x05, 0xdc, 0x88, 0xe8, 0xfb, 0x5e, 0x97, 0xd8, 0x14, 0xad, 0x40, 0xc9,
+	0xb6, 0x5c, 0x97, 0x84, 0xed, 0xfc, 0x3d, 0x6d, 0xb5, 0x8a, 0xd5, 0xc8, 0x78, 0x01, 0xed, 0xf3,
+	0x2a, 0xd1, 0xc0, 0xf7, 0x28, 0x41, 0xeb, 0x70, 0xcd, 0x72, 0x43, 0x62, 0xf5, 0x26, 0x91, 0x52,
+	0xa4, 0xa7, 0xd4, 0x69, 0xa9, 0x89, 0x6e, 0x44, 0x37, 0x3c, 0xb8, 0xd6, 0x3d, 0x73, 0x98, 0xdd,
+	0x7f, 0xed, 0xf7, 0x48, 0x74, 0xaa, 0x6f, 0x43, 0x61, 0xe8, 0xf7, 0x88, 0x58, 0xd4, 0xd8, 0x6a,
+	0x6f, 0xa4, 0x3c, 0x90, 0x60, 0x17, 0x5c, 0x68, 0x1d, 0x4a, 0xa1, 0xe5, 0x9d, 0x12, 0x7e, 0x86,
+	0xfc, 0x6a, 0x6d, 0xeb, 0x7a, 0x9a, 0x1f, 0xf3, 0x39, 0xac, 0x58, 0x8c, 0x65, 0x40, 0xc9, 0xfd,
+	0xa4, 0xca, 0x46, 0x0b, 0x1a, 0x2f, 0x08, 0x4b, 0xa8, 0x60, 0x3c, 0x83, 0x66, 0x4c, 0x51, 0xe7,
+	0xba, 0x94, 0x56, 0xc6, 0x0e, 0x14, 0x5f, 0x11, 0x8b, 0x12, 0xf4, 0x10, 0x4a, 0x21, 0x39, 0x75,
+	0x7c, 0x4f, 0x2c, 0xac, 0x6d, 0x35, 0x36, 0x54, 0xb8, 0x60, 0x41, 0xc5, 0x6a, 0x16, 0x21, 0x28,
+	0x8c, 0x46, 0x4e, 0x4f, 0x18, 0x5a, 0xc7, 0xe2, 0xdb, 0x38, 0x00, 0xfd, 0xb9, 0xfd, 0xd5, 0xc8,
+	0x09, 0x89, 0x94, 0xf5, 0x08, 0x8a, 0x2e, 0xff, 0x50, 0xa2, 0x32, 0x27, 0x15, 0x3c, 0x58, 0x72,
+	0xa0, 0x16, 0xe4, 0x19, 0x73, 0x95, 0x5b, 0xf9, 0xa7, 0xf1, 0x03, 0xd0, 0x31, 0x11, 0x93, 0x97,
+	0x15, 0x66, 0xfc, 0x0a, 0x74, 0x39, 0x8e, 0xc3, 0xae, 0x6c, 0x49, 0xbd, 0xda, 0x9a, 0xb0, 0x79,
+	0x27, 0xbd, 0x38, 0xa9, 0x34, 0x8e, 0x58, 0xf9, 0xaa, 0x50, 0x2a, 0xa0, 0x3c, 0x95, 0x59, 0x95,
+	0xd4, 0x0e, 0x47, 0xac, 0xc6, 0x6f, 0x35, 0xa8, 0xab, 0xcd, 0x95, 0x23, 0x6e, 0x41, 0x95, 0x39,
+	0x43, 0x42, 0x99, 0x35, 0x0c, 0x84, 0xf2, 0x05, 0x3c, 0x25, 0xa0, 0x4d, 0xa8, 0xa8, 0x0d, 0x7b,
+	0xb3, 0x03, 0x42, 0x0a, 0x8b, 0x99, 0xf8, 0x02, 0xb5, 0x17, 0x37, 0xfe, 0xfc, 0x05, 0x11, 0x93,
+	0xb1, 0x09, 0x45, 0x11, 0x54, 0x68, 0x19, 0x8a, 0x94, 0x59, 0x21, 0x13, 0x4a, 0xe8, 0x58, 0x0e,
+	0xb8, 0xe5, 0x89, 0xd7, 0x13, 0x96, 0xd7, 0x31, 0xff, 0x34, 0xfe, 0x98, 0x87, 0x72, 0xb7, 0x7b,
+	0xf4, 0x9a, 0x30, 0x2b, 0x76, 0xb3, 0x36, 0x75, 0x33, 0xf7, 0x84, 0x08, 0x4f, 0xb1, 0x66, 0x4e,
+	0x00, 0x4b, 0x0e, 0xbe, 0xa5, 0x1d, 0xda, 0x4f, 0xb6, 0x44, 0x98, 0xd4, 0xb1, 0x1c, 0xf0, 0x34,
+	0x75, 0x89, 0x77, 0xca, 0xfa, 0xed, 0x82, 0x30, 0x87, 0x1a, 0xa1, 0x1b, 0x50, 0xb6, 0x4f, 0x4c,
+	0xcf, 0x1a, 0x92, 0x76, 0x51, 0xe5, 0xef, 0xc9, 0x1b, 0x6b, 0x48, 0xd0, 0x4d, 0xa8, 0xca, 0xb0,
+	0x33, 0x9d, 0x5e, 0xbb, 0x24, 0xd6, 0x54, 0x24, 0x61, 0xbf, 0x87, 0x9e, 0x82, 0xae, 0x26, 0x49,
+	0xe0, 0xdb, 0xfd, 0x76, 0x59, 0x69, 0x95, 0x8a, 0xdb, 0x3d, 0x3e, 0x85, 0x6b, 0xe1, 0x74, 0x80,
+	0xd6, 0xe0, 0x1a, 0x47, 0xa0, 0x01, 0x99, 0x98, 0xe4, 0xbd, 0xed, 0x8e, 0xa8, 0x33, 0x26, 0xed,
+	0x8a, 0x48, 0xfc, 0x26, 0xf1, 0x7a, 0x07, 0x64, 0xb2, 0x17, 0x91, 0xb9, 0x02, 0xcc, 0x67, 0x96,
+	0x6b, 0x0e, 0xc6, 0xb4, 0x5d, 0x95, 0x0a, 0x08, 0xc2, 0xc1, 0x98, 0xa2, 0xbb, 0x50, 0x93, 0x93,
+	0xc7, 0x13, 0x46, 0x68, 0x1b, 0xc4, 0x34, 0x08, 0xd2, 0x36, 0xa7, 0xa0, 0x2f, 0xa0, 0x66, 0x05,
+	0x8e, 0x39, 0x26, 0x21, 0xe5, 0x89, 0x55, 0x13, 0x19, 0x79, 0x7d, 0x23, 0x82, 0xda, 0xe7, 0x87,
+	0xfb, 0xef, 0xe4, 0x14, 0x06, 0x2b, 0x70, 0xd4, 0x37, 0xdf, 0xd3, 0x76, 0x82, 0x3e, 0x09, 0x4d,
+	0x67, 0xdc, 0xd6, 0x85, 0xfd, 0x2b, 0x92, 0xb0, 0x3f, 0x36, 0x7e, 0x0d, 0x35, 0x4c, 0xce, 0x42,
+	0x87, 0x11, 0x3c, 0x72, 0x09, 0x7a, 0x00, 0x0d, 0xdf, 0x95, 0x67, 0x09, 0x42, 0x72, 0xe2, 0xbc,
+	0x57, 0x0e, 0xd3, 0x7d, 0x97, 0x1f, 0xe4, 0x50, 0xd0, 0x38, 0x97, 0x47, 0xce, 0x92, 0x5c, 0xd2,
+	0xeb, 0xba, 0x47, 0xce, 0xa6, 0x5c, 0xdf, 0x82, 0x3a, 0xe7, 0x9a, 0xc6, 0x6c, 0x5e, 0x1c, 0x88,
+	0x33, 0x1d, 0x45, 0x34, 0xe3, 0x17, 0x50, 0xff, 0x59, 0xe0, 0xfa, 0x56, 0x2f, 0xca, 0xb1, 0x75,
+	0x28, 0x70, 0x83, 0xab, 0xec, 0xfc, 0x24, 0x03, 0x37, 0x32, 0x9a, 0x5e, 0x2e, 0x61, 0xc1, 0x84,
+	0x96, 0xa1, 0xd0, 0xb3, 0x98, 0x25, 0xb7, 0xe7, 0x54, 0x3e, 0xda, 0x2e, 0x43, 0xd1, 0xee, 0x8f,
+	0xbc, 0x81, 0xf1, 0x14, 0x1a, 0x91, 0x70, 0x95, 0x43, 0x0f, 0xa0, 0x28, 0xea, 0x54, 0x0c, 0x4a,
+	0x51, 0xd5, 0xda, 0xe3, 0xbf, 0x58, 0x4e, 0x1a, 0x3d, 0xa8, 0xef, 0x73, 0xd8, 0x64, 0x91, 0x52,
+	0x6b, 0x50, 0xb6, 0x7d, 0x8f, 0x91, 0xf7, 0x4c, 0x2d, 0x6c, 0xc5, 0x46, 0xdf, 0x91, 0x74, 0x1c,
+	0x31, 0xa0, 0xcf, 0x21, 0x4f, 0x29, 0x53, 0x31, 0x3d, 0x5b, 0x7f, 0xcc, 0x39, 0x8c, 0x01, 0xa0,
+	0xd7, 0x23, 0x97, 0x39, 0x57, 0xdf, 0xea, 0x11, 0x14, 0x28, 0x65, 0x51, 0x01, 0x98, 0xb3, 0x97,
+	0x60, 0xe1, 0xa6, 0x88, 0xf6, 0xb9, 0x94, 0x29, 0x7e, 0xa3, 0x41, 0x63, 0xc7, 0x1f, 0x06, 0x96,
+	0x1d, 0x6b, 0x18, 0xa7, 0xad, 0xb6, 0x30, 0x6d, 0xef, 0x83, 0xee, 0x8f, 0x58, 0x30, 0x62, 0xa6,
+	0x4b, 0xc6, 0x44, 0xc2, 0x72, 0x11, 0xd7, 0x24, 0xed, 0x15, 0x27, 0x25, 0xcf, 0x9b, 0x5f, 0x70,
+	0x5e, 0xe3, 0x1a, 0x34, 0x63, 0x5d, 0x54, 0x09, 0xfb, 0x4f, 0x01, 0x9a, 0xbb, 0xfe, 0x99, 0x97,
+	0x0c, 0xa1, 0x1f, 0x2a, 0xb3, 0x48, 0x8c, 0xfe, 0x3c, 0xad, 0x5f, 0x86, 0x79, 0xa3, 0x4b, 0x19,
+	0xdd, 0xf3, 0x58, 0x38, 0x91, 0x86, 0xe2, 0x49, 0x18, 0x12, 0xea, 0xbb, 0x63, 0xd2, 0x33, 0x19,
+	0x55, 0x31, 0x0b, 0x11, 0xe9, 0x88, 0xa2, 0xef, 0x2c, 0xf6, 0xef, 0x76, 0xe1, 0x9b, 0x7f, 0xde,
+	0x5d, 0x12, 0x5e, 0xe6, 0xc0, 0x27, 0x80, 0xa8, 0x2a, 0x80, 0x48, 0x7c, 0xa3, 0x6d, 0x8e, 0x34,
+	0x22, 0xe9, 0xcc, 0x70, 0xe4, 0x92, 0x76, 0x5d, 0xc8, 0xfa, 0x34, 0x5b, 0x16, 0xe2, 0xb4, 0x54,
+	0xf2, 0x6a, 0x61, 0x22, 0x53, 0x9f, 0x41, 0x93, 0x32, 0x3f, 0xb4, 0x4e, 0x89, 0x79, 0x6c, 0xd9,
+	0x03, 0x0e, 0xbd, 0x0d, 0x21, 0x66, 0x65, 0x83, 0x8f, 0x47, 0xc1, 0x46, 0x57, 0x4e, 0x6f, 0xcb,
+	0x59, 0xdc, 0xa0, 0xa9, 0x31, 0xef, 0x86, 0x22, 0x01, 0xb6, 0x65, 0xf7, 0x09, 0x87, 0xc4, 0x6b,
+	0x42, 0xc9, 0x88, 0x73, 0x87, 0x93, 0xf7, 0x7b, 0xa8, 0x03, 0x55, 0x87, 0x9a, 0xa1, 0x75, 0x66,
+	0x0e, 0xc6, 0xed, 0xa6, 0x00, 0xb6, 0xb2, 0x43, 0xb1, 0x75, 0x76, 0x30, 0x46, 0x4f, 0xa0, 0x16,
+	0x81, 0x8b, 0x77, 0xe2, 0xb7, 0x5b, 0x42, 0x05, 0x14, 0xa9, 0xb0, 0x23, 0x61, 0xc6, 0x3b, 0xf1,
+	0x31, 0xd8, 0xf1, 0x37, 0xda, 0xe5, 0xe7, 0x17, 0xe6, 0x37, 0xd9, 0x24, 0x20, 0x6d, 0x24, 0x80,
+	0xec, 0xfe, 0x85, 0x8e, 0x3a, 0x9a, 0x04, 0x84, 0x5b, 0x20, 0x1e, 0x24, 0x23, 0xe7, 0xfa, 0x82,
+	0xc8, 0xe9, 0xbc, 0x81, 0x6a, 0xec, 0x68, 0x5e, 0xa9, 0x06, 0x64, 0x22, 0xc2, 0xb7, 0x8a, 0xf9,
+	0x27, 0x5a, 0x87, 0xe2, 0xd8, 0x72, 0x47, 0xe4, 0xe2, 0xac, 0x95, 0x3c, 0x5f, 0xe6, 0xbe, 0xaf,
+	0xfd, 0xa4, 0x50, 0xa9, 0xb4, 0xaa, 0x38, 0x3f, 0x0a, 0x5d, 0x03, 0x43, 0x51, 0x64, 0x0c, 0x6a,
+	0x43, 0x79, 0x48, 0x28, 0xb5, 0x54, 0x66, 0x54, 0x71, 0x34, 0x44, 0x9b, 0x50, 0xe3, 0x26, 0x25,
+	0xa6, 0x4c, 0xb8, 0xdc, 0xcc, 0x84, 0x03, 0xc1, 0x22, 0xbe, 0x8d, 0x0f, 0x1a, 0xb4, 0xa6, 0xe7,
+	0x57, 0x09, 0xbb, 0xb9, 0x38, 0xef, 0x54, 0xa0, 0xa8, 0xec, 0xfb, 0x14, 0x2a, 0x0e, 0x35, 0xc9,
+	0x30, 0x60, 0x13, 0xb1, 0xa7, 0x70, 0xdb, 0x1e, 0x1f, 0xf2, 0x1c, 0x96, 0xba, 0xe4, 0x67, 0xc9,
+	0x4a, 0x22, 0xc0, 0xb4, 0xf4, 0x16, 0x66, 0x97, 0xde, 0x62, 0xaa, 0xf4, 0x46, 0x90, 0x54, 0x5a,
+	0x0c, 0x49, 0xcf, 0xe0, 0x56, 0x97, 0xb0, 0xe8, 0x98, 0xdd, 0x80, 0x90, 0xde, 0x2b, 0x67, 0xe8,
+	0xc4, 0x38, 0x73, 0x17, 0x6a, 0x94, 0x13, 0x4d, 0x97, 0x53, 0x55, 0xc7, 0x03, 0x34, 0xe6, 0x33,
+	0xee, 0xc2, 0xed, 0x39, 0x02, 0x14, 0x38, 0x04, 0x50, 0x38, 0xb4, 0x9c, 0x30, 0xe9, 0x70, 0x5d,
+	0x3a, 0x7c, 0x39, 0xe9, 0x70, 0x5d, 0x79, 0x16, 0x7d, 0x06, 0x39, 0x5f, 0x96, 0xa9, 0x46, 0x56,
+	0x75, 0x2e, 0x67, 0xe3, 0xed, 0x21, 0xce, 0xf9, 0x81, 0xf1, 0x29, 0xe4, 0xde, 0x1e, 0xa2, 0x32,
+	0xe4, 0x0f, 0x47, 0xac, 0xb5, 0x84, 0x00, 0x4a, 0xbb, 0xc4, 0x25, 0x8c, 0xb4, 0x34, 0xa3, 0x0b,
+	0xf0, 0x73, 0x9e, 0xa2, 0xdb, 0x16, 0xb3, 0xfb, 0xa2, 0xf2, 0xfa, 0xc3, 0xa1, 0xc3, 0x4c, 0x75,
+	0x33, 0x29, 0xe0, 0x8a, 0x24, 0x1c, 0xf1, 0xdb, 0x48, 0x31, 0xb0, 0x9c, 0x30, 0x42, 0x6f, 0x74,
+	0x7e, 0x3f, 0x2c, 0x19, 0x8c, 0x3f, 0x69, 0xa0, 0x0b, 0xa9, 0x57, 0xaa, 0x91, 0x8f, 0xa1, 0x78,
+	0xcc, 0xb5, 0x51, 0x61, 0x97, 0x69, 0xe0, 0xa7, 0xda, 0xbe, 0x5c, 0xc2, 0x92, 0xf1, 0x32, 0x90,
+	0x3c, 0xad, 0xb5, 0xa7, 0x50, 0x57, 0x3a, 0xaa, 0x70, 0x7d, 0x94, 0xae, 0x2f, 0x17, 0x85, 0xd8,
+	0x3a, 0x14, 0xb9, 0xaa, 0x0b, 0x0a, 0x99, 0xe4, 0xe1, 0x1d, 0x03, 0xb6, 0xce, 0x12, 0x56, 0x56,
+	0x2d, 0xbf, 0x16, 0xb7, 0xfc, 0x1f, 0x6f, 0x5a, 0xd4, 0x80, 0x5c, 0x0c, 0xf2, 0x39, 0x46, 0x8d,
+	0xaf, 0x35, 0x68, 0x46, 0xd2, 0xaf, 0x64, 0xed, 0x27, 0x69, 0x6b, 0xdf, 0xcc, 0x26, 0xe9, 0xd9,
+	0xff, 0xcc, 0xe0, 0xbf, 0x84, 0xd6, 0x54, 0xd3, 0xff, 0xb3, 0xcd, 0xff, 0xaa, 0xc1, 0xca, 0xee,
+	0x28, 0x70, 0x1d, 0xdb, 0x62, 0x64, 0x97, 0x30, 0x62, 0x5f, 0xa9, 0x5f, 0xb9, 0x09, 0x55, 0x71,
+	0x57, 0xe0, 0x9d, 0xa3, 0xca, 0xbc, 0x8a, 0x20, 0x1c, 0x90, 0x09, 0x6f, 0xda, 0x55, 0x1b, 0xad,
+	0xee, 0x82, 0x25, 0xd9, 0x3c, 0x73, 0x18, 0xe3, 0x9d, 0xa6, 0xef, 0xb9, 0x13, 0x81, 0x41, 0x15,
+	0x5c, 0x1e, 0x90, 0xc9, 0x5b, 0xcf, 0x9d, 0x20, 0x03, 0xea, 0x43, 0xc7, 0x33, 0xa7, 0x49, 0x26,
+	0xc1, 0xa8, 0x36, 0x74, 0xbc, 0x1d, 0x95, 0x67, 0xc6, 0x6b, 0x28, 0x1d, 0x8c, 0x2f, 0x05, 0x03,
+	0xa9, 0xb4, 0xcd, 0xa7, 0xd3, 0xd6, 0xf8, 0xb3, 0x06, 0x37, 0xce, 0x99, 0x42, 0x99, 0xff, 0xbb,
+	0xd3, 0x1b, 0xc4, 0x05, 0x9d, 0x55, 0x74, 0x79, 0x10, 0x6e, 0x78, 0x0c, 0x55, 0x71, 0x71, 0x48,
+	0x14, 0x86, 0x99, 0x5e, 0xe3, 0x26, 0x90, 0x2b, 0xd6, 0xa2, 0xe0, 0x96, 0x97, 0xb6, 0xe5, 0x34,
+	0xb7, 0x3c, 0x6a, 0x84, 0x1c, 0x7f, 0xc8, 0x43, 0xe9, 0xe0, 0x5d, 0x74, 0x01, 0x13, 0x7d, 0x88,
+	0x96, 0xe8, 0x43, 0xee, 0x83, 0x2e, 0x2a, 0x85, 0xe9, 0x9f, 0x9c, 0x50, 0xc2, 0xc4, 0x85, 0xa2,
+	0x80, 0x6b, 0x82, 0xf6, 0x56, 0x90, 0x12, 0x38, 0x9f, 0x4b, 0xe1, 0x7c, 0xbc, 0x54, 0xcd, 0xea,
+	0x89, 0xa5, 0xaf, 0x24, 0x4b, 0x03, 0x72, 0xf6, 0x89, 0x7a, 0x40, 0xc9, 0xd9, 0x27, 0xdc, 0xac,
+	0x0e, 0x35, 0x7b, 0x02, 0x2a, 0x95, 0x23, 0x2b, 0x0e, 0x95, 0xd0, 0xc9, 0x9d, 0x2c, 0x43, 0x83,
+	0x45, 0x17, 0x9f, 0xb2, 0x18, 0x1f, 0x51, 0x74, 0x1b, 0x78, 0xfb, 0x25, 0xea, 0x67, 0xec, 0xe1,
+	0xaa, 0xa2, 0x1c, 0xd1, 0x74, 0x50, 0x95, 0xe6, 0x07, 0x55, 0x39, 0x15, 0x54, 0x2b, 0x50, 0xa2,
+	0x7d, 0x6b, 0xeb, 0x7b, 0x4f, 0xc5, 0x4d, 0x4d, 0xc7, 0x6a, 0xc4, 0x2f, 0x73, 0x52, 0x1a, 0xf5,
+	0xac, 0x80, 0xf6, 0x7d, 0xa1, 0x90, 0xbc, 0xa8, 0x35, 0xc5, 0x44, 0x57, 0xd1, 0x8f, 0x28, 0xda,
+	0x86, 0x96, 0xed, 0x0f, 0x83, 0x90, 0x50, 0x7e, 0xcf, 0x92, 0xad, 0x4c, 0x5d, 0x14, 0x8f, 0x1b,
+	0x71, 0x03, 0x34, 0x9d, 0x17, 0x0d, 0x4c, 0xd3, 0x4e, 0x13, 0x8c, 0xbf, 0xe4, 0x41, 0x7f, 0x1e,
+	0x04, 0xee, 0x24, 0xca, 0xa7, 0xd5, 0x14, 0xda, 0x64, 0xbd, 0xfb, 0x4e, 0xd6, 0x4f, 0x01, 0x35,
+	0x6b, 0x51, 0x06, 0xeb, 0x33, 0x03, 0xe1, 0x5d, 0x22, 0x81, 0xcf, 0x75, 0x9c, 0xb9, 0x2b, 0x74,
+	0x9c, 0x3f, 0x82, 0x7a, 0x52, 0x06, 0x6d, 0xd7, 0xc5, 0xbe, 0xf3, 0x85, 0x60, 0x3d, 0xb1, 0x9c,
+	0xce, 0x6c, 0x38, 0x8b, 0x33, 0x1b, 0xce, 0x19, 0xbd, 0x6d, 0xfe, 0x52, 0xbd, 0x6d, 0x02, 0x94,
+	0x0a, 0x8b, 0x40, 0x29, 0xd3, 0xc1, 0xd6, 0x3e, 0xa6, 0x83, 0x35, 0x06, 0x50, 0x57, 0x5e, 0xbb,
+	0x6a, 0x73, 0x16, 0x43, 0x75, 0x6e, 0x11, 0x54, 0x1b, 0x0f, 0x41, 0xdf, 0x71, 0x89, 0x15, 0x46,
+	0x21, 0xb2, 0x02, 0xa5, 0xc4, 0xe5, 0xbc, 0x8a, 0xd5, 0xc8, 0xf8, 0x12, 0xea, 0x8a, 0xef, 0xd2,
+	0xe5, 0x60, 0xed, 0x01, 0xc0, 0xf4, 0x2d, 0x8f, 0xb7, 0x34, 0x6f, 0xfc, 0x70, 0x68, 0xb9, 0xb2,
+	0xbd, 0x91, 0x8f, 0x9d, 0x2d, 0x6d, 0x6d, 0x13, 0xae, 0xcf, 0x68, 0xcb, 0x39, 0xcb, 0x2b, 0x72,
+	0x6a, 0xd9, 0x93, 0xd6, 0x12, 0xd2, 0xa1, 0x72, 0x40, 0x26, 0x34, 0xb0, 0x6c, 0xd2, 0xd2, 0xb6,
+	0xfe, 0x56, 0x85, 0xaa, 0x5c, 0xdd, 0xed, 0x1e, 0xa1, 0x9f, 0xa6, 0x36, 0xb9, 0x3b, 0xf7, 0x29,
+	0x51, 0x8a, 0xee, 0xdc, 0x9b, 0xcf, 0xa0, 0x1a, 0xbc, 0x25, 0xf4, 0x12, 0xca, 0xea, 0xc1, 0x12,
+	0xdd, 0x4a, 0xb3, 0xa7, 0x5f, 0x36, 0x3b, 0xb7, 0xe7, 0xcc, 0xc6, 0x92, 0xb6, 0xa3, 0x97, 0xcb,
+	0xce, 0xac, 0x67, 0x30, 0x25, 0xe5, 0xe6, 0xcc, 0xb9, 0x58, 0xc6, 0x0b, 0x28, 0xc9, 0x07, 0x07,
+	0x94, 0x61, 0x4c, 0xbd, 0x71, 0x74, 0x6e, 0xcd, 0x9e, 0x8c, 0xc4, 0xac, 0x6a, 0x68, 0x0f, 0x4a,
+	0xf2, 0xba, 0x9e, 0x15, 0x94, 0x7a, 0x2c, 0xc8, 0x0a, 0x4a, 0xdf, 0xf0, 0xa5, 0x75, 0xd4, 0x85,
+	0x39, 0x6b, 0x9d, 0xf4, 0x9d, 0x3e, 0x6b, 0x9d, 0xec, 0x2d, 0x7b, 0x09, 0x85, 0xf0, 0xc9, 0xcc,
+	0x5e, 0x1b, 0xad, 0x65, 0x9c, 0x74, 0x41, 0x47, 0xdf, 0x59, 0xff, 0x28, 0xde, 0x78, 0xcf, 0x03,
+	0xa8, 0x44, 0xf3, 0xe8, 0xf6, 0x85, 0x97, 0xc3, 0xce, 0x9d, 0x79, 0xd3, 0xb1, 0xb0, 0x5d, 0x28,
+	0x8a, 0x5e, 0x29, 0xeb, 0xde, 0x64, 0xab, 0x97, 0x75, 0x6f, 0xaa, 0xb9, 0x12, 0x7e, 0x79, 0x0d,
+	0x95, 0xa8, 0xe9, 0xca, 0xaa, 0x94, 0x69, 0x1b, 0xb3, 0x2a, 0x65, 0x7b, 0x35, 0x21, 0xee, 0x2d,
+	0xd4, 0x12, 0x4f, 0x40, 0x28, 0x13, 0xf0, 0xe7, 0x5f, 0x87, 0x16, 0x3a, 0xfc, 0x18, 0x9a, 0x99,
+	0xe6, 0x04, 0x3d, 0xc8, 0x98, 0x66, 0x66, 0x1b, 0xd7, 0xf9, 0x6c, 0x01, 0x57, 0xb4, 0xc3, 0x63,
+	0x8d, 0x27, 0x8a, 0xc0, 0xbe, 0xac, 0x25, 0x93, 0x65, 0x2c, 0x6b, 0xc9, 0x14, 0x58, 0x8a, 0x44,
+	0x01, 0x01, 0x55, 0x3f, 0x76, 0x78, 0x65, 0xc8, 0x08, 0x4a, 0x82, 0x5d, 0x56, 0x50, 0x0a, 0xe0,
+	0x8c, 0x25, 0x64, 0x43, 0x2b, 0xfb, 0x8f, 0x0c, 0xca, 0x9c, 0x65, 0xce, 0x9f, 0x48, 0x9d, 0x87,
+	0x8b, 0xd8, 0xa2, 0x4d, 0xb6, 0x1f, 0xfe, 0xe3, 0xeb, 0x8a, 0xf6, 0xcd, 0x87, 0x3b, 0xda, 0xdf,
+	0x3f, 0xdc, 0xd1, 0xfe, 0xf5, 0xe1, 0x8e, 0xf6, 0xfb, 0x7f, 0xdf, 0x59, 0x82, 0x96, 0x1f, 0x9e,
+	0x6e, 0x30, 0x67, 0x30, 0xde, 0x18, 0x8c, 0xc5, 0x5f, 0x56, 0xc7, 0x25, 0xf1, 0xf3, 0xe4, 0xbf,
+	0x01, 0x00, 0x00, 0xff, 0xff, 0x31, 0x2a, 0xd3, 0x1f, 0x3c, 0x1b, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -2784,6 +3090,7 @@ type ImportSSTClient interface {
 	SwitchMode(ctx context.Context, in *SwitchModeRequest, opts ...grpc.CallOption) (*SwitchModeResponse, error)
 	// Get import mode(normal/import).
 	GetMode(ctx context.Context, in *GetModeRequest, opts ...grpc.CallOption) (*GetModeResponse, error)
+	Lease(ctx context.Context, in *LeaseRequest, opts ...grpc.CallOption) (*LeaseResponse, error)
 	// Upload an SST file to a server.
 	Upload(ctx context.Context, opts ...grpc.CallOption) (ImportSST_UploadClient, error)
 	// Ingest an uploaded SST file to a region.
@@ -2835,6 +3142,15 @@ func (c *importSSTClient) GetMode(ctx context.Context, in *GetModeRequest, opts
 	return out, nil
 }
 
+func (c *importSSTClient) Lease(ctx context.Context, in *LeaseRequest, opts ...grpc.CallOption) (*LeaseResponse, error) {
+	out := new(LeaseResponse)
+	err := c.cc.Invoke(ctx, "/import_sstpb.ImportSST/Lease", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 func (c *importSSTClient) Upload(ctx context.Context, opts ...grpc.CallOption) (ImportSST_UploadClient, error) {
 	stream, err := c.cc.NewStream(ctx, &_ImportSST_serviceDesc.Streams[0], "/import_sstpb.ImportSST/Upload", opts...)
 	if err != nil {
@@ -3047,6 +3363,7 @@ type ImportSSTServer interface {
 	SwitchMode(context.Context, *SwitchModeRequest) (*SwitchModeResponse, error)
 	// Get import mode(normal/import).
 	GetMode(context.Context, *GetModeRequest) (*GetModeResponse, error)
+	Lease(context.Context, *LeaseRequest) (*LeaseResponse, error)
 	// Upload an SST file to a server.
 	Upload(ImportSST_UploadServer) error
 	// Ingest an uploaded SST file to a region.
@@ -3082,6 +3399,9 @@ func (*UnimplementedImportSSTServer) SwitchMode(ctx context.Context, req *Switch
 func (*UnimplementedImportSSTServer) GetMode(ctx context.Context, req *GetModeRequest) (*GetModeResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method GetMode not implemented")
 }
+func (*UnimplementedImportSSTServer) Lease(ctx context.Context, req *LeaseRequest) (*LeaseResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method Lease not implemented")
+}
 func (*UnimplementedImportSSTServer) Upload(srv ImportSST_UploadServer) error {
 	return status.Errorf(codes.Unimplemented, "method Upload not implemented")
 }
@@ -3159,13 +3479,31 @@ func _ImportSST_GetMode_Handler(srv interface{}, ctx context.Context, dec func(i
 	return interceptor(ctx, in, info, handler)
 }
 
-func _ImportSST_Upload_Handler(srv interface{}, stream grpc.ServerStream) error {
-	return srv.(ImportSSTServer).Upload(&importSSTUploadServer{stream})
-}
-
-type ImportSST_UploadServer interface {
-	SendAndClose(*UploadResponse) error
-	Recv() (*UploadRequest, error)
+func _ImportSST_Lease_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(LeaseRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(ImportSSTServer).Lease(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/import_sstpb.ImportSST/Lease",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(ImportSSTServer).Lease(ctx, req.(*LeaseRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _ImportSST_Upload_Handler(srv interface{}, stream grpc.ServerStream) error {
+	return srv.(ImportSSTServer).Upload(&importSSTUploadServer{stream})
+}
+
+type ImportSST_UploadServer interface {
+	SendAndClose(*UploadResponse) error
+	Recv() (*UploadRequest, error)
 	grpc.ServerStream
 }
 
@@ -3414,6 +3752,10 @@ var _ImportSST_serviceDesc = grpc.ServiceDesc{
 			MethodName: "GetMode",
 			Handler:    _ImportSST_GetMode_Handler,
 		},
+		{
+			MethodName: "Lease",
+			Handler:    _ImportSST_Lease_Handler,
+		},
 		{
 			MethodName: "Ingest",
 			Handler:    _ImportSST_Ingest_Handler,
@@ -3690,6 +4032,250 @@ func (m *GetModeResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	return len(dAtA) - i, nil
 }
 
+func (m *Lease) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *Lease) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Lease) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.XXX_unrecognized != nil {
+		i -= len(m.XXX_unrecognized)
+		copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	if len(m.Uuid) > 0 {
+		i -= len(m.Uuid)
+		copy(dAtA[i:], m.Uuid)
+		i = encodeVarintImportSstpb(dAtA, i, uint64(len(m.Uuid)))
+		i--
+		dAtA[i] = 0x1a
+	}
+	if m.Region != nil {
+		{
+			size, err := m.Region.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintImportSstpb(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *AcquireLease) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *AcquireLease) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *AcquireLease) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.XXX_unrecognized != nil {
+		i -= len(m.XXX_unrecognized)
+		copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	if m.Ttl != 0 {
+		i = encodeVarintImportSstpb(dAtA, i, uint64(m.Ttl))
+		i--
+		dAtA[i] = 0x10
+	}
+	if m.Lease != nil {
+		{
+			size, err := m.Lease.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintImportSstpb(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *ReleaseLease) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *ReleaseLease) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *ReleaseLease) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.XXX_unrecognized != nil {
+		i -= len(m.XXX_unrecognized)
+		copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	if m.Lease != nil {
+		{
+			size, err := m.Lease.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintImportSstpb(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *LeaseRequest) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *LeaseRequest) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *LeaseRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.XXX_unrecognized != nil {
+		i -= len(m.XXX_unrecognized)
+		copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	if len(m.Release) > 0 {
+		for iNdEx := len(m.Release) - 1; iNdEx >= 0; iNdEx-- {
+			{
+				size, err := m.Release[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintImportSstpb(dAtA, i, uint64(size))
+			}
+			i--
+			dAtA[i] = 0x12
+		}
+	}
+	if len(m.Acquire) > 0 {
+		for iNdEx := len(m.Acquire) - 1; iNdEx >= 0; iNdEx-- {
+			{
+				size, err := m.Acquire[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintImportSstpb(dAtA, i, uint64(size))
+			}
+			i--
+			dAtA[i] = 0xa
+		}
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *LeaseResponse) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *LeaseResponse) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *LeaseResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.XXX_unrecognized != nil {
+		i -= len(m.XXX_unrecognized)
+		copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	if len(m.Released) > 0 {
+		for iNdEx := len(m.Released) - 1; iNdEx >= 0; iNdEx-- {
+			{
+				size, err := m.Released[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintImportSstpb(dAtA, i, uint64(size))
+			}
+			i--
+			dAtA[i] = 0x1a
+		}
+	}
+	if len(m.Acquired) > 0 {
+		for iNdEx := len(m.Acquired) - 1; iNdEx >= 0; iNdEx-- {
+			{
+				size, err := m.Acquired[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintImportSstpb(dAtA, i, uint64(size))
+			}
+			i--
+			dAtA[i] = 0x12
+		}
+	}
+	if m.Timestamp != 0 {
+		i = encodeVarintImportSstpb(dAtA, i, uint64(m.Timestamp))
+		i--
+		dAtA[i] = 0x8
+	}
+	return len(dAtA) - i, nil
+}
+
 func (m *Range) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
@@ -3986,6 +4572,18 @@ func (m *UploadResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 		i -= len(m.XXX_unrecognized)
 		copy(dAtA[i:], m.XXX_unrecognized)
 	}
+	if m.Error != nil {
+		{
+			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintImportSstpb(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0xa
+	}
 	return len(dAtA) - i, nil
 }
 
@@ -5619,17 +6217,17 @@ func (m *GetModeResponse) Size() (n int) {
 	return n
 }
 
-func (m *Range) Size() (n int) {
+func (m *Lease) Size() (n int) {
 	if m == nil {
 		return 0
 	}
 	var l int
 	_ = l
-	l = len(m.Start)
-	if l > 0 {
+	if m.Region != nil {
+		l = m.Region.Size()
 		n += 1 + l + sovImportSstpb(uint64(l))
 	}
-	l = len(m.End)
+	l = len(m.Uuid)
 	if l > 0 {
 		n += 1 + l + sovImportSstpb(uint64(l))
 	}
@@ -5639,19 +6237,125 @@ func (m *Range) Size() (n int) {
 	return n
 }
 
-func (m *SSTMeta) Size() (n int) {
+func (m *AcquireLease) Size() (n int) {
 	if m == nil {
 		return 0
 	}
 	var l int
 	_ = l
-	l = len(m.Uuid)
-	if l > 0 {
+	if m.Lease != nil {
+		l = m.Lease.Size()
 		n += 1 + l + sovImportSstpb(uint64(l))
 	}
-	if m.Range != nil {
-		l = m.Range.Size()
-		n += 1 + l + sovImportSstpb(uint64(l))
+	if m.Ttl != 0 {
+		n += 1 + sovImportSstpb(uint64(m.Ttl))
+	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
+	return n
+}
+
+func (m *ReleaseLease) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.Lease != nil {
+		l = m.Lease.Size()
+		n += 1 + l + sovImportSstpb(uint64(l))
+	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
+	return n
+}
+
+func (m *LeaseRequest) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if len(m.Acquire) > 0 {
+		for _, e := range m.Acquire {
+			l = e.Size()
+			n += 1 + l + sovImportSstpb(uint64(l))
+		}
+	}
+	if len(m.Release) > 0 {
+		for _, e := range m.Release {
+			l = e.Size()
+			n += 1 + l + sovImportSstpb(uint64(l))
+		}
+	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
+	return n
+}
+
+func (m *LeaseResponse) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.Timestamp != 0 {
+		n += 1 + sovImportSstpb(uint64(m.Timestamp))
+	}
+	if len(m.Acquired) > 0 {
+		for _, e := range m.Acquired {
+			l = e.Size()
+			n += 1 + l + sovImportSstpb(uint64(l))
+		}
+	}
+	if len(m.Released) > 0 {
+		for _, e := range m.Released {
+			l = e.Size()
+			n += 1 + l + sovImportSstpb(uint64(l))
+		}
+	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
+	return n
+}
+
+func (m *Range) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.Start)
+	if l > 0 {
+		n += 1 + l + sovImportSstpb(uint64(l))
+	}
+	l = len(m.End)
+	if l > 0 {
+		n += 1 + l + sovImportSstpb(uint64(l))
+	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
+	return n
+}
+
+func (m *SSTMeta) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.Uuid)
+	if l > 0 {
+		n += 1 + l + sovImportSstpb(uint64(l))
+	}
+	if m.Range != nil {
+		l = m.Range.Size()
+		n += 1 + l + sovImportSstpb(uint64(l))
 	}
 	if m.Crc32 != 0 {
 		n += 1 + sovImportSstpb(uint64(m.Crc32))
@@ -5760,6 +6464,10 @@ func (m *UploadResponse) Size() (n int) {
 	}
 	var l int
 	_ = l
+	if m.Error != nil {
+		l = m.Error.Size()
+		n += 1 + l + sovImportSstpb(uint64(l))
+	}
 	if m.XXX_unrecognized != nil {
 		n += len(m.XXX_unrecognized)
 	}
@@ -6901,7 +7609,7 @@ func (m *GetModeResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *Range) Unmarshal(dAtA []byte) error {
+func (m *Lease) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -6924,17 +7632,17 @@ func (m *Range) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: Range: wiretype end group for non-group")
+			return fmt.Errorf("proto: Lease: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: Range: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: Lease: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Start", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Region", wireType)
 			}
-			var byteLen int
+			var msglen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowImportSstpb
@@ -6944,29 +7652,31 @@ func (m *Range) 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 ErrInvalidLengthImportSstpb
 			}
-			postIndex := iNdEx + byteLen
+			postIndex := iNdEx + msglen
 			if postIndex < 0 {
 				return ErrInvalidLengthImportSstpb
 			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Start = append(m.Start[:0], dAtA[iNdEx:postIndex]...)
-			if m.Start == nil {
-				m.Start = []byte{}
+			if m.Region == nil {
+				m.Region = &metapb.Region{}
+			}
+			if err := m.Region.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
 			}
 			iNdEx = postIndex
-		case 2:
+		case 3:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field End", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Uuid", wireType)
 			}
 			var byteLen int
 			for shift := uint(0); ; shift += 7 {
@@ -6993,9 +7703,9 @@ func (m *Range) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.End = append(m.End[:0], dAtA[iNdEx:postIndex]...)
-			if m.End == nil {
-				m.End = []byte{}
+			m.Uuid = append(m.Uuid[:0], dAtA[iNdEx:postIndex]...)
+			if m.Uuid == nil {
+				m.Uuid = []byte{}
 			}
 			iNdEx = postIndex
 		default:
@@ -7020,7 +7730,7 @@ func (m *Range) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *SSTMeta) Unmarshal(dAtA []byte) error {
+func (m *AcquireLease) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -7043,49 +7753,15 @@ func (m *SSTMeta) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: SSTMeta: wiretype end group for non-group")
+			return fmt.Errorf("proto: AcquireLease: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: SSTMeta: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: AcquireLease: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Uuid", wireType)
-			}
-			var byteLen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowImportSstpb
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				byteLen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if byteLen < 0 {
-				return ErrInvalidLengthImportSstpb
-			}
-			postIndex := iNdEx + byteLen
-			if postIndex < 0 {
-				return ErrInvalidLengthImportSstpb
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.Uuid = append(m.Uuid[:0], dAtA[iNdEx:postIndex]...)
-			if m.Uuid == nil {
-				m.Uuid = []byte{}
-			}
-			iNdEx = postIndex
-		case 2:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Range", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Lease", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -7112,18 +7788,18 @@ func (m *SSTMeta) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.Range == nil {
-				m.Range = &Range{}
+			if m.Lease == nil {
+				m.Lease = &Lease{}
 			}
-			if err := m.Range.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if err := m.Lease.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
-		case 3:
+		case 2:
 			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Crc32", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Ttl", wireType)
 			}
-			m.Crc32 = 0
+			m.Ttl = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowImportSstpb
@@ -7133,35 +7809,67 @@ func (m *SSTMeta) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.Crc32 |= uint32(b&0x7F) << shift
+				m.Ttl |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-		case 4:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Length", wireType)
+		default:
+			iNdEx = preIndex
+			skippy, err := skipImportSstpb(dAtA[iNdEx:])
+			if err != nil {
+				return err
 			}
-			m.Length = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowImportSstpb
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.Length |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthImportSstpb
 			}
-		case 5:
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *ReleaseLease) 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 ErrIntOverflowImportSstpb
+			}
+			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: ReleaseLease: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: ReleaseLease: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field CfName", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Lease", wireType)
 			}
-			var stringLen uint64
+			var msglen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowImportSstpb
@@ -7171,32 +7879,603 @@ func (m *SSTMeta) 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 ErrInvalidLengthImportSstpb
 			}
-			postIndex := iNdEx + intStringLen
+			postIndex := iNdEx + msglen
 			if postIndex < 0 {
 				return ErrInvalidLengthImportSstpb
 			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.CfName = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		case 6:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field RegionId", wireType)
+			if m.Lease == nil {
+				m.Lease = &Lease{}
 			}
-			m.RegionId = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowImportSstpb
+			if err := m.Lease.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipImportSstpb(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthImportSstpb
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *LeaseRequest) 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 ErrIntOverflowImportSstpb
+			}
+			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: LeaseRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: LeaseRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Acquire", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowImportSstpb
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthImportSstpb
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthImportSstpb
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Acquire = append(m.Acquire, &AcquireLease{})
+			if err := m.Acquire[len(m.Acquire)-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 Release", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowImportSstpb
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthImportSstpb
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthImportSstpb
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Release = append(m.Release, &ReleaseLease{})
+			if err := m.Release[len(m.Release)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipImportSstpb(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthImportSstpb
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *LeaseResponse) 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 ErrIntOverflowImportSstpb
+			}
+			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: LeaseResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: LeaseResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType)
+			}
+			m.Timestamp = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowImportSstpb
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Timestamp |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Acquired", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowImportSstpb
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthImportSstpb
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthImportSstpb
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Acquired = append(m.Acquired, &Lease{})
+			if err := m.Acquired[len(m.Acquired)-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 Released", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowImportSstpb
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthImportSstpb
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthImportSstpb
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Released = append(m.Released, &Lease{})
+			if err := m.Released[len(m.Released)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipImportSstpb(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthImportSstpb
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *Range) 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 ErrIntOverflowImportSstpb
+			}
+			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: Range: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: Range: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Start", wireType)
+			}
+			var byteLen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowImportSstpb
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				byteLen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if byteLen < 0 {
+				return ErrInvalidLengthImportSstpb
+			}
+			postIndex := iNdEx + byteLen
+			if postIndex < 0 {
+				return ErrInvalidLengthImportSstpb
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Start = append(m.Start[:0], dAtA[iNdEx:postIndex]...)
+			if m.Start == nil {
+				m.Start = []byte{}
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field End", wireType)
+			}
+			var byteLen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowImportSstpb
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				byteLen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if byteLen < 0 {
+				return ErrInvalidLengthImportSstpb
+			}
+			postIndex := iNdEx + byteLen
+			if postIndex < 0 {
+				return ErrInvalidLengthImportSstpb
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.End = append(m.End[:0], dAtA[iNdEx:postIndex]...)
+			if m.End == nil {
+				m.End = []byte{}
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipImportSstpb(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthImportSstpb
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *SSTMeta) 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 ErrIntOverflowImportSstpb
+			}
+			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: SSTMeta: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: SSTMeta: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Uuid", wireType)
+			}
+			var byteLen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowImportSstpb
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				byteLen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if byteLen < 0 {
+				return ErrInvalidLengthImportSstpb
+			}
+			postIndex := iNdEx + byteLen
+			if postIndex < 0 {
+				return ErrInvalidLengthImportSstpb
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Uuid = append(m.Uuid[:0], dAtA[iNdEx:postIndex]...)
+			if m.Uuid == nil {
+				m.Uuid = []byte{}
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Range", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowImportSstpb
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthImportSstpb
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthImportSstpb
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Range == nil {
+				m.Range = &Range{}
+			}
+			if err := m.Range.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 3:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Crc32", wireType)
+			}
+			m.Crc32 = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowImportSstpb
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Crc32 |= uint32(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 4:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Length", wireType)
+			}
+			m.Length = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowImportSstpb
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Length |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 5:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field CfName", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowImportSstpb
+				}
+				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 ErrInvalidLengthImportSstpb
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthImportSstpb
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.CfName = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 6:
+			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 ErrIntOverflowImportSstpb
 				}
 				if iNdEx >= l {
 					return io.ErrUnexpectedEOF
@@ -7663,6 +8942,42 @@ func (m *UploadResponse) Unmarshal(dAtA []byte) error {
 			return fmt.Errorf("proto: UploadResponse: 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 msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowImportSstpb
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthImportSstpb
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthImportSstpb
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Error == nil {
+				m.Error = &errorpb.Error{}
+			}
+			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipImportSstpb(dAtA[iNdEx:])
diff --git a/proto/import_sstpb.proto b/proto/import_sstpb.proto
index 089dd35f4..3b0ef9599 100644
--- a/proto/import_sstpb.proto
+++ b/proto/import_sstpb.proto
@@ -36,6 +36,9 @@ service ImportSST {
     rpc SwitchMode(SwitchModeRequest) returns (SwitchModeResponse) {}
     // Get import mode(normal/import).
     rpc GetMode(GetModeRequest) returns (GetModeResponse) {}
+
+    rpc Lease(LeaseRequest) returns (LeaseResponse) {}
+
     // Upload an SST file to a server.
     rpc Upload(stream UploadRequest) returns (UploadResponse) {}
     // Ingest an uploaded SST file to a region.
@@ -106,6 +109,40 @@ message GetModeResponse {
     SwitchMode mode = 1;
 }
 
+message Lease {
+    metapb.Region region = 1;
+    // A Random (Version 4) UUID.
+    // This is used by SSTMeta to prevent interference between concurrent imports.
+    bytes uuid = 3;
+}
+
+// AcquireLease notify TiKV to allow importing data that are described in the
+// request.
+// The allowance is effective during the time span [now, now+lease].
+message AcquireLease {
+    Lease lease = 1;
+    // Time to alive in seconds.
+    uint64 ttl = 2;
+}
+
+// ReleaseLease expires leases immediately.
+message ReleaseLease {
+    Lease lease = 1;
+}
+
+message LeaseRequest {
+    repeated AcquireLease acquire = 1;
+    repeated ReleaseLease release = 2;
+}
+
+message LeaseResponse {
+    // The timestamp when the leases take effect (starting from the unix epoch
+    // in seconds)
+    uint64 timestamp = 1;
+    repeated Lease acquired = 2;
+    repeated Lease released = 3;
+}
+
 message Range {
     bytes start = 1;
     bytes end = 2;
@@ -146,6 +183,7 @@ message UploadRequest {
 }
 
 message UploadResponse {
+    errorpb.Error error = 1;
 }
 
 message IngestRequest {
@@ -215,7 +253,7 @@ message DownloadRequest {
     string storage_cache_id = 17;
 
     bool is_raw_kv = 15;
-    // cipher_info is used to decrypt sst when download sst 
+    // cipher_info is used to decrypt sst when download sst
     backup.CipherInfo cipher_info = 16;
 
     // The type of the download request.
@@ -234,7 +272,7 @@ enum DownloadRequestType {
 // of gRPC, add more concrete types if it is necessary later.
 message Error {
     string message = 1;
-    
+
     // We meet some internal errors of the store.
     errorpb.Error store_error = 2;
 }
diff --git a/scripts/proto.lock b/scripts/proto.lock
index 9458126f5..e3e3a4d0f 100644
--- a/scripts/proto.lock
+++ b/scripts/proto.lock
@@ -777,20 +777,17 @@
               {
                 "id": 3,
                 "name": "cluster_id_error",
-                "type": "ClusterIDError",
-                "oneof_parent": "detail"
+                "type": "ClusterIDError"
               },
               {
                 "id": 4,
                 "name": "kv_error",
-                "type": "kvrpcpb.KeyError",
-                "oneof_parent": "detail"
+                "type": "kvrpcpb.KeyError"
               },
               {
                 "id": 5,
                 "name": "region_error",
-                "type": "errorpb.Error",
-                "oneof_parent": "detail"
+                "type": "errorpb.Error"
               }
             ]
           },
@@ -963,44 +960,37 @@
               {
                 "id": 1,
                 "name": "noop",
-                "type": "Noop",
-                "oneof_parent": "backend"
+                "type": "Noop"
               },
               {
                 "id": 2,
                 "name": "local",
-                "type": "Local",
-                "oneof_parent": "backend"
+                "type": "Local"
               },
               {
                 "id": 3,
                 "name": "s3",
-                "type": "S3",
-                "oneof_parent": "backend"
+                "type": "S3"
               },
               {
                 "id": 4,
                 "name": "gcs",
-                "type": "GCS",
-                "oneof_parent": "backend"
+                "type": "GCS"
               },
               {
                 "id": 5,
                 "name": "cloud_dynamic",
-                "type": "CloudDynamic",
-                "oneof_parent": "backend"
+                "type": "CloudDynamic"
               },
               {
                 "id": 6,
                 "name": "hdfs",
-                "type": "HDFS",
-                "oneof_parent": "backend"
+                "type": "HDFS"
               },
               {
                 "id": 7,
                 "name": "azure_blob_storage",
-                "type": "AzureBlobStorage",
-                "oneof_parent": "backend"
+                "type": "AzureBlobStorage"
               }
             ]
           },
@@ -1954,20 +1944,17 @@
               {
                 "id": 3,
                 "name": "entries",
-                "type": "Entries",
-                "oneof_parent": "event"
+                "type": "Entries"
               },
               {
                 "id": 4,
                 "name": "admin",
-                "type": "Admin",
-                "oneof_parent": "event"
+                "type": "Admin"
               },
               {
                 "id": 5,
                 "name": "error",
-                "type": "Error",
-                "oneof_parent": "event"
+                "type": "Error"
               },
               {
                 "id": 6,
@@ -1978,14 +1965,12 @@
                     "name": "deprecated",
                     "value": "true"
                   }
-                ],
-                "oneof_parent": "event"
+                ]
               },
               {
                 "id": 8,
                 "name": "long_txn",
-                "type": "LongTxn",
-                "oneof_parent": "event"
+                "type": "LongTxn"
               }
             ],
             "messages": [
@@ -2161,20 +2146,17 @@
               {
                 "id": 9,
                 "name": "register",
-                "type": "Register",
-                "oneof_parent": "request"
+                "type": "Register"
               },
               {
                 "id": 10,
                 "name": "notify_txn_status",
-                "type": "NotifyTxnStatus",
-                "oneof_parent": "request"
+                "type": "NotifyTxnStatus"
               },
               {
                 "id": 13,
                 "name": "deregister",
-                "type": "Deregister",
-                "oneof_parent": "request"
+                "type": "Deregister"
               },
               {
                 "id": 11,
@@ -2366,14 +2348,12 @@
               {
                 "id": 1,
                 "name": "local",
-                "type": "Local",
-                "oneof_parent": "kind"
+                "type": "Local"
               },
               {
                 "id": 2,
                 "name": "global",
-                "type": "Global",
-                "oneof_parent": "kind"
+                "type": "Global"
               }
             ]
           },
@@ -4479,20 +4459,17 @@
               {
                 "id": 1,
                 "name": "success",
-                "type": "Success",
-                "oneof_parent": "error"
+                "type": "Success"
               },
               {
                 "id": 2,
                 "name": "not_owner",
-                "type": "NotOwner",
-                "oneof_parent": "error"
+                "type": "NotOwner"
               },
               {
                 "id": 3,
                 "name": "conflict",
-                "type": "Conflict",
-                "oneof_parent": "error"
+                "type": "Conflict"
               }
             ]
           },
@@ -4676,20 +4653,17 @@
               {
                 "id": 1,
                 "name": "error_region",
-                "type": "ErrorRegion",
-                "oneof_parent": "errors"
+                "type": "ErrorRegion"
               },
               {
                 "id": 2,
                 "name": "error_locked",
-                "type": "ErrorLocked",
-                "oneof_parent": "errors"
+                "type": "ErrorLocked"
               },
               {
                 "id": 99,
                 "name": "error_other",
-                "type": "ErrorOther",
-                "oneof_parent": "errors"
+                "type": "ErrorOther"
               }
             ]
           },
@@ -5069,20 +5043,17 @@
               {
                 "id": 1,
                 "name": "plaintext",
-                "type": "MasterKeyPlaintext",
-                "oneof_parent": "backend"
+                "type": "MasterKeyPlaintext"
               },
               {
                 "id": 2,
                 "name": "file",
-                "type": "MasterKeyFile",
-                "oneof_parent": "backend"
+                "type": "MasterKeyFile"
               },
               {
                 "id": 3,
                 "name": "kms",
-                "type": "MasterKeyKms",
-                "oneof_parent": "backend"
+                "type": "MasterKeyKms"
               }
             ]
           },
@@ -5364,14 +5335,12 @@
               {
                 "id": 1,
                 "name": "state",
-                "type": "SnapshotState",
-                "oneof_parent": "chunk"
+                "type": "SnapshotState"
               },
               {
                 "id": 2,
                 "name": "data",
-                "type": "SnapshotData",
-                "oneof_parent": "chunk"
+                "type": "SnapshotData"
               }
             ]
           },
@@ -6266,14 +6235,12 @@
               {
                 "id": 1,
                 "name": "head",
-                "type": "WriteHead",
-                "oneof_parent": "chunk"
+                "type": "WriteHead"
               },
               {
                 "id": 2,
                 "name": "batch",
-                "type": "WriteBatch",
-                "oneof_parent": "chunk"
+                "type": "WriteBatch"
               }
             ]
           },
@@ -6646,6 +6613,85 @@
               }
             ]
           },
+          {
+            "name": "Lease",
+            "fields": [
+              {
+                "id": 1,
+                "name": "region",
+                "type": "metapb.Region"
+              },
+              {
+                "id": 3,
+                "name": "uuid",
+                "type": "bytes"
+              }
+            ]
+          },
+          {
+            "name": "AcquireLease",
+            "fields": [
+              {
+                "id": 1,
+                "name": "lease",
+                "type": "Lease"
+              },
+              {
+                "id": 2,
+                "name": "ttl",
+                "type": "uint64"
+              }
+            ]
+          },
+          {
+            "name": "ReleaseLease",
+            "fields": [
+              {
+                "id": 1,
+                "name": "lease",
+                "type": "Lease"
+              }
+            ]
+          },
+          {
+            "name": "LeaseRequest",
+            "fields": [
+              {
+                "id": 1,
+                "name": "acquire",
+                "type": "AcquireLease",
+                "is_repeated": true
+              },
+              {
+                "id": 2,
+                "name": "release",
+                "type": "ReleaseLease",
+                "is_repeated": true
+              }
+            ]
+          },
+          {
+            "name": "LeaseResponse",
+            "fields": [
+              {
+                "id": 1,
+                "name": "timestamp",
+                "type": "uint64"
+              },
+              {
+                "id": 2,
+                "name": "acquired",
+                "type": "Lease",
+                "is_repeated": true
+              },
+              {
+                "id": 3,
+                "name": "released",
+                "type": "Lease",
+                "is_repeated": true
+              }
+            ]
+          },
           {
             "name": "Range",
             "fields": [
@@ -6752,19 +6798,24 @@
               {
                 "id": 1,
                 "name": "meta",
-                "type": "SSTMeta",
-                "oneof_parent": "chunk"
+                "type": "SSTMeta"
               },
               {
                 "id": 2,
                 "name": "data",
-                "type": "bytes",
-                "oneof_parent": "chunk"
+                "type": "bytes"
               }
             ]
           },
           {
-            "name": "UploadResponse"
+            "name": "UploadResponse",
+            "fields": [
+              {
+                "id": 1,
+                "name": "error",
+                "type": "errorpb.Error"
+              }
+            ]
           },
           {
             "name": "IngestRequest",
@@ -7025,14 +7076,12 @@
               {
                 "id": 1,
                 "name": "meta",
-                "type": "SSTMeta",
-                "oneof_parent": "chunk"
+                "type": "SSTMeta"
               },
               {
                 "id": 2,
                 "name": "batch",
-                "type": "WriteBatch",
-                "oneof_parent": "chunk"
+                "type": "WriteBatch"
               },
               {
                 "id": 3,
@@ -7084,14 +7133,12 @@
               {
                 "id": 1,
                 "name": "meta",
-                "type": "SSTMeta",
-                "oneof_parent": "chunk"
+                "type": "SSTMeta"
               },
               {
                 "id": 2,
                 "name": "batch",
-                "type": "RawWriteBatch",
-                "oneof_parent": "chunk"
+                "type": "RawWriteBatch"
               },
               {
                 "id": 3,
@@ -7366,6 +7413,11 @@
                 "in_type": "GetModeRequest",
                 "out_type": "GetModeResponse"
               },
+              {
+                "name": "Lease",
+                "in_type": "LeaseRequest",
+                "out_type": "LeaseResponse"
+              },
               {
                 "name": "Upload",
                 "in_type": "UploadRequest",
@@ -11332,26 +11384,22 @@
               {
                 "id": 1,
                 "name": "err_invalid_start_key",
-                "type": "CompactErrorInvalidStartKey",
-                "oneof_parent": "error"
+                "type": "CompactErrorInvalidStartKey"
               },
               {
                 "id": 2,
                 "name": "err_physical_table_not_exist",
-                "type": "CompactErrorPhysicalTableNotExist",
-                "oneof_parent": "error"
+                "type": "CompactErrorPhysicalTableNotExist"
               },
               {
                 "id": 3,
                 "name": "err_compact_in_progress",
-                "type": "CompactErrorCompactInProgress",
-                "oneof_parent": "error"
+                "type": "CompactErrorCompactInProgress"
               },
               {
                 "id": 4,
                 "name": "err_too_many_pending_tasks",
-                "type": "CompactErrorTooManyPendingTasks",
-                "oneof_parent": "error"
+                "type": "CompactErrorTooManyPendingTasks"
               }
             ]
           },
@@ -17491,26 +17539,22 @@
               {
                 "id": 1,
                 "name": "head",
-                "type": "TabletSnapshotHead",
-                "oneof_parent": "payload"
+                "type": "TabletSnapshotHead"
               },
               {
                 "id": 2,
                 "name": "preview",
-                "type": "TabletSnapshotPreview",
-                "oneof_parent": "payload"
+                "type": "TabletSnapshotPreview"
               },
               {
                 "id": 3,
                 "name": "chunk",
-                "type": "TabletSnapshotFileChunk",
-                "oneof_parent": "payload"
+                "type": "TabletSnapshotFileChunk"
               },
               {
                 "id": 4,
                 "name": "end",
-                "type": "TabletSnapshotEnd",
-                "oneof_parent": "payload"
+                "type": "TabletSnapshotEnd"
               }
             ]
           },
@@ -18563,14 +18607,12 @@
               {
                 "id": 2,
                 "name": "ru_items",
-                "type": "RequestRU",
-                "oneof_parent": "request"
+                "type": "RequestRU"
               },
               {
                 "id": 3,
                 "name": "raw_resource_items",
-                "type": "RequestRawResource",
-                "oneof_parent": "request"
+                "type": "RequestRawResource"
               },
               {
                 "id": 4,
@@ -19050,8 +19092,7 @@
               {
                 "id": 1,
                 "name": "record",
-                "type": "GroupTagRecord",
-                "oneof_parent": "record_oneof"
+                "type": "GroupTagRecord"
               }
             ]
           },
@@ -19695,188 +19736,157 @@
                   {
                     "id": 1,
                     "name": "Get",
-                    "type": "kvrpcpb.GetRequest",
-                    "oneof_parent": "cmd"
+                    "type": "kvrpcpb.GetRequest"
                   },
                   {
                     "id": 2,
                     "name": "Scan",
-                    "type": "kvrpcpb.ScanRequest",
-                    "oneof_parent": "cmd"
+                    "type": "kvrpcpb.ScanRequest"
                   },
                   {
                     "id": 3,
                     "name": "Prewrite",
-                    "type": "kvrpcpb.PrewriteRequest",
-                    "oneof_parent": "cmd"
+                    "type": "kvrpcpb.PrewriteRequest"
                   },
                   {
                     "id": 4,
                     "name": "Commit",
-                    "type": "kvrpcpb.CommitRequest",
-                    "oneof_parent": "cmd"
+                    "type": "kvrpcpb.CommitRequest"
                   },
                   {
                     "id": 5,
                     "name": "Import",
-                    "type": "kvrpcpb.ImportRequest",
-                    "oneof_parent": "cmd"
+                    "type": "kvrpcpb.ImportRequest"
                   },
                   {
                     "id": 6,
                     "name": "Cleanup",
-                    "type": "kvrpcpb.CleanupRequest",
-                    "oneof_parent": "cmd"
+                    "type": "kvrpcpb.CleanupRequest"
                   },
                   {
                     "id": 7,
                     "name": "BatchGet",
-                    "type": "kvrpcpb.BatchGetRequest",
-                    "oneof_parent": "cmd"
+                    "type": "kvrpcpb.BatchGetRequest"
                   },
                   {
                     "id": 8,
                     "name": "BatchRollback",
-                    "type": "kvrpcpb.BatchRollbackRequest",
-                    "oneof_parent": "cmd"
+                    "type": "kvrpcpb.BatchRollbackRequest"
                   },
                   {
                     "id": 9,
                     "name": "ScanLock",
-                    "type": "kvrpcpb.ScanLockRequest",
-                    "oneof_parent": "cmd"
+                    "type": "kvrpcpb.ScanLockRequest"
                   },
                   {
                     "id": 10,
                     "name": "ResolveLock",
-                    "type": "kvrpcpb.ResolveLockRequest",
-                    "oneof_parent": "cmd"
+                    "type": "kvrpcpb.ResolveLockRequest"
                   },
                   {
                     "id": 11,
                     "name": "GC",
-                    "type": "kvrpcpb.GCRequest",
-                    "oneof_parent": "cmd"
+                    "type": "kvrpcpb.GCRequest"
                   },
                   {
                     "id": 12,
                     "name": "DeleteRange",
-                    "type": "kvrpcpb.DeleteRangeRequest",
-                    "oneof_parent": "cmd"
+                    "type": "kvrpcpb.DeleteRangeRequest"
                   },
                   {
                     "id": 13,
                     "name": "RawGet",
-                    "type": "kvrpcpb.RawGetRequest",
-                    "oneof_parent": "cmd"
+                    "type": "kvrpcpb.RawGetRequest"
                   },
                   {
                     "id": 14,
                     "name": "RawBatchGet",
-                    "type": "kvrpcpb.RawBatchGetRequest",
-                    "oneof_parent": "cmd"
+                    "type": "kvrpcpb.RawBatchGetRequest"
                   },
                   {
                     "id": 15,
                     "name": "RawPut",
-                    "type": "kvrpcpb.RawPutRequest",
-                    "oneof_parent": "cmd"
+                    "type": "kvrpcpb.RawPutRequest"
                   },
                   {
                     "id": 16,
                     "name": "RawBatchPut",
-                    "type": "kvrpcpb.RawBatchPutRequest",
-                    "oneof_parent": "cmd"
+                    "type": "kvrpcpb.RawBatchPutRequest"
                   },
                   {
                     "id": 17,
                     "name": "RawDelete",
-                    "type": "kvrpcpb.RawDeleteRequest",
-                    "oneof_parent": "cmd"
+                    "type": "kvrpcpb.RawDeleteRequest"
                   },
                   {
                     "id": 18,
                     "name": "RawBatchDelete",
-                    "type": "kvrpcpb.RawBatchDeleteRequest",
-                    "oneof_parent": "cmd"
+                    "type": "kvrpcpb.RawBatchDeleteRequest"
                   },
                   {
                     "id": 19,
                     "name": "RawScan",
-                    "type": "kvrpcpb.RawScanRequest",
-                    "oneof_parent": "cmd"
+                    "type": "kvrpcpb.RawScanRequest"
                   },
                   {
                     "id": 20,
                     "name": "RawDeleteRange",
-                    "type": "kvrpcpb.RawDeleteRangeRequest",
-                    "oneof_parent": "cmd"
+                    "type": "kvrpcpb.RawDeleteRangeRequest"
                   },
                   {
                     "id": 21,
                     "name": "RawBatchScan",
-                    "type": "kvrpcpb.RawBatchScanRequest",
-                    "oneof_parent": "cmd"
+                    "type": "kvrpcpb.RawBatchScanRequest"
                   },
                   {
                     "id": 22,
                     "name": "Coprocessor",
-                    "type": "coprocessor.Request",
-                    "oneof_parent": "cmd"
+                    "type": "coprocessor.Request"
                   },
                   {
                     "id": 23,
                     "name": "PessimisticLock",
-                    "type": "kvrpcpb.PessimisticLockRequest",
-                    "oneof_parent": "cmd"
+                    "type": "kvrpcpb.PessimisticLockRequest"
                   },
                   {
                     "id": 24,
                     "name": "PessimisticRollback",
-                    "type": "kvrpcpb.PessimisticRollbackRequest",
-                    "oneof_parent": "cmd"
+                    "type": "kvrpcpb.PessimisticRollbackRequest"
                   },
                   {
                     "id": 25,
                     "name": "CheckTxnStatus",
-                    "type": "kvrpcpb.CheckTxnStatusRequest",
-                    "oneof_parent": "cmd"
+                    "type": "kvrpcpb.CheckTxnStatusRequest"
                   },
                   {
                     "id": 26,
                     "name": "TxnHeartBeat",
-                    "type": "kvrpcpb.TxnHeartBeatRequest",
-                    "oneof_parent": "cmd"
+                    "type": "kvrpcpb.TxnHeartBeatRequest"
                   },
                   {
                     "id": 33,
                     "name": "CheckSecondaryLocks",
-                    "type": "kvrpcpb.CheckSecondaryLocksRequest",
-                    "oneof_parent": "cmd"
+                    "type": "kvrpcpb.CheckSecondaryLocksRequest"
                   },
                   {
                     "id": 34,
                     "name": "RawCoprocessor",
-                    "type": "kvrpcpb.RawCoprocessorRequest",
-                    "oneof_parent": "cmd"
+                    "type": "kvrpcpb.RawCoprocessorRequest"
                   },
                   {
                     "id": 35,
                     "name": "FlashbackToVersion",
-                    "type": "kvrpcpb.FlashbackToVersionRequest",
-                    "oneof_parent": "cmd"
+                    "type": "kvrpcpb.FlashbackToVersionRequest"
                   },
                   {
                     "id": 36,
                     "name": "PrepareFlashbackToVersion",
-                    "type": "kvrpcpb.PrepareFlashbackToVersionRequest",
-                    "oneof_parent": "cmd"
+                    "type": "kvrpcpb.PrepareFlashbackToVersionRequest"
                   },
                   {
                     "id": 255,
                     "name": "Empty",
-                    "type": "BatchCommandsEmptyRequest",
-                    "oneof_parent": "cmd"
+                    "type": "BatchCommandsEmptyRequest"
                   }
                 ],
                 "reserved_ids": [
@@ -19918,188 +19928,157 @@
                   {
                     "id": 1,
                     "name": "Get",
-                    "type": "kvrpcpb.GetResponse",
-                    "oneof_parent": "cmd"
+                    "type": "kvrpcpb.GetResponse"
                   },
                   {
                     "id": 2,
                     "name": "Scan",
-                    "type": "kvrpcpb.ScanResponse",
-                    "oneof_parent": "cmd"
+                    "type": "kvrpcpb.ScanResponse"
                   },
                   {
                     "id": 3,
                     "name": "Prewrite",
-                    "type": "kvrpcpb.PrewriteResponse",
-                    "oneof_parent": "cmd"
+                    "type": "kvrpcpb.PrewriteResponse"
                   },
                   {
                     "id": 4,
                     "name": "Commit",
-                    "type": "kvrpcpb.CommitResponse",
-                    "oneof_parent": "cmd"
+                    "type": "kvrpcpb.CommitResponse"
                   },
                   {
                     "id": 5,
                     "name": "Import",
-                    "type": "kvrpcpb.ImportResponse",
-                    "oneof_parent": "cmd"
+                    "type": "kvrpcpb.ImportResponse"
                   },
                   {
                     "id": 6,
                     "name": "Cleanup",
-                    "type": "kvrpcpb.CleanupResponse",
-                    "oneof_parent": "cmd"
+                    "type": "kvrpcpb.CleanupResponse"
                   },
                   {
                     "id": 7,
                     "name": "BatchGet",
-                    "type": "kvrpcpb.BatchGetResponse",
-                    "oneof_parent": "cmd"
+                    "type": "kvrpcpb.BatchGetResponse"
                   },
                   {
                     "id": 8,
                     "name": "BatchRollback",
-                    "type": "kvrpcpb.BatchRollbackResponse",
-                    "oneof_parent": "cmd"
+                    "type": "kvrpcpb.BatchRollbackResponse"
                   },
                   {
                     "id": 9,
                     "name": "ScanLock",
-                    "type": "kvrpcpb.ScanLockResponse",
-                    "oneof_parent": "cmd"
+                    "type": "kvrpcpb.ScanLockResponse"
                   },
                   {
                     "id": 10,
                     "name": "ResolveLock",
-                    "type": "kvrpcpb.ResolveLockResponse",
-                    "oneof_parent": "cmd"
+                    "type": "kvrpcpb.ResolveLockResponse"
                   },
                   {
                     "id": 11,
                     "name": "GC",
-                    "type": "kvrpcpb.GCResponse",
-                    "oneof_parent": "cmd"
+                    "type": "kvrpcpb.GCResponse"
                   },
                   {
                     "id": 12,
                     "name": "DeleteRange",
-                    "type": "kvrpcpb.DeleteRangeResponse",
-                    "oneof_parent": "cmd"
+                    "type": "kvrpcpb.DeleteRangeResponse"
                   },
                   {
                     "id": 13,
                     "name": "RawGet",
-                    "type": "kvrpcpb.RawGetResponse",
-                    "oneof_parent": "cmd"
+                    "type": "kvrpcpb.RawGetResponse"
                   },
                   {
                     "id": 14,
                     "name": "RawBatchGet",
-                    "type": "kvrpcpb.RawBatchGetResponse",
-                    "oneof_parent": "cmd"
+                    "type": "kvrpcpb.RawBatchGetResponse"
                   },
                   {
                     "id": 15,
                     "name": "RawPut",
-                    "type": "kvrpcpb.RawPutResponse",
-                    "oneof_parent": "cmd"
+                    "type": "kvrpcpb.RawPutResponse"
                   },
                   {
                     "id": 16,
                     "name": "RawBatchPut",
-                    "type": "kvrpcpb.RawBatchPutResponse",
-                    "oneof_parent": "cmd"
+                    "type": "kvrpcpb.RawBatchPutResponse"
                   },
                   {
                     "id": 17,
                     "name": "RawDelete",
-                    "type": "kvrpcpb.RawDeleteResponse",
-                    "oneof_parent": "cmd"
+                    "type": "kvrpcpb.RawDeleteResponse"
                   },
                   {
                     "id": 18,
                     "name": "RawBatchDelete",
-                    "type": "kvrpcpb.RawBatchDeleteResponse",
-                    "oneof_parent": "cmd"
+                    "type": "kvrpcpb.RawBatchDeleteResponse"
                   },
                   {
                     "id": 19,
                     "name": "RawScan",
-                    "type": "kvrpcpb.RawScanResponse",
-                    "oneof_parent": "cmd"
+                    "type": "kvrpcpb.RawScanResponse"
                   },
                   {
                     "id": 20,
                     "name": "RawDeleteRange",
-                    "type": "kvrpcpb.RawDeleteRangeResponse",
-                    "oneof_parent": "cmd"
+                    "type": "kvrpcpb.RawDeleteRangeResponse"
                   },
                   {
                     "id": 21,
                     "name": "RawBatchScan",
-                    "type": "kvrpcpb.RawBatchScanResponse",
-                    "oneof_parent": "cmd"
+                    "type": "kvrpcpb.RawBatchScanResponse"
                   },
                   {
                     "id": 22,
                     "name": "Coprocessor",
-                    "type": "coprocessor.Response",
-                    "oneof_parent": "cmd"
+                    "type": "coprocessor.Response"
                   },
                   {
                     "id": 23,
                     "name": "PessimisticLock",
-                    "type": "kvrpcpb.PessimisticLockResponse",
-                    "oneof_parent": "cmd"
+                    "type": "kvrpcpb.PessimisticLockResponse"
                   },
                   {
                     "id": 24,
                     "name": "PessimisticRollback",
-                    "type": "kvrpcpb.PessimisticRollbackResponse",
-                    "oneof_parent": "cmd"
+                    "type": "kvrpcpb.PessimisticRollbackResponse"
                   },
                   {
                     "id": 25,
                     "name": "CheckTxnStatus",
-                    "type": "kvrpcpb.CheckTxnStatusResponse",
-                    "oneof_parent": "cmd"
+                    "type": "kvrpcpb.CheckTxnStatusResponse"
                   },
                   {
                     "id": 26,
                     "name": "TxnHeartBeat",
-                    "type": "kvrpcpb.TxnHeartBeatResponse",
-                    "oneof_parent": "cmd"
+                    "type": "kvrpcpb.TxnHeartBeatResponse"
                   },
                   {
                     "id": 33,
                     "name": "CheckSecondaryLocks",
-                    "type": "kvrpcpb.CheckSecondaryLocksResponse",
-                    "oneof_parent": "cmd"
+                    "type": "kvrpcpb.CheckSecondaryLocksResponse"
                   },
                   {
                     "id": 34,
                     "name": "RawCoprocessor",
-                    "type": "kvrpcpb.RawCoprocessorResponse",
-                    "oneof_parent": "cmd"
+                    "type": "kvrpcpb.RawCoprocessorResponse"
                   },
                   {
                     "id": 35,
                     "name": "FlashbackToVersion",
-                    "type": "kvrpcpb.FlashbackToVersionResponse",
-                    "oneof_parent": "cmd"
+                    "type": "kvrpcpb.FlashbackToVersionResponse"
                   },
                   {
                     "id": 36,
                     "name": "PrepareFlashbackToVersion",
-                    "type": "kvrpcpb.PrepareFlashbackToVersionResponse",
-                    "oneof_parent": "cmd"
+                    "type": "kvrpcpb.PrepareFlashbackToVersionResponse"
                   },
                   {
                     "id": 255,
                     "name": "Empty",
-                    "type": "BatchCommandsEmptyResponse",
-                    "oneof_parent": "cmd"
+                    "type": "BatchCommandsEmptyResponse"
                   }
                 ],
                 "reserved_ids": [
@@ -20561,14 +20540,12 @@
               {
                 "id": 1,
                 "name": "report",
-                "type": "Report",
-                "oneof_parent": "record_oneof"
+                "type": "Report"
               },
               {
                 "id": 2,
                 "name": "notify_collect",
-                "type": "NotifyCollect",
-                "oneof_parent": "record_oneof"
+                "type": "NotifyCollect"
               }
             ]
           },