// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: metainfo.proto

package pb

import (
	context "context"
	fmt "fmt"
	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	timestamp "github.com/golang/protobuf/ptypes/timestamp"
	grpc "google.golang.org/grpc"
	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.GoGoProtoPackageIsVersion2 // please upgrade the proto package

type AddressedOrderLimit struct {
	Limit                *OrderLimit2 `protobuf:"bytes,1,opt,name=limit,proto3" json:"limit,omitempty"`
	StorageNodeAddress   *NodeAddress `protobuf:"bytes,2,opt,name=storage_node_address,json=storageNodeAddress,proto3" json:"storage_node_address,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

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

var xxx_messageInfo_AddressedOrderLimit proto.InternalMessageInfo

func (m *AddressedOrderLimit) GetLimit() *OrderLimit2 {
	if m != nil {
		return m.Limit
	}
	return nil
}

func (m *AddressedOrderLimit) GetStorageNodeAddress() *NodeAddress {
	if m != nil {
		return m.StorageNodeAddress
	}
	return nil
}

type SegmentWriteRequest struct {
	Bucket                  []byte               `protobuf:"bytes,1,opt,name=bucket,proto3" json:"bucket,omitempty"`
	Path                    []byte               `protobuf:"bytes,2,opt,name=path,proto3" json:"path,omitempty"`
	Segment                 int64                `protobuf:"varint,3,opt,name=segment,proto3" json:"segment,omitempty"`
	Redundancy              *RedundancyScheme    `protobuf:"bytes,4,opt,name=redundancy,proto3" json:"redundancy,omitempty"`
	MaxEncryptedSegmentSize int64                `protobuf:"varint,5,opt,name=max_encrypted_segment_size,json=maxEncryptedSegmentSize,proto3" json:"max_encrypted_segment_size,omitempty"`
	Expiration              *timestamp.Timestamp `protobuf:"bytes,6,opt,name=expiration,proto3" json:"expiration,omitempty"`
	XXX_NoUnkeyedLiteral    struct{}             `json:"-"`
	XXX_unrecognized        []byte               `json:"-"`
	XXX_sizecache           int32                `json:"-"`
}

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

var xxx_messageInfo_SegmentWriteRequest proto.InternalMessageInfo

func (m *SegmentWriteRequest) GetBucket() []byte {
	if m != nil {
		return m.Bucket
	}
	return nil
}

func (m *SegmentWriteRequest) GetPath() []byte {
	if m != nil {
		return m.Path
	}
	return nil
}

func (m *SegmentWriteRequest) GetSegment() int64 {
	if m != nil {
		return m.Segment
	}
	return 0
}

func (m *SegmentWriteRequest) GetRedundancy() *RedundancyScheme {
	if m != nil {
		return m.Redundancy
	}
	return nil
}

func (m *SegmentWriteRequest) GetMaxEncryptedSegmentSize() int64 {
	if m != nil {
		return m.MaxEncryptedSegmentSize
	}
	return 0
}

func (m *SegmentWriteRequest) GetExpiration() *timestamp.Timestamp {
	if m != nil {
		return m.Expiration
	}
	return nil
}

type SegmentWriteResponse struct {
	AddressedLimits      []*AddressedOrderLimit `protobuf:"bytes,1,rep,name=addressed_limits,json=addressedLimits,proto3" json:"addressed_limits,omitempty"`
	RootPieceId          PieceID                `protobuf:"bytes,2,opt,name=root_piece_id,json=rootPieceId,proto3,customtype=PieceID" json:"root_piece_id"`
	XXX_NoUnkeyedLiteral struct{}               `json:"-"`
	XXX_unrecognized     []byte                 `json:"-"`
	XXX_sizecache        int32                  `json:"-"`
}

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

var xxx_messageInfo_SegmentWriteResponse proto.InternalMessageInfo

func (m *SegmentWriteResponse) GetAddressedLimits() []*AddressedOrderLimit {
	if m != nil {
		return m.AddressedLimits
	}
	return nil
}

type SegmentCommitRequest struct {
	Bucket               []byte         `protobuf:"bytes,1,opt,name=bucket,proto3" json:"bucket,omitempty"`
	Path                 []byte         `protobuf:"bytes,2,opt,name=path,proto3" json:"path,omitempty"`
	Segment              int64          `protobuf:"varint,3,opt,name=segment,proto3" json:"segment,omitempty"`
	Pointer              *Pointer       `protobuf:"bytes,4,opt,name=pointer,proto3" json:"pointer,omitempty"`
	OriginalLimits       []*OrderLimit2 `protobuf:"bytes,5,rep,name=original_limits,json=originalLimits,proto3" json:"original_limits,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

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

var xxx_messageInfo_SegmentCommitRequest proto.InternalMessageInfo

func (m *SegmentCommitRequest) GetBucket() []byte {
	if m != nil {
		return m.Bucket
	}
	return nil
}

func (m *SegmentCommitRequest) GetPath() []byte {
	if m != nil {
		return m.Path
	}
	return nil
}

func (m *SegmentCommitRequest) GetSegment() int64 {
	if m != nil {
		return m.Segment
	}
	return 0
}

func (m *SegmentCommitRequest) GetPointer() *Pointer {
	if m != nil {
		return m.Pointer
	}
	return nil
}

func (m *SegmentCommitRequest) GetOriginalLimits() []*OrderLimit2 {
	if m != nil {
		return m.OriginalLimits
	}
	return nil
}

type SegmentCommitResponse struct {
	Pointer              *Pointer `protobuf:"bytes,1,opt,name=pointer,proto3" json:"pointer,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_SegmentCommitResponse proto.InternalMessageInfo

func (m *SegmentCommitResponse) GetPointer() *Pointer {
	if m != nil {
		return m.Pointer
	}
	return nil
}

type SegmentDownloadRequest struct {
	Bucket               []byte   `protobuf:"bytes,1,opt,name=bucket,proto3" json:"bucket,omitempty"`
	Path                 []byte   `protobuf:"bytes,2,opt,name=path,proto3" json:"path,omitempty"`
	Segment              int64    `protobuf:"varint,3,opt,name=segment,proto3" json:"segment,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_SegmentDownloadRequest proto.InternalMessageInfo

func (m *SegmentDownloadRequest) GetBucket() []byte {
	if m != nil {
		return m.Bucket
	}
	return nil
}

func (m *SegmentDownloadRequest) GetPath() []byte {
	if m != nil {
		return m.Path
	}
	return nil
}

func (m *SegmentDownloadRequest) GetSegment() int64 {
	if m != nil {
		return m.Segment
	}
	return 0
}

type SegmentDownloadResponse struct {
	AddressedLimits      []*AddressedOrderLimit `protobuf:"bytes,1,rep,name=addressed_limits,json=addressedLimits,proto3" json:"addressed_limits,omitempty"`
	Pointer              *Pointer               `protobuf:"bytes,2,opt,name=pointer,proto3" json:"pointer,omitempty"`
	XXX_NoUnkeyedLiteral struct{}               `json:"-"`
	XXX_unrecognized     []byte                 `json:"-"`
	XXX_sizecache        int32                  `json:"-"`
}

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

var xxx_messageInfo_SegmentDownloadResponse proto.InternalMessageInfo

func (m *SegmentDownloadResponse) GetAddressedLimits() []*AddressedOrderLimit {
	if m != nil {
		return m.AddressedLimits
	}
	return nil
}

func (m *SegmentDownloadResponse) GetPointer() *Pointer {
	if m != nil {
		return m.Pointer
	}
	return nil
}

type SegmentInfoRequest struct {
	Bucket               []byte   `protobuf:"bytes,1,opt,name=bucket,proto3" json:"bucket,omitempty"`
	Path                 []byte   `protobuf:"bytes,2,opt,name=path,proto3" json:"path,omitempty"`
	Segment              int64    `protobuf:"varint,3,opt,name=segment,proto3" json:"segment,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_SegmentInfoRequest proto.InternalMessageInfo

func (m *SegmentInfoRequest) GetBucket() []byte {
	if m != nil {
		return m.Bucket
	}
	return nil
}

func (m *SegmentInfoRequest) GetPath() []byte {
	if m != nil {
		return m.Path
	}
	return nil
}

func (m *SegmentInfoRequest) GetSegment() int64 {
	if m != nil {
		return m.Segment
	}
	return 0
}

type SegmentInfoResponse struct {
	Pointer              *Pointer `protobuf:"bytes,2,opt,name=pointer,proto3" json:"pointer,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_SegmentInfoResponse proto.InternalMessageInfo

func (m *SegmentInfoResponse) GetPointer() *Pointer {
	if m != nil {
		return m.Pointer
	}
	return nil
}

type SegmentDeleteRequest struct {
	Bucket               []byte   `protobuf:"bytes,1,opt,name=bucket,proto3" json:"bucket,omitempty"`
	Path                 []byte   `protobuf:"bytes,2,opt,name=path,proto3" json:"path,omitempty"`
	Segment              int64    `protobuf:"varint,3,opt,name=segment,proto3" json:"segment,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_SegmentDeleteRequest proto.InternalMessageInfo

func (m *SegmentDeleteRequest) GetBucket() []byte {
	if m != nil {
		return m.Bucket
	}
	return nil
}

func (m *SegmentDeleteRequest) GetPath() []byte {
	if m != nil {
		return m.Path
	}
	return nil
}

func (m *SegmentDeleteRequest) GetSegment() int64 {
	if m != nil {
		return m.Segment
	}
	return 0
}

type SegmentDeleteResponse struct {
	AddressedLimits      []*AddressedOrderLimit `protobuf:"bytes,1,rep,name=addressed_limits,json=addressedLimits,proto3" json:"addressed_limits,omitempty"`
	XXX_NoUnkeyedLiteral struct{}               `json:"-"`
	XXX_unrecognized     []byte                 `json:"-"`
	XXX_sizecache        int32                  `json:"-"`
}

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

var xxx_messageInfo_SegmentDeleteResponse proto.InternalMessageInfo

func (m *SegmentDeleteResponse) GetAddressedLimits() []*AddressedOrderLimit {
	if m != nil {
		return m.AddressedLimits
	}
	return nil
}

type ListSegmentsRequest struct {
	Bucket               []byte   `protobuf:"bytes,1,opt,name=bucket,proto3" json:"bucket,omitempty"`
	Prefix               []byte   `protobuf:"bytes,2,opt,name=prefix,proto3" json:"prefix,omitempty"`
	StartAfter           []byte   `protobuf:"bytes,3,opt,name=start_after,json=startAfter,proto3" json:"start_after,omitempty"`
	EndBefore            []byte   `protobuf:"bytes,4,opt,name=end_before,json=endBefore,proto3" json:"end_before,omitempty"`
	Recursive            bool     `protobuf:"varint,5,opt,name=recursive,proto3" json:"recursive,omitempty"`
	Limit                int32    `protobuf:"varint,6,opt,name=limit,proto3" json:"limit,omitempty"`
	MetaFlags            uint32   `protobuf:"fixed32,7,opt,name=meta_flags,json=metaFlags,proto3" json:"meta_flags,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_ListSegmentsRequest proto.InternalMessageInfo

func (m *ListSegmentsRequest) GetBucket() []byte {
	if m != nil {
		return m.Bucket
	}
	return nil
}

func (m *ListSegmentsRequest) GetPrefix() []byte {
	if m != nil {
		return m.Prefix
	}
	return nil
}

func (m *ListSegmentsRequest) GetStartAfter() []byte {
	if m != nil {
		return m.StartAfter
	}
	return nil
}

func (m *ListSegmentsRequest) GetEndBefore() []byte {
	if m != nil {
		return m.EndBefore
	}
	return nil
}

func (m *ListSegmentsRequest) GetRecursive() bool {
	if m != nil {
		return m.Recursive
	}
	return false
}

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

func (m *ListSegmentsRequest) GetMetaFlags() uint32 {
	if m != nil {
		return m.MetaFlags
	}
	return 0
}

type ListSegmentsResponse struct {
	Items                []*ListSegmentsResponse_Item `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"`
	More                 bool                         `protobuf:"varint,2,opt,name=more,proto3" json:"more,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                     `json:"-"`
	XXX_unrecognized     []byte                       `json:"-"`
	XXX_sizecache        int32                        `json:"-"`
}

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

var xxx_messageInfo_ListSegmentsResponse proto.InternalMessageInfo

func (m *ListSegmentsResponse) GetItems() []*ListSegmentsResponse_Item {
	if m != nil {
		return m.Items
	}
	return nil
}

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

type ListSegmentsResponse_Item struct {
	Path                 []byte   `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"`
	Pointer              *Pointer `protobuf:"bytes,2,opt,name=pointer,proto3" json:"pointer,omitempty"`
	IsPrefix             bool     `protobuf:"varint,3,opt,name=is_prefix,json=isPrefix,proto3" json:"is_prefix,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_ListSegmentsResponse_Item proto.InternalMessageInfo

func (m *ListSegmentsResponse_Item) GetPath() []byte {
	if m != nil {
		return m.Path
	}
	return nil
}

func (m *ListSegmentsResponse_Item) GetPointer() *Pointer {
	if m != nil {
		return m.Pointer
	}
	return nil
}

func (m *ListSegmentsResponse_Item) GetIsPrefix() bool {
	if m != nil {
		return m.IsPrefix
	}
	return false
}

func init() {
	proto.RegisterType((*AddressedOrderLimit)(nil), "metainfo.AddressedOrderLimit")
	proto.RegisterType((*SegmentWriteRequest)(nil), "metainfo.SegmentWriteRequest")
	proto.RegisterType((*SegmentWriteResponse)(nil), "metainfo.SegmentWriteResponse")
	proto.RegisterType((*SegmentCommitRequest)(nil), "metainfo.SegmentCommitRequest")
	proto.RegisterType((*SegmentCommitResponse)(nil), "metainfo.SegmentCommitResponse")
	proto.RegisterType((*SegmentDownloadRequest)(nil), "metainfo.SegmentDownloadRequest")
	proto.RegisterType((*SegmentDownloadResponse)(nil), "metainfo.SegmentDownloadResponse")
	proto.RegisterType((*SegmentInfoRequest)(nil), "metainfo.SegmentInfoRequest")
	proto.RegisterType((*SegmentInfoResponse)(nil), "metainfo.SegmentInfoResponse")
	proto.RegisterType((*SegmentDeleteRequest)(nil), "metainfo.SegmentDeleteRequest")
	proto.RegisterType((*SegmentDeleteResponse)(nil), "metainfo.SegmentDeleteResponse")
	proto.RegisterType((*ListSegmentsRequest)(nil), "metainfo.ListSegmentsRequest")
	proto.RegisterType((*ListSegmentsResponse)(nil), "metainfo.ListSegmentsResponse")
	proto.RegisterType((*ListSegmentsResponse_Item)(nil), "metainfo.ListSegmentsResponse.Item")
}

func init() { proto.RegisterFile("metainfo.proto", fileDescriptor_631e2f30a93cd64e) }

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

// MetainfoClient is the client API for Metainfo service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type MetainfoClient interface {
	CreateSegment(ctx context.Context, in *SegmentWriteRequest, opts ...grpc.CallOption) (*SegmentWriteResponse, error)
	CommitSegment(ctx context.Context, in *SegmentCommitRequest, opts ...grpc.CallOption) (*SegmentCommitResponse, error)
	SegmentInfo(ctx context.Context, in *SegmentInfoRequest, opts ...grpc.CallOption) (*SegmentInfoResponse, error)
	DownloadSegment(ctx context.Context, in *SegmentDownloadRequest, opts ...grpc.CallOption) (*SegmentDownloadResponse, error)
	DeleteSegment(ctx context.Context, in *SegmentDeleteRequest, opts ...grpc.CallOption) (*SegmentDeleteResponse, error)
	ListSegments(ctx context.Context, in *ListSegmentsRequest, opts ...grpc.CallOption) (*ListSegmentsResponse, error)
}

type metainfoClient struct {
	cc *grpc.ClientConn
}

func NewMetainfoClient(cc *grpc.ClientConn) MetainfoClient {
	return &metainfoClient{cc}
}

func (c *metainfoClient) CreateSegment(ctx context.Context, in *SegmentWriteRequest, opts ...grpc.CallOption) (*SegmentWriteResponse, error) {
	out := new(SegmentWriteResponse)
	err := c.cc.Invoke(ctx, "/metainfo.Metainfo/CreateSegment", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *metainfoClient) CommitSegment(ctx context.Context, in *SegmentCommitRequest, opts ...grpc.CallOption) (*SegmentCommitResponse, error) {
	out := new(SegmentCommitResponse)
	err := c.cc.Invoke(ctx, "/metainfo.Metainfo/CommitSegment", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *metainfoClient) SegmentInfo(ctx context.Context, in *SegmentInfoRequest, opts ...grpc.CallOption) (*SegmentInfoResponse, error) {
	out := new(SegmentInfoResponse)
	err := c.cc.Invoke(ctx, "/metainfo.Metainfo/SegmentInfo", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *metainfoClient) DownloadSegment(ctx context.Context, in *SegmentDownloadRequest, opts ...grpc.CallOption) (*SegmentDownloadResponse, error) {
	out := new(SegmentDownloadResponse)
	err := c.cc.Invoke(ctx, "/metainfo.Metainfo/DownloadSegment", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *metainfoClient) DeleteSegment(ctx context.Context, in *SegmentDeleteRequest, opts ...grpc.CallOption) (*SegmentDeleteResponse, error) {
	out := new(SegmentDeleteResponse)
	err := c.cc.Invoke(ctx, "/metainfo.Metainfo/DeleteSegment", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *metainfoClient) ListSegments(ctx context.Context, in *ListSegmentsRequest, opts ...grpc.CallOption) (*ListSegmentsResponse, error) {
	out := new(ListSegmentsResponse)
	err := c.cc.Invoke(ctx, "/metainfo.Metainfo/ListSegments", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// MetainfoServer is the server API for Metainfo service.
type MetainfoServer interface {
	CreateSegment(context.Context, *SegmentWriteRequest) (*SegmentWriteResponse, error)
	CommitSegment(context.Context, *SegmentCommitRequest) (*SegmentCommitResponse, error)
	SegmentInfo(context.Context, *SegmentInfoRequest) (*SegmentInfoResponse, error)
	DownloadSegment(context.Context, *SegmentDownloadRequest) (*SegmentDownloadResponse, error)
	DeleteSegment(context.Context, *SegmentDeleteRequest) (*SegmentDeleteResponse, error)
	ListSegments(context.Context, *ListSegmentsRequest) (*ListSegmentsResponse, error)
}

func RegisterMetainfoServer(s *grpc.Server, srv MetainfoServer) {
	s.RegisterService(&_Metainfo_serviceDesc, srv)
}

func _Metainfo_CreateSegment_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SegmentWriteRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MetainfoServer).CreateSegment(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/metainfo.Metainfo/CreateSegment",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MetainfoServer).CreateSegment(ctx, req.(*SegmentWriteRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Metainfo_CommitSegment_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SegmentCommitRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MetainfoServer).CommitSegment(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/metainfo.Metainfo/CommitSegment",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MetainfoServer).CommitSegment(ctx, req.(*SegmentCommitRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Metainfo_SegmentInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SegmentInfoRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MetainfoServer).SegmentInfo(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/metainfo.Metainfo/SegmentInfo",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MetainfoServer).SegmentInfo(ctx, req.(*SegmentInfoRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Metainfo_DownloadSegment_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SegmentDownloadRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MetainfoServer).DownloadSegment(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/metainfo.Metainfo/DownloadSegment",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MetainfoServer).DownloadSegment(ctx, req.(*SegmentDownloadRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Metainfo_DeleteSegment_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SegmentDeleteRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MetainfoServer).DeleteSegment(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/metainfo.Metainfo/DeleteSegment",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MetainfoServer).DeleteSegment(ctx, req.(*SegmentDeleteRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Metainfo_ListSegments_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListSegmentsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MetainfoServer).ListSegments(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/metainfo.Metainfo/ListSegments",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MetainfoServer).ListSegments(ctx, req.(*ListSegmentsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _Metainfo_serviceDesc = grpc.ServiceDesc{
	ServiceName: "metainfo.Metainfo",
	HandlerType: (*MetainfoServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "CreateSegment",
			Handler:    _Metainfo_CreateSegment_Handler,
		},
		{
			MethodName: "CommitSegment",
			Handler:    _Metainfo_CommitSegment_Handler,
		},
		{
			MethodName: "SegmentInfo",
			Handler:    _Metainfo_SegmentInfo_Handler,
		},
		{
			MethodName: "DownloadSegment",
			Handler:    _Metainfo_DownloadSegment_Handler,
		},
		{
			MethodName: "DeleteSegment",
			Handler:    _Metainfo_DeleteSegment_Handler,
		},
		{
			MethodName: "ListSegments",
			Handler:    _Metainfo_ListSegments_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "metainfo.proto",
}