// Code generated by protoc-gen-go. DO NOT EDIT.
// source: data_service.proto

package datapb

import (
	context "context"
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	commonpb "github.com/zilliztech/milvus-distributed/internal/proto/commonpb"
	internalpb2 "github.com/zilliztech/milvus-distributed/internal/proto/internalpb2"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	math "math"
)

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

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

type SegmentState int32

const (
	SegmentState_SegmentNone     SegmentState = 0
	SegmentState_SegmentNotExist SegmentState = 1
	SegmentState_SegmentGrowing  SegmentState = 2
	SegmentState_SegmentSealed   SegmentState = 3
)

var SegmentState_name = map[int32]string{
	0: "SegmentNone",
	1: "SegmentNotExist",
	2: "SegmentGrowing",
	3: "SegmentSealed",
}

var SegmentState_value = map[string]int32{
	"SegmentNone":     0,
	"SegmentNotExist": 1,
	"SegmentGrowing":  2,
	"SegmentSealed":   3,
}

func (x SegmentState) String() string {
	return proto.EnumName(SegmentState_name, int32(x))
}

func (SegmentState) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_3385cd32ad6cfe64, []int{0}
}

type RegisterNodeRequest struct {
	Base                 *internalpb2.MsgBase `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"`
	Address              *commonpb.Address    `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

func (m *RegisterNodeRequest) Reset()         { *m = RegisterNodeRequest{} }
func (m *RegisterNodeRequest) String() string { return proto.CompactTextString(m) }
func (*RegisterNodeRequest) ProtoMessage()    {}
func (*RegisterNodeRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_3385cd32ad6cfe64, []int{0}
}

func (m *RegisterNodeRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_RegisterNodeRequest.Unmarshal(m, b)
}
func (m *RegisterNodeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_RegisterNodeRequest.Marshal(b, m, deterministic)
}
func (m *RegisterNodeRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RegisterNodeRequest.Merge(m, src)
}
func (m *RegisterNodeRequest) XXX_Size() int {
	return xxx_messageInfo_RegisterNodeRequest.Size(m)
}
func (m *RegisterNodeRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RegisterNodeRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RegisterNodeRequest proto.InternalMessageInfo

func (m *RegisterNodeRequest) GetBase() *internalpb2.MsgBase {
	if m != nil {
		return m.Base
	}
	return nil
}

func (m *RegisterNodeRequest) GetAddress() *commonpb.Address {
	if m != nil {
		return m.Address
	}
	return nil
}

type RegisterNodeResponse struct {
	InitParams           *internalpb2.InitParams `protobuf:"bytes,1,opt,name=init_params,json=initParams,proto3" json:"init_params,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                `json:"-"`
	XXX_unrecognized     []byte                  `json:"-"`
	XXX_sizecache        int32                   `json:"-"`
}

func (m *RegisterNodeResponse) Reset()         { *m = RegisterNodeResponse{} }
func (m *RegisterNodeResponse) String() string { return proto.CompactTextString(m) }
func (*RegisterNodeResponse) ProtoMessage()    {}
func (*RegisterNodeResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_3385cd32ad6cfe64, []int{1}
}

func (m *RegisterNodeResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_RegisterNodeResponse.Unmarshal(m, b)
}
func (m *RegisterNodeResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_RegisterNodeResponse.Marshal(b, m, deterministic)
}
func (m *RegisterNodeResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RegisterNodeResponse.Merge(m, src)
}
func (m *RegisterNodeResponse) XXX_Size() int {
	return xxx_messageInfo_RegisterNodeResponse.Size(m)
}
func (m *RegisterNodeResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RegisterNodeResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RegisterNodeResponse proto.InternalMessageInfo

func (m *RegisterNodeResponse) GetInitParams() *internalpb2.InitParams {
	if m != nil {
		return m.InitParams
	}
	return nil
}

type SegIDRequest struct {
	Count                int32    `protobuf:"varint,1,opt,name=count,proto3" json:"count,omitempty"`
	ChannelID            string   `protobuf:"bytes,2,opt,name=channelID,proto3" json:"channelID,omitempty"`
	CollectionID         int64    `protobuf:"varint,3,opt,name=collectionID,proto3" json:"collectionID,omitempty"`
	PartitionID          int64    `protobuf:"varint,4,opt,name=partitionID,proto3" json:"partitionID,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *SegIDRequest) Reset()         { *m = SegIDRequest{} }
func (m *SegIDRequest) String() string { return proto.CompactTextString(m) }
func (*SegIDRequest) ProtoMessage()    {}
func (*SegIDRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_3385cd32ad6cfe64, []int{2}
}

func (m *SegIDRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_SegIDRequest.Unmarshal(m, b)
}
func (m *SegIDRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_SegIDRequest.Marshal(b, m, deterministic)
}
func (m *SegIDRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SegIDRequest.Merge(m, src)
}
func (m *SegIDRequest) XXX_Size() int {
	return xxx_messageInfo_SegIDRequest.Size(m)
}
func (m *SegIDRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_SegIDRequest.DiscardUnknown(m)
}

var xxx_messageInfo_SegIDRequest proto.InternalMessageInfo

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

func (m *SegIDRequest) GetChannelID() string {
	if m != nil {
		return m.ChannelID
	}
	return ""
}

func (m *SegIDRequest) GetCollectionID() int64 {
	if m != nil {
		return m.CollectionID
	}
	return 0
}

func (m *SegIDRequest) GetPartitionID() int64 {
	if m != nil {
		return m.PartitionID
	}
	return 0
}

type AssignSegIDRequest struct {
	NodeID               int64           `protobuf:"varint,1,opt,name=nodeID,proto3" json:"nodeID,omitempty"`
	PeerRole             string          `protobuf:"bytes,2,opt,name=peer_role,json=peerRole,proto3" json:"peer_role,omitempty"`
	SegIDRequests        []*SegIDRequest `protobuf:"bytes,3,rep,name=segIDRequests,proto3" json:"segIDRequests,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

func (m *AssignSegIDRequest) Reset()         { *m = AssignSegIDRequest{} }
func (m *AssignSegIDRequest) String() string { return proto.CompactTextString(m) }
func (*AssignSegIDRequest) ProtoMessage()    {}
func (*AssignSegIDRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_3385cd32ad6cfe64, []int{3}
}

func (m *AssignSegIDRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_AssignSegIDRequest.Unmarshal(m, b)
}
func (m *AssignSegIDRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_AssignSegIDRequest.Marshal(b, m, deterministic)
}
func (m *AssignSegIDRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AssignSegIDRequest.Merge(m, src)
}
func (m *AssignSegIDRequest) XXX_Size() int {
	return xxx_messageInfo_AssignSegIDRequest.Size(m)
}
func (m *AssignSegIDRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_AssignSegIDRequest.DiscardUnknown(m)
}

var xxx_messageInfo_AssignSegIDRequest proto.InternalMessageInfo

func (m *AssignSegIDRequest) GetNodeID() int64 {
	if m != nil {
		return m.NodeID
	}
	return 0
}

func (m *AssignSegIDRequest) GetPeerRole() string {
	if m != nil {
		return m.PeerRole
	}
	return ""
}

func (m *AssignSegIDRequest) GetSegIDRequests() []*SegIDRequest {
	if m != nil {
		return m.SegIDRequests
	}
	return nil
}

type SegIDAssignment struct {
	SegID                int64            `protobuf:"varint,1,opt,name=segID,proto3" json:"segID,omitempty"`
	ChannelID            int32            `protobuf:"varint,2,opt,name=channelID,proto3" json:"channelID,omitempty"`
	Count                uint32           `protobuf:"varint,3,opt,name=count,proto3" json:"count,omitempty"`
	CollectionID         int64            `protobuf:"varint,4,opt,name=collectionID,proto3" json:"collectionID,omitempty"`
	PartitionID          int64            `protobuf:"varint,5,opt,name=partitionID,proto3" json:"partitionID,omitempty"`
	ExpireTime           uint64           `protobuf:"varint,6,opt,name=expire_time,json=expireTime,proto3" json:"expire_time,omitempty"`
	Status               *commonpb.Status `protobuf:"bytes,7,opt,name=status,proto3" json:"status,omitempty"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

func (m *SegIDAssignment) Reset()         { *m = SegIDAssignment{} }
func (m *SegIDAssignment) String() string { return proto.CompactTextString(m) }
func (*SegIDAssignment) ProtoMessage()    {}
func (*SegIDAssignment) Descriptor() ([]byte, []int) {
	return fileDescriptor_3385cd32ad6cfe64, []int{4}
}

func (m *SegIDAssignment) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_SegIDAssignment.Unmarshal(m, b)
}
func (m *SegIDAssignment) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_SegIDAssignment.Marshal(b, m, deterministic)
}
func (m *SegIDAssignment) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SegIDAssignment.Merge(m, src)
}
func (m *SegIDAssignment) XXX_Size() int {
	return xxx_messageInfo_SegIDAssignment.Size(m)
}
func (m *SegIDAssignment) XXX_DiscardUnknown() {
	xxx_messageInfo_SegIDAssignment.DiscardUnknown(m)
}

var xxx_messageInfo_SegIDAssignment proto.InternalMessageInfo

func (m *SegIDAssignment) GetSegID() int64 {
	if m != nil {
		return m.SegID
	}
	return 0
}

func (m *SegIDAssignment) GetChannelID() int32 {
	if m != nil {
		return m.ChannelID
	}
	return 0
}

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

func (m *SegIDAssignment) GetCollectionID() int64 {
	if m != nil {
		return m.CollectionID
	}
	return 0
}

func (m *SegIDAssignment) GetPartitionID() int64 {
	if m != nil {
		return m.PartitionID
	}
	return 0
}

func (m *SegIDAssignment) GetExpireTime() uint64 {
	if m != nil {
		return m.ExpireTime
	}
	return 0
}

func (m *SegIDAssignment) GetStatus() *commonpb.Status {
	if m != nil {
		return m.Status
	}
	return nil
}

type AssignSegIDResponse struct {
	SegIDAssignments     []*SegIDAssignment `protobuf:"bytes,1,rep,name=segIDAssignments,proto3" json:"segIDAssignments,omitempty"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
	XXX_unrecognized     []byte             `json:"-"`
	XXX_sizecache        int32              `json:"-"`
}

func (m *AssignSegIDResponse) Reset()         { *m = AssignSegIDResponse{} }
func (m *AssignSegIDResponse) String() string { return proto.CompactTextString(m) }
func (*AssignSegIDResponse) ProtoMessage()    {}
func (*AssignSegIDResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_3385cd32ad6cfe64, []int{5}
}

func (m *AssignSegIDResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_AssignSegIDResponse.Unmarshal(m, b)
}
func (m *AssignSegIDResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_AssignSegIDResponse.Marshal(b, m, deterministic)
}
func (m *AssignSegIDResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AssignSegIDResponse.Merge(m, src)
}
func (m *AssignSegIDResponse) XXX_Size() int {
	return xxx_messageInfo_AssignSegIDResponse.Size(m)
}
func (m *AssignSegIDResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_AssignSegIDResponse.DiscardUnknown(m)
}

var xxx_messageInfo_AssignSegIDResponse proto.InternalMessageInfo

func (m *AssignSegIDResponse) GetSegIDAssignments() []*SegIDAssignment {
	if m != nil {
		return m.SegIDAssignments
	}
	return nil
}

type FlushRequest struct {
	Base                 *internalpb2.MsgBase `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"`
	DbID                 int64                `protobuf:"varint,2,opt,name=dbID,proto3" json:"dbID,omitempty"`
	CollectionID         int64                `protobuf:"varint,4,opt,name=collectionID,proto3" json:"collectionID,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

func (m *FlushRequest) Reset()         { *m = FlushRequest{} }
func (m *FlushRequest) String() string { return proto.CompactTextString(m) }
func (*FlushRequest) ProtoMessage()    {}
func (*FlushRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_3385cd32ad6cfe64, []int{6}
}

func (m *FlushRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_FlushRequest.Unmarshal(m, b)
}
func (m *FlushRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_FlushRequest.Marshal(b, m, deterministic)
}
func (m *FlushRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_FlushRequest.Merge(m, src)
}
func (m *FlushRequest) XXX_Size() int {
	return xxx_messageInfo_FlushRequest.Size(m)
}
func (m *FlushRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_FlushRequest.DiscardUnknown(m)
}

var xxx_messageInfo_FlushRequest proto.InternalMessageInfo

func (m *FlushRequest) GetBase() *internalpb2.MsgBase {
	if m != nil {
		return m.Base
	}
	return nil
}

func (m *FlushRequest) GetDbID() int64 {
	if m != nil {
		return m.DbID
	}
	return 0
}

func (m *FlushRequest) GetCollectionID() int64 {
	if m != nil {
		return m.CollectionID
	}
	return 0
}

type ShowSegmentRequest struct {
	Base                 *internalpb2.MsgBase `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"`
	CollectionID         int64                `protobuf:"varint,2,opt,name=collectionID,proto3" json:"collectionID,omitempty"`
	PartitionID          int64                `protobuf:"varint,3,opt,name=partitionID,proto3" json:"partitionID,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

func (m *ShowSegmentRequest) Reset()         { *m = ShowSegmentRequest{} }
func (m *ShowSegmentRequest) String() string { return proto.CompactTextString(m) }
func (*ShowSegmentRequest) ProtoMessage()    {}
func (*ShowSegmentRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_3385cd32ad6cfe64, []int{7}
}

func (m *ShowSegmentRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ShowSegmentRequest.Unmarshal(m, b)
}
func (m *ShowSegmentRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ShowSegmentRequest.Marshal(b, m, deterministic)
}
func (m *ShowSegmentRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ShowSegmentRequest.Merge(m, src)
}
func (m *ShowSegmentRequest) XXX_Size() int {
	return xxx_messageInfo_ShowSegmentRequest.Size(m)
}
func (m *ShowSegmentRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_ShowSegmentRequest.DiscardUnknown(m)
}

var xxx_messageInfo_ShowSegmentRequest proto.InternalMessageInfo

func (m *ShowSegmentRequest) GetBase() *internalpb2.MsgBase {
	if m != nil {
		return m.Base
	}
	return nil
}

func (m *ShowSegmentRequest) GetCollectionID() int64 {
	if m != nil {
		return m.CollectionID
	}
	return 0
}

func (m *ShowSegmentRequest) GetPartitionID() int64 {
	if m != nil {
		return m.PartitionID
	}
	return 0
}

type ShowSegmentResponse struct {
	SegmentIDs           []int64  `protobuf:"varint,1,rep,packed,name=segmentIDs,proto3" json:"segmentIDs,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ShowSegmentResponse) Reset()         { *m = ShowSegmentResponse{} }
func (m *ShowSegmentResponse) String() string { return proto.CompactTextString(m) }
func (*ShowSegmentResponse) ProtoMessage()    {}
func (*ShowSegmentResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_3385cd32ad6cfe64, []int{8}
}

func (m *ShowSegmentResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ShowSegmentResponse.Unmarshal(m, b)
}
func (m *ShowSegmentResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ShowSegmentResponse.Marshal(b, m, deterministic)
}
func (m *ShowSegmentResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ShowSegmentResponse.Merge(m, src)
}
func (m *ShowSegmentResponse) XXX_Size() int {
	return xxx_messageInfo_ShowSegmentResponse.Size(m)
}
func (m *ShowSegmentResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_ShowSegmentResponse.DiscardUnknown(m)
}

var xxx_messageInfo_ShowSegmentResponse proto.InternalMessageInfo

func (m *ShowSegmentResponse) GetSegmentIDs() []int64 {
	if m != nil {
		return m.SegmentIDs
	}
	return nil
}

type SegmentStatesRequest struct {
	Base                 *internalpb2.MsgBase `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"`
	SegmentID            int64                `protobuf:"varint,2,opt,name=segmentID,proto3" json:"segmentID,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

func (m *SegmentStatesRequest) Reset()         { *m = SegmentStatesRequest{} }
func (m *SegmentStatesRequest) String() string { return proto.CompactTextString(m) }
func (*SegmentStatesRequest) ProtoMessage()    {}
func (*SegmentStatesRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_3385cd32ad6cfe64, []int{9}
}

func (m *SegmentStatesRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_SegmentStatesRequest.Unmarshal(m, b)
}
func (m *SegmentStatesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_SegmentStatesRequest.Marshal(b, m, deterministic)
}
func (m *SegmentStatesRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SegmentStatesRequest.Merge(m, src)
}
func (m *SegmentStatesRequest) XXX_Size() int {
	return xxx_messageInfo_SegmentStatesRequest.Size(m)
}
func (m *SegmentStatesRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_SegmentStatesRequest.DiscardUnknown(m)
}

var xxx_messageInfo_SegmentStatesRequest proto.InternalMessageInfo

func (m *SegmentStatesRequest) GetBase() *internalpb2.MsgBase {
	if m != nil {
		return m.Base
	}
	return nil
}

func (m *SegmentStatesRequest) GetSegmentID() int64 {
	if m != nil {
		return m.SegmentID
	}
	return 0
}

type SegmentStatesResponse struct {
	State                SegmentState `protobuf:"varint,1,opt,name=state,proto3,enum=milvus.proto.data.SegmentState" json:"state,omitempty"`
	CreateTime           uint64       `protobuf:"varint,2,opt,name=create_time,json=createTime,proto3" json:"create_time,omitempty"`
	SealedTime           uint64       `protobuf:"varint,3,opt,name=sealed_time,json=sealedTime,proto3" json:"sealed_time,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

func (m *SegmentStatesResponse) Reset()         { *m = SegmentStatesResponse{} }
func (m *SegmentStatesResponse) String() string { return proto.CompactTextString(m) }
func (*SegmentStatesResponse) ProtoMessage()    {}
func (*SegmentStatesResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_3385cd32ad6cfe64, []int{10}
}

func (m *SegmentStatesResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_SegmentStatesResponse.Unmarshal(m, b)
}
func (m *SegmentStatesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_SegmentStatesResponse.Marshal(b, m, deterministic)
}
func (m *SegmentStatesResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SegmentStatesResponse.Merge(m, src)
}
func (m *SegmentStatesResponse) XXX_Size() int {
	return xxx_messageInfo_SegmentStatesResponse.Size(m)
}
func (m *SegmentStatesResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_SegmentStatesResponse.DiscardUnknown(m)
}

var xxx_messageInfo_SegmentStatesResponse proto.InternalMessageInfo

func (m *SegmentStatesResponse) GetState() SegmentState {
	if m != nil {
		return m.State
	}
	return SegmentState_SegmentNone
}

func (m *SegmentStatesResponse) GetCreateTime() uint64 {
	if m != nil {
		return m.CreateTime
	}
	return 0
}

func (m *SegmentStatesResponse) GetSealedTime() uint64 {
	if m != nil {
		return m.SealedTime
	}
	return 0
}

type InsertBinlogPathRequest struct {
	Base                 *internalpb2.MsgBase `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"`
	SegmentID            int64                `protobuf:"varint,2,opt,name=segmentID,proto3" json:"segmentID,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

func (m *InsertBinlogPathRequest) Reset()         { *m = InsertBinlogPathRequest{} }
func (m *InsertBinlogPathRequest) String() string { return proto.CompactTextString(m) }
func (*InsertBinlogPathRequest) ProtoMessage()    {}
func (*InsertBinlogPathRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_3385cd32ad6cfe64, []int{11}
}

func (m *InsertBinlogPathRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_InsertBinlogPathRequest.Unmarshal(m, b)
}
func (m *InsertBinlogPathRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_InsertBinlogPathRequest.Marshal(b, m, deterministic)
}
func (m *InsertBinlogPathRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_InsertBinlogPathRequest.Merge(m, src)
}
func (m *InsertBinlogPathRequest) XXX_Size() int {
	return xxx_messageInfo_InsertBinlogPathRequest.Size(m)
}
func (m *InsertBinlogPathRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_InsertBinlogPathRequest.DiscardUnknown(m)
}

var xxx_messageInfo_InsertBinlogPathRequest proto.InternalMessageInfo

func (m *InsertBinlogPathRequest) GetBase() *internalpb2.MsgBase {
	if m != nil {
		return m.Base
	}
	return nil
}

func (m *InsertBinlogPathRequest) GetSegmentID() int64 {
	if m != nil {
		return m.SegmentID
	}
	return 0
}

type InsertBinlogPathsResponse struct {
	FieldIDs             []int64                   `protobuf:"varint,1,rep,packed,name=fieldIDs,proto3" json:"fieldIDs,omitempty"`
	Paths                []*internalpb2.StringList `protobuf:"bytes,2,rep,name=paths,proto3" json:"paths,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                  `json:"-"`
	XXX_unrecognized     []byte                    `json:"-"`
	XXX_sizecache        int32                     `json:"-"`
}

func (m *InsertBinlogPathsResponse) Reset()         { *m = InsertBinlogPathsResponse{} }
func (m *InsertBinlogPathsResponse) String() string { return proto.CompactTextString(m) }
func (*InsertBinlogPathsResponse) ProtoMessage()    {}
func (*InsertBinlogPathsResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_3385cd32ad6cfe64, []int{12}
}

func (m *InsertBinlogPathsResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_InsertBinlogPathsResponse.Unmarshal(m, b)
}
func (m *InsertBinlogPathsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_InsertBinlogPathsResponse.Marshal(b, m, deterministic)
}
func (m *InsertBinlogPathsResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_InsertBinlogPathsResponse.Merge(m, src)
}
func (m *InsertBinlogPathsResponse) XXX_Size() int {
	return xxx_messageInfo_InsertBinlogPathsResponse.Size(m)
}
func (m *InsertBinlogPathsResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_InsertBinlogPathsResponse.DiscardUnknown(m)
}

var xxx_messageInfo_InsertBinlogPathsResponse proto.InternalMessageInfo

func (m *InsertBinlogPathsResponse) GetFieldIDs() []int64 {
	if m != nil {
		return m.FieldIDs
	}
	return nil
}

func (m *InsertBinlogPathsResponse) GetPaths() []*internalpb2.StringList {
	if m != nil {
		return m.Paths
	}
	return nil
}

type InsertChannelRequest struct {
	Base                 *internalpb2.MsgBase `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"`
	DbID                 int64                `protobuf:"varint,2,opt,name=dbID,proto3" json:"dbID,omitempty"`
	CollectionID         int64                `protobuf:"varint,3,opt,name=collectionID,proto3" json:"collectionID,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

func (m *InsertChannelRequest) Reset()         { *m = InsertChannelRequest{} }
func (m *InsertChannelRequest) String() string { return proto.CompactTextString(m) }
func (*InsertChannelRequest) ProtoMessage()    {}
func (*InsertChannelRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_3385cd32ad6cfe64, []int{13}
}

func (m *InsertChannelRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_InsertChannelRequest.Unmarshal(m, b)
}
func (m *InsertChannelRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_InsertChannelRequest.Marshal(b, m, deterministic)
}
func (m *InsertChannelRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_InsertChannelRequest.Merge(m, src)
}
func (m *InsertChannelRequest) XXX_Size() int {
	return xxx_messageInfo_InsertChannelRequest.Size(m)
}
func (m *InsertChannelRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_InsertChannelRequest.DiscardUnknown(m)
}

var xxx_messageInfo_InsertChannelRequest proto.InternalMessageInfo

func (m *InsertChannelRequest) GetBase() *internalpb2.MsgBase {
	if m != nil {
		return m.Base
	}
	return nil
}

func (m *InsertChannelRequest) GetDbID() int64 {
	if m != nil {
		return m.DbID
	}
	return 0
}

func (m *InsertChannelRequest) GetCollectionID() int64 {
	if m != nil {
		return m.CollectionID
	}
	return 0
}

type WatchDmChannelRequest struct {
	Base                 *internalpb2.MsgBase `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"`
	ChannelIDs           []string             `protobuf:"bytes,2,rep,name=channelIDs,proto3" json:"channelIDs,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

func (m *WatchDmChannelRequest) Reset()         { *m = WatchDmChannelRequest{} }
func (m *WatchDmChannelRequest) String() string { return proto.CompactTextString(m) }
func (*WatchDmChannelRequest) ProtoMessage()    {}
func (*WatchDmChannelRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_3385cd32ad6cfe64, []int{14}
}

func (m *WatchDmChannelRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_WatchDmChannelRequest.Unmarshal(m, b)
}
func (m *WatchDmChannelRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_WatchDmChannelRequest.Marshal(b, m, deterministic)
}
func (m *WatchDmChannelRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_WatchDmChannelRequest.Merge(m, src)
}
func (m *WatchDmChannelRequest) XXX_Size() int {
	return xxx_messageInfo_WatchDmChannelRequest.Size(m)
}
func (m *WatchDmChannelRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_WatchDmChannelRequest.DiscardUnknown(m)
}

var xxx_messageInfo_WatchDmChannelRequest proto.InternalMessageInfo

func (m *WatchDmChannelRequest) GetBase() *internalpb2.MsgBase {
	if m != nil {
		return m.Base
	}
	return nil
}

func (m *WatchDmChannelRequest) GetChannelIDs() []string {
	if m != nil {
		return m.ChannelIDs
	}
	return nil
}

type FlushSegRequest struct {
	Base                 *internalpb2.MsgBase `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"`
	DbID                 int64                `protobuf:"varint,2,opt,name=dbID,proto3" json:"dbID,omitempty"`
	CollectionID         int64                `protobuf:"varint,3,opt,name=collectionID,proto3" json:"collectionID,omitempty"`
	SegmentIDs           []int64              `protobuf:"varint,4,rep,packed,name=segmentIDs,proto3" json:"segmentIDs,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

func (m *FlushSegRequest) Reset()         { *m = FlushSegRequest{} }
func (m *FlushSegRequest) String() string { return proto.CompactTextString(m) }
func (*FlushSegRequest) ProtoMessage()    {}
func (*FlushSegRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_3385cd32ad6cfe64, []int{15}
}

func (m *FlushSegRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_FlushSegRequest.Unmarshal(m, b)
}
func (m *FlushSegRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_FlushSegRequest.Marshal(b, m, deterministic)
}
func (m *FlushSegRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_FlushSegRequest.Merge(m, src)
}
func (m *FlushSegRequest) XXX_Size() int {
	return xxx_messageInfo_FlushSegRequest.Size(m)
}
func (m *FlushSegRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_FlushSegRequest.DiscardUnknown(m)
}

var xxx_messageInfo_FlushSegRequest proto.InternalMessageInfo

func (m *FlushSegRequest) GetBase() *internalpb2.MsgBase {
	if m != nil {
		return m.Base
	}
	return nil
}

func (m *FlushSegRequest) GetDbID() int64 {
	if m != nil {
		return m.DbID
	}
	return 0
}

func (m *FlushSegRequest) GetCollectionID() int64 {
	if m != nil {
		return m.CollectionID
	}
	return 0
}

func (m *FlushSegRequest) GetSegmentIDs() []int64 {
	if m != nil {
		return m.SegmentIDs
	}
	return nil
}

type SegmentInfo struct {
	SegmentID            int64    `protobuf:"varint,1,opt,name=segmentID,proto3" json:"segmentID,omitempty"`
	CollectionID         int64    `protobuf:"varint,2,opt,name=collectionID,proto3" json:"collectionID,omitempty"`
	PartitionID          int64    `protobuf:"varint,3,opt,name=partitionID,proto3" json:"partitionID,omitempty"`
	InsertChannels       []string `protobuf:"bytes,4,rep,name=insert_channels,json=insertChannels,proto3" json:"insert_channels,omitempty"`
	OpenTime             uint64   `protobuf:"varint,5,opt,name=open_time,json=openTime,proto3" json:"open_time,omitempty"`
	CloseTime            uint64   `protobuf:"varint,6,opt,name=close_time,json=closeTime,proto3" json:"close_time,omitempty"`
	NumRows              int64    `protobuf:"varint,7,opt,name=num_rows,json=numRows,proto3" json:"num_rows,omitempty"`
	MemSize              int64    `protobuf:"varint,8,opt,name=mem_size,json=memSize,proto3" json:"mem_size,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *SegmentInfo) Reset()         { *m = SegmentInfo{} }
func (m *SegmentInfo) String() string { return proto.CompactTextString(m) }
func (*SegmentInfo) ProtoMessage()    {}
func (*SegmentInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_3385cd32ad6cfe64, []int{16}
}

func (m *SegmentInfo) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_SegmentInfo.Unmarshal(m, b)
}
func (m *SegmentInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_SegmentInfo.Marshal(b, m, deterministic)
}
func (m *SegmentInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SegmentInfo.Merge(m, src)
}
func (m *SegmentInfo) XXX_Size() int {
	return xxx_messageInfo_SegmentInfo.Size(m)
}
func (m *SegmentInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_SegmentInfo.DiscardUnknown(m)
}

var xxx_messageInfo_SegmentInfo proto.InternalMessageInfo

func (m *SegmentInfo) GetSegmentID() int64 {
	if m != nil {
		return m.SegmentID
	}
	return 0
}

func (m *SegmentInfo) GetCollectionID() int64 {
	if m != nil {
		return m.CollectionID
	}
	return 0
}

func (m *SegmentInfo) GetPartitionID() int64 {
	if m != nil {
		return m.PartitionID
	}
	return 0
}

func (m *SegmentInfo) GetInsertChannels() []string {
	if m != nil {
		return m.InsertChannels
	}
	return nil
}

func (m *SegmentInfo) GetOpenTime() uint64 {
	if m != nil {
		return m.OpenTime
	}
	return 0
}

func (m *SegmentInfo) GetCloseTime() uint64 {
	if m != nil {
		return m.CloseTime
	}
	return 0
}

func (m *SegmentInfo) GetNumRows() int64 {
	if m != nil {
		return m.NumRows
	}
	return 0
}

func (m *SegmentInfo) GetMemSize() int64 {
	if m != nil {
		return m.MemSize
	}
	return 0
}

func init() {
	proto.RegisterEnum("milvus.proto.data.SegmentState", SegmentState_name, SegmentState_value)
	proto.RegisterType((*RegisterNodeRequest)(nil), "milvus.proto.data.RegisterNodeRequest")
	proto.RegisterType((*RegisterNodeResponse)(nil), "milvus.proto.data.RegisterNodeResponse")
	proto.RegisterType((*SegIDRequest)(nil), "milvus.proto.data.SegIDRequest")
	proto.RegisterType((*AssignSegIDRequest)(nil), "milvus.proto.data.AssignSegIDRequest")
	proto.RegisterType((*SegIDAssignment)(nil), "milvus.proto.data.SegIDAssignment")
	proto.RegisterType((*AssignSegIDResponse)(nil), "milvus.proto.data.AssignSegIDResponse")
	proto.RegisterType((*FlushRequest)(nil), "milvus.proto.data.FlushRequest")
	proto.RegisterType((*ShowSegmentRequest)(nil), "milvus.proto.data.ShowSegmentRequest")
	proto.RegisterType((*ShowSegmentResponse)(nil), "milvus.proto.data.ShowSegmentResponse")
	proto.RegisterType((*SegmentStatesRequest)(nil), "milvus.proto.data.SegmentStatesRequest")
	proto.RegisterType((*SegmentStatesResponse)(nil), "milvus.proto.data.SegmentStatesResponse")
	proto.RegisterType((*InsertBinlogPathRequest)(nil), "milvus.proto.data.InsertBinlogPathRequest")
	proto.RegisterType((*InsertBinlogPathsResponse)(nil), "milvus.proto.data.InsertBinlogPathsResponse")
	proto.RegisterType((*InsertChannelRequest)(nil), "milvus.proto.data.InsertChannelRequest")
	proto.RegisterType((*WatchDmChannelRequest)(nil), "milvus.proto.data.WatchDmChannelRequest")
	proto.RegisterType((*FlushSegRequest)(nil), "milvus.proto.data.FlushSegRequest")
	proto.RegisterType((*SegmentInfo)(nil), "milvus.proto.data.SegmentInfo")
}

func init() { proto.RegisterFile("data_service.proto", fileDescriptor_3385cd32ad6cfe64) }

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

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4

// DataServiceClient is the client API for DataService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type DataServiceClient interface {
	RegisterNode(ctx context.Context, in *RegisterNodeRequest, opts ...grpc.CallOption) (*RegisterNodeResponse, error)
	Flush(ctx context.Context, in *FlushRequest, opts ...grpc.CallOption) (*commonpb.Status, error)
	AssignSegmentID(ctx context.Context, in *AssignSegIDRequest, opts ...grpc.CallOption) (*AssignSegIDResponse, error)
	ShowSegments(ctx context.Context, in *ShowSegmentRequest, opts ...grpc.CallOption) (*ShowSegmentResponse, error)
	GetSegmentStates(ctx context.Context, in *SegmentStatesRequest, opts ...grpc.CallOption) (*SegmentStatesResponse, error)
	GetInsertBinlogPaths(ctx context.Context, in *InsertBinlogPathRequest, opts ...grpc.CallOption) (*InsertBinlogPathsResponse, error)
	GetInsertChannels(ctx context.Context, in *InsertChannelRequest, opts ...grpc.CallOption) (*internalpb2.StringList, error)
}

type dataServiceClient struct {
	cc *grpc.ClientConn
}

func NewDataServiceClient(cc *grpc.ClientConn) DataServiceClient {
	return &dataServiceClient{cc}
}

func (c *dataServiceClient) RegisterNode(ctx context.Context, in *RegisterNodeRequest, opts ...grpc.CallOption) (*RegisterNodeResponse, error) {
	out := new(RegisterNodeResponse)
	err := c.cc.Invoke(ctx, "/milvus.proto.data.DataService/RegisterNode", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *dataServiceClient) Flush(ctx context.Context, in *FlushRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
	out := new(commonpb.Status)
	err := c.cc.Invoke(ctx, "/milvus.proto.data.DataService/Flush", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *dataServiceClient) AssignSegmentID(ctx context.Context, in *AssignSegIDRequest, opts ...grpc.CallOption) (*AssignSegIDResponse, error) {
	out := new(AssignSegIDResponse)
	err := c.cc.Invoke(ctx, "/milvus.proto.data.DataService/AssignSegmentID", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *dataServiceClient) ShowSegments(ctx context.Context, in *ShowSegmentRequest, opts ...grpc.CallOption) (*ShowSegmentResponse, error) {
	out := new(ShowSegmentResponse)
	err := c.cc.Invoke(ctx, "/milvus.proto.data.DataService/ShowSegments", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *dataServiceClient) GetSegmentStates(ctx context.Context, in *SegmentStatesRequest, opts ...grpc.CallOption) (*SegmentStatesResponse, error) {
	out := new(SegmentStatesResponse)
	err := c.cc.Invoke(ctx, "/milvus.proto.data.DataService/GetSegmentStates", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *dataServiceClient) GetInsertBinlogPaths(ctx context.Context, in *InsertBinlogPathRequest, opts ...grpc.CallOption) (*InsertBinlogPathsResponse, error) {
	out := new(InsertBinlogPathsResponse)
	err := c.cc.Invoke(ctx, "/milvus.proto.data.DataService/GetInsertBinlogPaths", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *dataServiceClient) GetInsertChannels(ctx context.Context, in *InsertChannelRequest, opts ...grpc.CallOption) (*internalpb2.StringList, error) {
	out := new(internalpb2.StringList)
	err := c.cc.Invoke(ctx, "/milvus.proto.data.DataService/GetInsertChannels", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// DataServiceServer is the server API for DataService service.
type DataServiceServer interface {
	RegisterNode(context.Context, *RegisterNodeRequest) (*RegisterNodeResponse, error)
	Flush(context.Context, *FlushRequest) (*commonpb.Status, error)
	AssignSegmentID(context.Context, *AssignSegIDRequest) (*AssignSegIDResponse, error)
	ShowSegments(context.Context, *ShowSegmentRequest) (*ShowSegmentResponse, error)
	GetSegmentStates(context.Context, *SegmentStatesRequest) (*SegmentStatesResponse, error)
	GetInsertBinlogPaths(context.Context, *InsertBinlogPathRequest) (*InsertBinlogPathsResponse, error)
	GetInsertChannels(context.Context, *InsertChannelRequest) (*internalpb2.StringList, error)
}

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

func (*UnimplementedDataServiceServer) RegisterNode(ctx context.Context, req *RegisterNodeRequest) (*RegisterNodeResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RegisterNode not implemented")
}
func (*UnimplementedDataServiceServer) Flush(ctx context.Context, req *FlushRequest) (*commonpb.Status, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Flush not implemented")
}
func (*UnimplementedDataServiceServer) AssignSegmentID(ctx context.Context, req *AssignSegIDRequest) (*AssignSegIDResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AssignSegmentID not implemented")
}
func (*UnimplementedDataServiceServer) ShowSegments(ctx context.Context, req *ShowSegmentRequest) (*ShowSegmentResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ShowSegments not implemented")
}
func (*UnimplementedDataServiceServer) GetSegmentStates(ctx context.Context, req *SegmentStatesRequest) (*SegmentStatesResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetSegmentStates not implemented")
}
func (*UnimplementedDataServiceServer) GetInsertBinlogPaths(ctx context.Context, req *InsertBinlogPathRequest) (*InsertBinlogPathsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetInsertBinlogPaths not implemented")
}
func (*UnimplementedDataServiceServer) GetInsertChannels(ctx context.Context, req *InsertChannelRequest) (*internalpb2.StringList, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetInsertChannels not implemented")
}

func RegisterDataServiceServer(s *grpc.Server, srv DataServiceServer) {
	s.RegisterService(&_DataService_serviceDesc, srv)
}

func _DataService_RegisterNode_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RegisterNodeRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DataServiceServer).RegisterNode(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/milvus.proto.data.DataService/RegisterNode",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DataServiceServer).RegisterNode(ctx, req.(*RegisterNodeRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _DataService_Flush_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(FlushRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DataServiceServer).Flush(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/milvus.proto.data.DataService/Flush",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DataServiceServer).Flush(ctx, req.(*FlushRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _DataService_AssignSegmentID_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AssignSegIDRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DataServiceServer).AssignSegmentID(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/milvus.proto.data.DataService/AssignSegmentID",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DataServiceServer).AssignSegmentID(ctx, req.(*AssignSegIDRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _DataService_ShowSegments_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ShowSegmentRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DataServiceServer).ShowSegments(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/milvus.proto.data.DataService/ShowSegments",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DataServiceServer).ShowSegments(ctx, req.(*ShowSegmentRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _DataService_GetSegmentStates_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SegmentStatesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DataServiceServer).GetSegmentStates(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/milvus.proto.data.DataService/GetSegmentStates",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DataServiceServer).GetSegmentStates(ctx, req.(*SegmentStatesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _DataService_GetInsertBinlogPaths_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(InsertBinlogPathRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DataServiceServer).GetInsertBinlogPaths(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/milvus.proto.data.DataService/GetInsertBinlogPaths",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DataServiceServer).GetInsertBinlogPaths(ctx, req.(*InsertBinlogPathRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _DataService_GetInsertChannels_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(InsertChannelRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DataServiceServer).GetInsertChannels(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/milvus.proto.data.DataService/GetInsertChannels",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DataServiceServer).GetInsertChannels(ctx, req.(*InsertChannelRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _DataService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "milvus.proto.data.DataService",
	HandlerType: (*DataServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "RegisterNode",
			Handler:    _DataService_RegisterNode_Handler,
		},
		{
			MethodName: "Flush",
			Handler:    _DataService_Flush_Handler,
		},
		{
			MethodName: "AssignSegmentID",
			Handler:    _DataService_AssignSegmentID_Handler,
		},
		{
			MethodName: "ShowSegments",
			Handler:    _DataService_ShowSegments_Handler,
		},
		{
			MethodName: "GetSegmentStates",
			Handler:    _DataService_GetSegmentStates_Handler,
		},
		{
			MethodName: "GetInsertBinlogPaths",
			Handler:    _DataService_GetInsertBinlogPaths_Handler,
		},
		{
			MethodName: "GetInsertChannels",
			Handler:    _DataService_GetInsertChannels_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "data_service.proto",
}