// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: pkg/dataobj/compaction/proto/compaction.proto

package proto

import (
	fmt "fmt"
	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	io "io"
	math "math"
	math_bits "math/bits"
	reflect "reflect"
	strings "strings"
)

// 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.GoGoProtoPackageIsVersion3 // please upgrade the proto package

// Stream identifies a single stream from an index.
// It does not include Tenant ID to let us store group of streams for same Tenant without repeating the ID.
type Stream struct {
	ID    int64  `protobuf:"varint,1,opt,name=ID,proto3" json:"id"`
	Index string `protobuf:"bytes,2,opt,name=Index,proto3" json:"index"`
}

func (m *Stream) Reset()      { *m = Stream{} }
func (*Stream) ProtoMessage() {}
func (*Stream) Descriptor() ([]byte, []int) {
	return fileDescriptor_e8066c7cd7ae7d12, []int{0}
}
func (m *Stream) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Stream) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Stream.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Stream) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Stream.Merge(m, src)
}
func (m *Stream) XXX_Size() int {
	return m.Size()
}
func (m *Stream) XXX_DiscardUnknown() {
	xxx_messageInfo_Stream.DiscardUnknown(m)
}

var xxx_messageInfo_Stream proto.InternalMessageInfo

func (m *Stream) GetID() int64 {
	if m != nil {
		return m.ID
	}
	return 0
}

func (m *Stream) GetIndex() string {
	if m != nil {
		return m.Index
	}
	return ""
}

// TenantStream identifies a single stream from an index belonging to a specific Tenant.
type TenantStream struct {
	Tenant string  `protobuf:"bytes,1,opt,name=Tenant,proto3" json:"tenant"`
	Stream *Stream `protobuf:"bytes,2,opt,name=Stream,proto3" json:"stream"`
}

func (m *TenantStream) Reset()      { *m = TenantStream{} }
func (*TenantStream) ProtoMessage() {}
func (*TenantStream) Descriptor() ([]byte, []int) {
	return fileDescriptor_e8066c7cd7ae7d12, []int{1}
}
func (m *TenantStream) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TenantStream) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TenantStream.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *TenantStream) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TenantStream.Merge(m, src)
}
func (m *TenantStream) XXX_Size() int {
	return m.Size()
}
func (m *TenantStream) XXX_DiscardUnknown() {
	xxx_messageInfo_TenantStream.DiscardUnknown(m)
}

var xxx_messageInfo_TenantStream proto.InternalMessageInfo

func (m *TenantStream) GetTenant() string {
	if m != nil {
		return m.Tenant
	}
	return ""
}

func (m *TenantStream) GetStream() *Stream {
	if m != nil {
		return m.Stream
	}
	return nil
}

type TimeRange struct {
	From    int64 `protobuf:"varint,1,opt,name=From,proto3" json:"from"`
	Through int64 `protobuf:"varint,2,opt,name=Through,proto3" json:"through"`
}

func (m *TimeRange) Reset()      { *m = TimeRange{} }
func (*TimeRange) ProtoMessage() {}
func (*TimeRange) Descriptor() ([]byte, []int) {
	return fileDescriptor_e8066c7cd7ae7d12, []int{2}
}
func (m *TimeRange) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TimeRange) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TimeRange.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *TimeRange) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TimeRange.Merge(m, src)
}
func (m *TimeRange) XXX_Size() int {
	return m.Size()
}
func (m *TimeRange) XXX_DiscardUnknown() {
	xxx_messageInfo_TimeRange.DiscardUnknown(m)
}

var xxx_messageInfo_TimeRange proto.InternalMessageInfo

func (m *TimeRange) GetFrom() int64 {
	if m != nil {
		return m.From
	}
	return 0
}

func (m *TimeRange) GetThrough() int64 {
	if m != nil {
		return m.Through
	}
	return 0
}

// SingleTenantObjectSource holds all the required info to build one or more output objects for a single tenant.
// To avoid repetition, common info like time-range and target size of objects are to be referenced from CompactionManifest and added separately where relevant.
type SingleTenantObjectSource struct {
	Streams          []*Stream `protobuf:"bytes,1,rep,name=Streams,proto3" json:"streams"`
	NumOutputObjects int32     `protobuf:"varint,2,opt,name=NumOutputObjects,proto3" json:"num_output_objects"`
}

func (m *SingleTenantObjectSource) Reset()      { *m = SingleTenantObjectSource{} }
func (*SingleTenantObjectSource) ProtoMessage() {}
func (*SingleTenantObjectSource) Descriptor() ([]byte, []int) {
	return fileDescriptor_e8066c7cd7ae7d12, []int{3}
}
func (m *SingleTenantObjectSource) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SingleTenantObjectSource) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_SingleTenantObjectSource.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *SingleTenantObjectSource) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SingleTenantObjectSource.Merge(m, src)
}
func (m *SingleTenantObjectSource) XXX_Size() int {
	return m.Size()
}
func (m *SingleTenantObjectSource) XXX_DiscardUnknown() {
	xxx_messageInfo_SingleTenantObjectSource.DiscardUnknown(m)
}

var xxx_messageInfo_SingleTenantObjectSource proto.InternalMessageInfo

func (m *SingleTenantObjectSource) GetStreams() []*Stream {
	if m != nil {
		return m.Streams
	}
	return nil
}

func (m *SingleTenantObjectSource) GetNumOutputObjects() int32 {
	if m != nil {
		return m.NumOutputObjects
	}
	return 0
}

// MultiTenantObjectSource holds all the required info to build one or more multi-tenant output objects.
// To avoid repetition, common info like time-range and target size of objects are to be referenced from CompactionManifest and added separately where relevant.
type MultiTenantObjectSource struct {
	TenantStreams    []*TenantStream `protobuf:"bytes,1,rep,name=TenantStreams,proto3" json:"tenant_streams"`
	NumOutputObjects int32           `protobuf:"varint,2,opt,name=NumOutputObjects,proto3" json:"num_output_objects"`
}

func (m *MultiTenantObjectSource) Reset()      { *m = MultiTenantObjectSource{} }
func (*MultiTenantObjectSource) ProtoMessage() {}
func (*MultiTenantObjectSource) Descriptor() ([]byte, []int) {
	return fileDescriptor_e8066c7cd7ae7d12, []int{4}
}
func (m *MultiTenantObjectSource) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MultiTenantObjectSource) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MultiTenantObjectSource.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *MultiTenantObjectSource) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MultiTenantObjectSource.Merge(m, src)
}
func (m *MultiTenantObjectSource) XXX_Size() int {
	return m.Size()
}
func (m *MultiTenantObjectSource) XXX_DiscardUnknown() {
	xxx_messageInfo_MultiTenantObjectSource.DiscardUnknown(m)
}

var xxx_messageInfo_MultiTenantObjectSource proto.InternalMessageInfo

func (m *MultiTenantObjectSource) GetTenantStreams() []*TenantStream {
	if m != nil {
		return m.TenantStreams
	}
	return nil
}

func (m *MultiTenantObjectSource) GetNumOutputObjects() int32 {
	if m != nil {
		return m.NumOutputObjects
	}
	return 0
}

// CompactionManifest represents the completion of compaction planning stage and summarizes the compaction plan.
// It serves two purposes:
// 1. Acts as a marker indicating all the relevant data has been scanned for building a compaction plan
// 2. Stores a summary of data being compacted:
//   - Time Range of compaction window
//   - Configured target size while planning the compaction
//   - List of source indexes considered for planning the compaction
type CompactionManifest struct {
	TimeRange       *TimeRange `protobuf:"bytes,1,opt,name=TimeRange,proto3" json:"time_range"`
	TargetSizeBytes int64      `protobuf:"varint,2,opt,name=TargetSizeBytes,proto3" json:"target_size_bytes"`
	SourceIndexes   []string   `protobuf:"bytes,3,rep,name=SourceIndexes,proto3" json:"source_indexes"`
}

func (m *CompactionManifest) Reset()      { *m = CompactionManifest{} }
func (*CompactionManifest) ProtoMessage() {}
func (*CompactionManifest) Descriptor() ([]byte, []int) {
	return fileDescriptor_e8066c7cd7ae7d12, []int{5}
}
func (m *CompactionManifest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CompactionManifest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CompactionManifest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *CompactionManifest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CompactionManifest.Merge(m, src)
}
func (m *CompactionManifest) XXX_Size() int {
	return m.Size()
}
func (m *CompactionManifest) XXX_DiscardUnknown() {
	xxx_messageInfo_CompactionManifest.DiscardUnknown(m)
}

var xxx_messageInfo_CompactionManifest proto.InternalMessageInfo

func (m *CompactionManifest) GetTimeRange() *TimeRange {
	if m != nil {
		return m.TimeRange
	}
	return nil
}

func (m *CompactionManifest) GetTargetSizeBytes() int64 {
	if m != nil {
		return m.TargetSizeBytes
	}
	return 0
}

func (m *CompactionManifest) GetSourceIndexes() []string {
	if m != nil {
		return m.SourceIndexes
	}
	return nil
}

type SingleTenantObjectSourceWithTenantID struct {
	Tenant string                    `protobuf:"bytes,1,opt,name=Tenant,proto3" json:"tenant"`
	Source *SingleTenantObjectSource `protobuf:"bytes,2,opt,name=Source,proto3" json:"source"`
}

func (m *SingleTenantObjectSourceWithTenantID) Reset()      { *m = SingleTenantObjectSourceWithTenantID{} }
func (*SingleTenantObjectSourceWithTenantID) ProtoMessage() {}
func (*SingleTenantObjectSourceWithTenantID) Descriptor() ([]byte, []int) {
	return fileDescriptor_e8066c7cd7ae7d12, []int{6}
}
func (m *SingleTenantObjectSourceWithTenantID) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SingleTenantObjectSourceWithTenantID) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_SingleTenantObjectSourceWithTenantID.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *SingleTenantObjectSourceWithTenantID) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SingleTenantObjectSourceWithTenantID.Merge(m, src)
}
func (m *SingleTenantObjectSourceWithTenantID) XXX_Size() int {
	return m.Size()
}
func (m *SingleTenantObjectSourceWithTenantID) XXX_DiscardUnknown() {
	xxx_messageInfo_SingleTenantObjectSourceWithTenantID.DiscardUnknown(m)
}

var xxx_messageInfo_SingleTenantObjectSourceWithTenantID proto.InternalMessageInfo

func (m *SingleTenantObjectSourceWithTenantID) GetTenant() string {
	if m != nil {
		return m.Tenant
	}
	return ""
}

func (m *SingleTenantObjectSourceWithTenantID) GetSource() *SingleTenantObjectSource {
	if m != nil {
		return m.Source
	}
	return nil
}

// CompactionJob defines a single compaction job to build one or more DataObjects using the data defined in Source.
type CompactionJob struct {
	// Source either defines a single-tenant source to build single-tenant object(s) or read multi-tenant source to build multi-tenant object(s).
	//
	// Types that are valid to be assigned to Source:
	//
	//	*CompactionJob_SingleTenant
	//	*CompactionJob_MultiTenant
	Source          isCompactionJob_Source `protobuf_oneof:"Source"`
	TargetSizeBytes int64                  `protobuf:"varint,3,opt,name=TargetSizeBytes,proto3" json:"target_size_bytes"`
	// ReadRange defines time-range of logs to read from source for building new objects.
	// It could have either From or Through set to 0 to signify no boundaries on either end.
	ReadRange *TimeRange `protobuf:"bytes,4,opt,name=ReadRange,proto3" json:"read_range"`
}

func (m *CompactionJob) Reset()      { *m = CompactionJob{} }
func (*CompactionJob) ProtoMessage() {}
func (*CompactionJob) Descriptor() ([]byte, []int) {
	return fileDescriptor_e8066c7cd7ae7d12, []int{7}
}
func (m *CompactionJob) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CompactionJob) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CompactionJob.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *CompactionJob) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CompactionJob.Merge(m, src)
}
func (m *CompactionJob) XXX_Size() int {
	return m.Size()
}
func (m *CompactionJob) XXX_DiscardUnknown() {
	xxx_messageInfo_CompactionJob.DiscardUnknown(m)
}

var xxx_messageInfo_CompactionJob proto.InternalMessageInfo

type isCompactionJob_Source interface {
	isCompactionJob_Source()
	Equal(interface{}) bool
	MarshalTo([]byte) (int, error)
	Size() int
}

type CompactionJob_SingleTenant struct {
	SingleTenant *SingleTenantObjectSourceWithTenantID `protobuf:"bytes,1,opt,name=SingleTenant,proto3,oneof"`
}
type CompactionJob_MultiTenant struct {
	MultiTenant *MultiTenantObjectSource `protobuf:"bytes,2,opt,name=MultiTenant,proto3,oneof"`
}

func (*CompactionJob_SingleTenant) isCompactionJob_Source() {}
func (*CompactionJob_MultiTenant) isCompactionJob_Source()  {}

func (m *CompactionJob) GetSource() isCompactionJob_Source {
	if m != nil {
		return m.Source
	}
	return nil
}

func (m *CompactionJob) GetSingleTenant() *SingleTenantObjectSourceWithTenantID {
	if x, ok := m.GetSource().(*CompactionJob_SingleTenant); ok {
		return x.SingleTenant
	}
	return nil
}

func (m *CompactionJob) GetMultiTenant() *MultiTenantObjectSource {
	if x, ok := m.GetSource().(*CompactionJob_MultiTenant); ok {
		return x.MultiTenant
	}
	return nil
}

func (m *CompactionJob) GetTargetSizeBytes() int64 {
	if m != nil {
		return m.TargetSizeBytes
	}
	return 0
}

func (m *CompactionJob) GetReadRange() *TimeRange {
	if m != nil {
		return m.ReadRange
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*CompactionJob) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*CompactionJob_SingleTenant)(nil),
		(*CompactionJob_MultiTenant)(nil),
	}
}

type CompactionJobResponse struct {
	Paths []string `protobuf:"bytes,1,rep,name=Paths,proto3" json:"paths"`
}

func (m *CompactionJobResponse) Reset()      { *m = CompactionJobResponse{} }
func (*CompactionJobResponse) ProtoMessage() {}
func (*CompactionJobResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_e8066c7cd7ae7d12, []int{8}
}
func (m *CompactionJobResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CompactionJobResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CompactionJobResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *CompactionJobResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CompactionJobResponse.Merge(m, src)
}
func (m *CompactionJobResponse) XXX_Size() int {
	return m.Size()
}
func (m *CompactionJobResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_CompactionJobResponse.DiscardUnknown(m)
}

var xxx_messageInfo_CompactionJobResponse proto.InternalMessageInfo

func (m *CompactionJobResponse) GetPaths() []string {
	if m != nil {
		return m.Paths
	}
	return nil
}

type IndexingJob struct {
	Paths []string `protobuf:"bytes,1,rep,name=Paths,proto3" json:"paths"`
}

func (m *IndexingJob) Reset()      { *m = IndexingJob{} }
func (*IndexingJob) ProtoMessage() {}
func (*IndexingJob) Descriptor() ([]byte, []int) {
	return fileDescriptor_e8066c7cd7ae7d12, []int{9}
}
func (m *IndexingJob) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *IndexingJob) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_IndexingJob.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *IndexingJob) XXX_Merge(src proto.Message) {
	xxx_messageInfo_IndexingJob.Merge(m, src)
}
func (m *IndexingJob) XXX_Size() int {
	return m.Size()
}
func (m *IndexingJob) XXX_DiscardUnknown() {
	xxx_messageInfo_IndexingJob.DiscardUnknown(m)
}

var xxx_messageInfo_IndexingJob proto.InternalMessageInfo

func (m *IndexingJob) GetPaths() []string {
	if m != nil {
		return m.Paths
	}
	return nil
}

type IndexInfo struct {
	Tenant    string     `protobuf:"bytes,1,opt,name=Tenant,proto3" json:"tenant"`
	Path      string     `protobuf:"bytes,2,opt,name=Path,proto3" json:"path"`
	TimeRange *TimeRange `protobuf:"bytes,3,opt,name=TimeRange,proto3" json:"time_range"`
}

func (m *IndexInfo) Reset()      { *m = IndexInfo{} }
func (*IndexInfo) ProtoMessage() {}
func (*IndexInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_e8066c7cd7ae7d12, []int{10}
}
func (m *IndexInfo) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *IndexInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_IndexInfo.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *IndexInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_IndexInfo.Merge(m, src)
}
func (m *IndexInfo) XXX_Size() int {
	return m.Size()
}
func (m *IndexInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_IndexInfo.DiscardUnknown(m)
}

var xxx_messageInfo_IndexInfo proto.InternalMessageInfo

func (m *IndexInfo) GetTenant() string {
	if m != nil {
		return m.Tenant
	}
	return ""
}

func (m *IndexInfo) GetPath() string {
	if m != nil {
		return m.Path
	}
	return ""
}

func (m *IndexInfo) GetTimeRange() *TimeRange {
	if m != nil {
		return m.TimeRange
	}
	return nil
}

type IndexingJobResponse struct {
	Indexes []*IndexInfo `protobuf:"bytes,1,rep,name=Indexes,proto3" json:"indexes"`
}

func (m *IndexingJobResponse) Reset()      { *m = IndexingJobResponse{} }
func (*IndexingJobResponse) ProtoMessage() {}
func (*IndexingJobResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_e8066c7cd7ae7d12, []int{11}
}
func (m *IndexingJobResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *IndexingJobResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_IndexingJobResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *IndexingJobResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_IndexingJobResponse.Merge(m, src)
}
func (m *IndexingJobResponse) XXX_Size() int {
	return m.Size()
}
func (m *IndexingJobResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_IndexingJobResponse.DiscardUnknown(m)
}

var xxx_messageInfo_IndexingJobResponse proto.InternalMessageInfo

func (m *IndexingJobResponse) GetIndexes() []*IndexInfo {
	if m != nil {
		return m.Indexes
	}
	return nil
}

func init() {
	proto.RegisterType((*Stream)(nil), "proto.Stream")
	proto.RegisterType((*TenantStream)(nil), "proto.TenantStream")
	proto.RegisterType((*TimeRange)(nil), "proto.TimeRange")
	proto.RegisterType((*SingleTenantObjectSource)(nil), "proto.SingleTenantObjectSource")
	proto.RegisterType((*MultiTenantObjectSource)(nil), "proto.MultiTenantObjectSource")
	proto.RegisterType((*CompactionManifest)(nil), "proto.CompactionManifest")
	proto.RegisterType((*SingleTenantObjectSourceWithTenantID)(nil), "proto.SingleTenantObjectSourceWithTenantID")
	proto.RegisterType((*CompactionJob)(nil), "proto.CompactionJob")
	proto.RegisterType((*CompactionJobResponse)(nil), "proto.CompactionJobResponse")
	proto.RegisterType((*IndexingJob)(nil), "proto.IndexingJob")
	proto.RegisterType((*IndexInfo)(nil), "proto.IndexInfo")
	proto.RegisterType((*IndexingJobResponse)(nil), "proto.IndexingJobResponse")
}

func init() {
	proto.RegisterFile("pkg/dataobj/compaction/proto/compaction.proto", fileDescriptor_e8066c7cd7ae7d12)
}

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

func (this *Stream) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Stream)
	if !ok {
		that2, ok := that.(Stream)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.ID != that1.ID {
		return false
	}
	if this.Index != that1.Index {
		return false
	}
	return true
}
func (this *TenantStream) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*TenantStream)
	if !ok {
		that2, ok := that.(TenantStream)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Tenant != that1.Tenant {
		return false
	}
	if !this.Stream.Equal(that1.Stream) {
		return false
	}
	return true
}
func (this *TimeRange) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*TimeRange)
	if !ok {
		that2, ok := that.(TimeRange)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.From != that1.From {
		return false
	}
	if this.Through != that1.Through {
		return false
	}
	return true
}
func (this *SingleTenantObjectSource) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*SingleTenantObjectSource)
	if !ok {
		that2, ok := that.(SingleTenantObjectSource)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.Streams) != len(that1.Streams) {
		return false
	}
	for i := range this.Streams {
		if !this.Streams[i].Equal(that1.Streams[i]) {
			return false
		}
	}
	if this.NumOutputObjects != that1.NumOutputObjects {
		return false
	}
	return true
}
func (this *MultiTenantObjectSource) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*MultiTenantObjectSource)
	if !ok {
		that2, ok := that.(MultiTenantObjectSource)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.TenantStreams) != len(that1.TenantStreams) {
		return false
	}
	for i := range this.TenantStreams {
		if !this.TenantStreams[i].Equal(that1.TenantStreams[i]) {
			return false
		}
	}
	if this.NumOutputObjects != that1.NumOutputObjects {
		return false
	}
	return true
}
func (this *CompactionManifest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*CompactionManifest)
	if !ok {
		that2, ok := that.(CompactionManifest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.TimeRange.Equal(that1.TimeRange) {
		return false
	}
	if this.TargetSizeBytes != that1.TargetSizeBytes {
		return false
	}
	if len(this.SourceIndexes) != len(that1.SourceIndexes) {
		return false
	}
	for i := range this.SourceIndexes {
		if this.SourceIndexes[i] != that1.SourceIndexes[i] {
			return false
		}
	}
	return true
}
func (this *SingleTenantObjectSourceWithTenantID) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*SingleTenantObjectSourceWithTenantID)
	if !ok {
		that2, ok := that.(SingleTenantObjectSourceWithTenantID)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Tenant != that1.Tenant {
		return false
	}
	if !this.Source.Equal(that1.Source) {
		return false
	}
	return true
}
func (this *CompactionJob) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*CompactionJob)
	if !ok {
		that2, ok := that.(CompactionJob)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if that1.Source == nil {
		if this.Source != nil {
			return false
		}
	} else if this.Source == nil {
		return false
	} else if !this.Source.Equal(that1.Source) {
		return false
	}
	if this.TargetSizeBytes != that1.TargetSizeBytes {
		return false
	}
	if !this.ReadRange.Equal(that1.ReadRange) {
		return false
	}
	return true
}
func (this *CompactionJob_SingleTenant) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*CompactionJob_SingleTenant)
	if !ok {
		that2, ok := that.(CompactionJob_SingleTenant)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.SingleTenant.Equal(that1.SingleTenant) {
		return false
	}
	return true
}
func (this *CompactionJob_MultiTenant) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*CompactionJob_MultiTenant)
	if !ok {
		that2, ok := that.(CompactionJob_MultiTenant)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.MultiTenant.Equal(that1.MultiTenant) {
		return false
	}
	return true
}
func (this *CompactionJobResponse) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*CompactionJobResponse)
	if !ok {
		that2, ok := that.(CompactionJobResponse)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.Paths) != len(that1.Paths) {
		return false
	}
	for i := range this.Paths {
		if this.Paths[i] != that1.Paths[i] {
			return false
		}
	}
	return true
}
func (this *IndexingJob) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*IndexingJob)
	if !ok {
		that2, ok := that.(IndexingJob)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.Paths) != len(that1.Paths) {
		return false
	}
	for i := range this.Paths {
		if this.Paths[i] != that1.Paths[i] {
			return false
		}
	}
	return true
}
func (this *IndexInfo) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*IndexInfo)
	if !ok {
		that2, ok := that.(IndexInfo)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Tenant != that1.Tenant {
		return false
	}
	if this.Path != that1.Path {
		return false
	}
	if !this.TimeRange.Equal(that1.TimeRange) {
		return false
	}
	return true
}
func (this *IndexingJobResponse) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*IndexingJobResponse)
	if !ok {
		that2, ok := that.(IndexingJobResponse)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.Indexes) != len(that1.Indexes) {
		return false
	}
	for i := range this.Indexes {
		if !this.Indexes[i].Equal(that1.Indexes[i]) {
			return false
		}
	}
	return true
}
func (this *Stream) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&proto.Stream{")
	s = append(s, "ID: "+fmt.Sprintf("%#v", this.ID)+",\n")
	s = append(s, "Index: "+fmt.Sprintf("%#v", this.Index)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *TenantStream) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&proto.TenantStream{")
	s = append(s, "Tenant: "+fmt.Sprintf("%#v", this.Tenant)+",\n")
	if this.Stream != nil {
		s = append(s, "Stream: "+fmt.Sprintf("%#v", this.Stream)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *TimeRange) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&proto.TimeRange{")
	s = append(s, "From: "+fmt.Sprintf("%#v", this.From)+",\n")
	s = append(s, "Through: "+fmt.Sprintf("%#v", this.Through)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *SingleTenantObjectSource) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&proto.SingleTenantObjectSource{")
	if this.Streams != nil {
		s = append(s, "Streams: "+fmt.Sprintf("%#v", this.Streams)+",\n")
	}
	s = append(s, "NumOutputObjects: "+fmt.Sprintf("%#v", this.NumOutputObjects)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *MultiTenantObjectSource) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&proto.MultiTenantObjectSource{")
	if this.TenantStreams != nil {
		s = append(s, "TenantStreams: "+fmt.Sprintf("%#v", this.TenantStreams)+",\n")
	}
	s = append(s, "NumOutputObjects: "+fmt.Sprintf("%#v", this.NumOutputObjects)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *CompactionManifest) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&proto.CompactionManifest{")
	if this.TimeRange != nil {
		s = append(s, "TimeRange: "+fmt.Sprintf("%#v", this.TimeRange)+",\n")
	}
	s = append(s, "TargetSizeBytes: "+fmt.Sprintf("%#v", this.TargetSizeBytes)+",\n")
	s = append(s, "SourceIndexes: "+fmt.Sprintf("%#v", this.SourceIndexes)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *SingleTenantObjectSourceWithTenantID) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&proto.SingleTenantObjectSourceWithTenantID{")
	s = append(s, "Tenant: "+fmt.Sprintf("%#v", this.Tenant)+",\n")
	if this.Source != nil {
		s = append(s, "Source: "+fmt.Sprintf("%#v", this.Source)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *CompactionJob) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 8)
	s = append(s, "&proto.CompactionJob{")
	if this.Source != nil {
		s = append(s, "Source: "+fmt.Sprintf("%#v", this.Source)+",\n")
	}
	s = append(s, "TargetSizeBytes: "+fmt.Sprintf("%#v", this.TargetSizeBytes)+",\n")
	if this.ReadRange != nil {
		s = append(s, "ReadRange: "+fmt.Sprintf("%#v", this.ReadRange)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *CompactionJob_SingleTenant) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&proto.CompactionJob_SingleTenant{` +
		`SingleTenant:` + fmt.Sprintf("%#v", this.SingleTenant) + `}`}, ", ")
	return s
}
func (this *CompactionJob_MultiTenant) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&proto.CompactionJob_MultiTenant{` +
		`MultiTenant:` + fmt.Sprintf("%#v", this.MultiTenant) + `}`}, ", ")
	return s
}
func (this *CompactionJobResponse) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&proto.CompactionJobResponse{")
	s = append(s, "Paths: "+fmt.Sprintf("%#v", this.Paths)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *IndexingJob) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&proto.IndexingJob{")
	s = append(s, "Paths: "+fmt.Sprintf("%#v", this.Paths)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *IndexInfo) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&proto.IndexInfo{")
	s = append(s, "Tenant: "+fmt.Sprintf("%#v", this.Tenant)+",\n")
	s = append(s, "Path: "+fmt.Sprintf("%#v", this.Path)+",\n")
	if this.TimeRange != nil {
		s = append(s, "TimeRange: "+fmt.Sprintf("%#v", this.TimeRange)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *IndexingJobResponse) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&proto.IndexingJobResponse{")
	if this.Indexes != nil {
		s = append(s, "Indexes: "+fmt.Sprintf("%#v", this.Indexes)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func valueToGoStringCompaction(v interface{}, typ string) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv)
}
func (m *Stream) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Stream) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Stream) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Index) > 0 {
		i -= len(m.Index)
		copy(dAtA[i:], m.Index)
		i = encodeVarintCompaction(dAtA, i, uint64(len(m.Index)))
		i--
		dAtA[i] = 0x12
	}
	if m.ID != 0 {
		i = encodeVarintCompaction(dAtA, i, uint64(m.ID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *TenantStream) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *TenantStream) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *TenantStream) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Stream != nil {
		{
			size, err := m.Stream.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCompaction(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.Tenant) > 0 {
		i -= len(m.Tenant)
		copy(dAtA[i:], m.Tenant)
		i = encodeVarintCompaction(dAtA, i, uint64(len(m.Tenant)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *TimeRange) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *TimeRange) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *TimeRange) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Through != 0 {
		i = encodeVarintCompaction(dAtA, i, uint64(m.Through))
		i--
		dAtA[i] = 0x10
	}
	if m.From != 0 {
		i = encodeVarintCompaction(dAtA, i, uint64(m.From))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *SingleTenantObjectSource) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *SingleTenantObjectSource) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *SingleTenantObjectSource) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.NumOutputObjects != 0 {
		i = encodeVarintCompaction(dAtA, i, uint64(m.NumOutputObjects))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Streams) > 0 {
		for iNdEx := len(m.Streams) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Streams[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintCompaction(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *MultiTenantObjectSource) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *MultiTenantObjectSource) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MultiTenantObjectSource) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.NumOutputObjects != 0 {
		i = encodeVarintCompaction(dAtA, i, uint64(m.NumOutputObjects))
		i--
		dAtA[i] = 0x10
	}
	if len(m.TenantStreams) > 0 {
		for iNdEx := len(m.TenantStreams) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.TenantStreams[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintCompaction(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *CompactionManifest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *CompactionManifest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CompactionManifest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.SourceIndexes) > 0 {
		for iNdEx := len(m.SourceIndexes) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.SourceIndexes[iNdEx])
			copy(dAtA[i:], m.SourceIndexes[iNdEx])
			i = encodeVarintCompaction(dAtA, i, uint64(len(m.SourceIndexes[iNdEx])))
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.TargetSizeBytes != 0 {
		i = encodeVarintCompaction(dAtA, i, uint64(m.TargetSizeBytes))
		i--
		dAtA[i] = 0x10
	}
	if m.TimeRange != nil {
		{
			size, err := m.TimeRange.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCompaction(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *SingleTenantObjectSourceWithTenantID) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *SingleTenantObjectSourceWithTenantID) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *SingleTenantObjectSourceWithTenantID) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Source != nil {
		{
			size, err := m.Source.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCompaction(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.Tenant) > 0 {
		i -= len(m.Tenant)
		copy(dAtA[i:], m.Tenant)
		i = encodeVarintCompaction(dAtA, i, uint64(len(m.Tenant)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *CompactionJob) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *CompactionJob) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CompactionJob) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ReadRange != nil {
		{
			size, err := m.ReadRange.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCompaction(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.TargetSizeBytes != 0 {
		i = encodeVarintCompaction(dAtA, i, uint64(m.TargetSizeBytes))
		i--
		dAtA[i] = 0x18
	}
	if m.Source != nil {
		{
			size := m.Source.Size()
			i -= size
			if _, err := m.Source.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	return len(dAtA) - i, nil
}

func (m *CompactionJob_SingleTenant) MarshalTo(dAtA []byte) (int, error) {
	return m.MarshalToSizedBuffer(dAtA[:m.Size()])
}

func (m *CompactionJob_SingleTenant) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.SingleTenant != nil {
		{
			size, err := m.SingleTenant.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCompaction(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}
func (m *CompactionJob_MultiTenant) MarshalTo(dAtA []byte) (int, error) {
	return m.MarshalToSizedBuffer(dAtA[:m.Size()])
}

func (m *CompactionJob_MultiTenant) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.MultiTenant != nil {
		{
			size, err := m.MultiTenant.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCompaction(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	return len(dAtA) - i, nil
}
func (m *CompactionJobResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *CompactionJobResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CompactionJobResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Paths) > 0 {
		for iNdEx := len(m.Paths) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Paths[iNdEx])
			copy(dAtA[i:], m.Paths[iNdEx])
			i = encodeVarintCompaction(dAtA, i, uint64(len(m.Paths[iNdEx])))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *IndexingJob) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *IndexingJob) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *IndexingJob) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Paths) > 0 {
		for iNdEx := len(m.Paths) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Paths[iNdEx])
			copy(dAtA[i:], m.Paths[iNdEx])
			i = encodeVarintCompaction(dAtA, i, uint64(len(m.Paths[iNdEx])))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *IndexInfo) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *IndexInfo) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *IndexInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.TimeRange != nil {
		{
			size, err := m.TimeRange.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCompaction(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Path) > 0 {
		i -= len(m.Path)
		copy(dAtA[i:], m.Path)
		i = encodeVarintCompaction(dAtA, i, uint64(len(m.Path)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Tenant) > 0 {
		i -= len(m.Tenant)
		copy(dAtA[i:], m.Tenant)
		i = encodeVarintCompaction(dAtA, i, uint64(len(m.Tenant)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *IndexingJobResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *IndexingJobResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *IndexingJobResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Indexes) > 0 {
		for iNdEx := len(m.Indexes) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Indexes[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintCompaction(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func encodeVarintCompaction(dAtA []byte, offset int, v uint64) int {
	offset -= sovCompaction(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *Stream) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ID != 0 {
		n += 1 + sovCompaction(uint64(m.ID))
	}
	l = len(m.Index)
	if l > 0 {
		n += 1 + l + sovCompaction(uint64(l))
	}
	return n
}

func (m *TenantStream) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Tenant)
	if l > 0 {
		n += 1 + l + sovCompaction(uint64(l))
	}
	if m.Stream != nil {
		l = m.Stream.Size()
		n += 1 + l + sovCompaction(uint64(l))
	}
	return n
}

func (m *TimeRange) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.From != 0 {
		n += 1 + sovCompaction(uint64(m.From))
	}
	if m.Through != 0 {
		n += 1 + sovCompaction(uint64(m.Through))
	}
	return n
}

func (m *SingleTenantObjectSource) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Streams) > 0 {
		for _, e := range m.Streams {
			l = e.Size()
			n += 1 + l + sovCompaction(uint64(l))
		}
	}
	if m.NumOutputObjects != 0 {
		n += 1 + sovCompaction(uint64(m.NumOutputObjects))
	}
	return n
}

func (m *MultiTenantObjectSource) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.TenantStreams) > 0 {
		for _, e := range m.TenantStreams {
			l = e.Size()
			n += 1 + l + sovCompaction(uint64(l))
		}
	}
	if m.NumOutputObjects != 0 {
		n += 1 + sovCompaction(uint64(m.NumOutputObjects))
	}
	return n
}

func (m *CompactionManifest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TimeRange != nil {
		l = m.TimeRange.Size()
		n += 1 + l + sovCompaction(uint64(l))
	}
	if m.TargetSizeBytes != 0 {
		n += 1 + sovCompaction(uint64(m.TargetSizeBytes))
	}
	if len(m.SourceIndexes) > 0 {
		for _, s := range m.SourceIndexes {
			l = len(s)
			n += 1 + l + sovCompaction(uint64(l))
		}
	}
	return n
}

func (m *SingleTenantObjectSourceWithTenantID) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Tenant)
	if l > 0 {
		n += 1 + l + sovCompaction(uint64(l))
	}
	if m.Source != nil {
		l = m.Source.Size()
		n += 1 + l + sovCompaction(uint64(l))
	}
	return n
}

func (m *CompactionJob) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Source != nil {
		n += m.Source.Size()
	}
	if m.TargetSizeBytes != 0 {
		n += 1 + sovCompaction(uint64(m.TargetSizeBytes))
	}
	if m.ReadRange != nil {
		l = m.ReadRange.Size()
		n += 1 + l + sovCompaction(uint64(l))
	}
	return n
}

func (m *CompactionJob_SingleTenant) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.SingleTenant != nil {
		l = m.SingleTenant.Size()
		n += 1 + l + sovCompaction(uint64(l))
	}
	return n
}
func (m *CompactionJob_MultiTenant) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.MultiTenant != nil {
		l = m.MultiTenant.Size()
		n += 1 + l + sovCompaction(uint64(l))
	}
	return n
}
func (m *CompactionJobResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Paths) > 0 {
		for _, s := range m.Paths {
			l = len(s)
			n += 1 + l + sovCompaction(uint64(l))
		}
	}
	return n
}

func (m *IndexingJob) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Paths) > 0 {
		for _, s := range m.Paths {
			l = len(s)
			n += 1 + l + sovCompaction(uint64(l))
		}
	}
	return n
}

func (m *IndexInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Tenant)
	if l > 0 {
		n += 1 + l + sovCompaction(uint64(l))
	}
	l = len(m.Path)
	if l > 0 {
		n += 1 + l + sovCompaction(uint64(l))
	}
	if m.TimeRange != nil {
		l = m.TimeRange.Size()
		n += 1 + l + sovCompaction(uint64(l))
	}
	return n
}

func (m *IndexingJobResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Indexes) > 0 {
		for _, e := range m.Indexes {
			l = e.Size()
			n += 1 + l + sovCompaction(uint64(l))
		}
	}
	return n
}

func sovCompaction(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozCompaction(x uint64) (n int) {
	return sovCompaction(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (this *Stream) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Stream{`,
		`ID:` + fmt.Sprintf("%v", this.ID) + `,`,
		`Index:` + fmt.Sprintf("%v", this.Index) + `,`,
		`}`,
	}, "")
	return s
}
func (this *TenantStream) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&TenantStream{`,
		`Tenant:` + fmt.Sprintf("%v", this.Tenant) + `,`,
		`Stream:` + strings.Replace(this.Stream.String(), "Stream", "Stream", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *TimeRange) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&TimeRange{`,
		`From:` + fmt.Sprintf("%v", this.From) + `,`,
		`Through:` + fmt.Sprintf("%v", this.Through) + `,`,
		`}`,
	}, "")
	return s
}
func (this *SingleTenantObjectSource) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForStreams := "[]*Stream{"
	for _, f := range this.Streams {
		repeatedStringForStreams += strings.Replace(f.String(), "Stream", "Stream", 1) + ","
	}
	repeatedStringForStreams += "}"
	s := strings.Join([]string{`&SingleTenantObjectSource{`,
		`Streams:` + repeatedStringForStreams + `,`,
		`NumOutputObjects:` + fmt.Sprintf("%v", this.NumOutputObjects) + `,`,
		`}`,
	}, "")
	return s
}
func (this *MultiTenantObjectSource) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForTenantStreams := "[]*TenantStream{"
	for _, f := range this.TenantStreams {
		repeatedStringForTenantStreams += strings.Replace(f.String(), "TenantStream", "TenantStream", 1) + ","
	}
	repeatedStringForTenantStreams += "}"
	s := strings.Join([]string{`&MultiTenantObjectSource{`,
		`TenantStreams:` + repeatedStringForTenantStreams + `,`,
		`NumOutputObjects:` + fmt.Sprintf("%v", this.NumOutputObjects) + `,`,
		`}`,
	}, "")
	return s
}
func (this *CompactionManifest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&CompactionManifest{`,
		`TimeRange:` + strings.Replace(this.TimeRange.String(), "TimeRange", "TimeRange", 1) + `,`,
		`TargetSizeBytes:` + fmt.Sprintf("%v", this.TargetSizeBytes) + `,`,
		`SourceIndexes:` + fmt.Sprintf("%v", this.SourceIndexes) + `,`,
		`}`,
	}, "")
	return s
}
func (this *SingleTenantObjectSourceWithTenantID) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&SingleTenantObjectSourceWithTenantID{`,
		`Tenant:` + fmt.Sprintf("%v", this.Tenant) + `,`,
		`Source:` + strings.Replace(this.Source.String(), "SingleTenantObjectSource", "SingleTenantObjectSource", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *CompactionJob) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&CompactionJob{`,
		`Source:` + fmt.Sprintf("%v", this.Source) + `,`,
		`TargetSizeBytes:` + fmt.Sprintf("%v", this.TargetSizeBytes) + `,`,
		`ReadRange:` + strings.Replace(this.ReadRange.String(), "TimeRange", "TimeRange", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *CompactionJob_SingleTenant) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&CompactionJob_SingleTenant{`,
		`SingleTenant:` + strings.Replace(fmt.Sprintf("%v", this.SingleTenant), "SingleTenantObjectSourceWithTenantID", "SingleTenantObjectSourceWithTenantID", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *CompactionJob_MultiTenant) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&CompactionJob_MultiTenant{`,
		`MultiTenant:` + strings.Replace(fmt.Sprintf("%v", this.MultiTenant), "MultiTenantObjectSource", "MultiTenantObjectSource", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *CompactionJobResponse) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&CompactionJobResponse{`,
		`Paths:` + fmt.Sprintf("%v", this.Paths) + `,`,
		`}`,
	}, "")
	return s
}
func (this *IndexingJob) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&IndexingJob{`,
		`Paths:` + fmt.Sprintf("%v", this.Paths) + `,`,
		`}`,
	}, "")
	return s
}
func (this *IndexInfo) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&IndexInfo{`,
		`Tenant:` + fmt.Sprintf("%v", this.Tenant) + `,`,
		`Path:` + fmt.Sprintf("%v", this.Path) + `,`,
		`TimeRange:` + strings.Replace(this.TimeRange.String(), "TimeRange", "TimeRange", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *IndexingJobResponse) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForIndexes := "[]*IndexInfo{"
	for _, f := range this.Indexes {
		repeatedStringForIndexes += strings.Replace(f.String(), "IndexInfo", "IndexInfo", 1) + ","
	}
	repeatedStringForIndexes += "}"
	s := strings.Join([]string{`&IndexingJobResponse{`,
		`Indexes:` + repeatedStringForIndexes + `,`,
		`}`,
	}, "")
	return s
}
func valueToStringCompaction(v interface{}) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("*%v", pv)
}
func (m *Stream) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCompaction
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Stream: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Stream: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
			}
			m.ID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCompaction
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ID |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCompaction
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCompaction
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCompaction
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Index = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCompaction(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCompaction
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthCompaction
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TenantStream) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCompaction
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: TenantStream: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TenantStream: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Tenant", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCompaction
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCompaction
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCompaction
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Tenant = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Stream", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCompaction
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCompaction
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCompaction
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Stream == nil {
				m.Stream = &Stream{}
			}
			if err := m.Stream.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCompaction(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCompaction
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthCompaction
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TimeRange) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCompaction
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: TimeRange: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TimeRange: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field From", wireType)
			}
			m.From = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCompaction
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.From |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Through", wireType)
			}
			m.Through = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCompaction
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Through |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipCompaction(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCompaction
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthCompaction
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SingleTenantObjectSource) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCompaction
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: SingleTenantObjectSource: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SingleTenantObjectSource: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Streams", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCompaction
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCompaction
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCompaction
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Streams = append(m.Streams, &Stream{})
			if err := m.Streams[len(m.Streams)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NumOutputObjects", wireType)
			}
			m.NumOutputObjects = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCompaction
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.NumOutputObjects |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipCompaction(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCompaction
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthCompaction
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MultiTenantObjectSource) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCompaction
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MultiTenantObjectSource: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MultiTenantObjectSource: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TenantStreams", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCompaction
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCompaction
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCompaction
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TenantStreams = append(m.TenantStreams, &TenantStream{})
			if err := m.TenantStreams[len(m.TenantStreams)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NumOutputObjects", wireType)
			}
			m.NumOutputObjects = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCompaction
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.NumOutputObjects |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipCompaction(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCompaction
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthCompaction
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CompactionManifest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCompaction
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: CompactionManifest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CompactionManifest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TimeRange", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCompaction
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCompaction
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCompaction
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.TimeRange == nil {
				m.TimeRange = &TimeRange{}
			}
			if err := m.TimeRange.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TargetSizeBytes", wireType)
			}
			m.TargetSizeBytes = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCompaction
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TargetSizeBytes |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SourceIndexes", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCompaction
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCompaction
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCompaction
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SourceIndexes = append(m.SourceIndexes, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCompaction(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCompaction
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthCompaction
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SingleTenantObjectSourceWithTenantID) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCompaction
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: SingleTenantObjectSourceWithTenantID: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SingleTenantObjectSourceWithTenantID: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Tenant", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCompaction
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCompaction
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCompaction
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Tenant = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Source", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCompaction
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCompaction
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCompaction
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Source == nil {
				m.Source = &SingleTenantObjectSource{}
			}
			if err := m.Source.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCompaction(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCompaction
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthCompaction
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CompactionJob) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCompaction
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: CompactionJob: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CompactionJob: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SingleTenant", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCompaction
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCompaction
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCompaction
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &SingleTenantObjectSourceWithTenantID{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Source = &CompactionJob_SingleTenant{v}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MultiTenant", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCompaction
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCompaction
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCompaction
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &MultiTenantObjectSource{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Source = &CompactionJob_MultiTenant{v}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TargetSizeBytes", wireType)
			}
			m.TargetSizeBytes = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCompaction
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TargetSizeBytes |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReadRange", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCompaction
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCompaction
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCompaction
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ReadRange == nil {
				m.ReadRange = &TimeRange{}
			}
			if err := m.ReadRange.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCompaction(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCompaction
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthCompaction
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CompactionJobResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCompaction
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: CompactionJobResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CompactionJobResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Paths", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCompaction
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCompaction
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCompaction
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Paths = append(m.Paths, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCompaction(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCompaction
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthCompaction
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *IndexingJob) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCompaction
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: IndexingJob: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: IndexingJob: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Paths", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCompaction
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCompaction
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCompaction
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Paths = append(m.Paths, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCompaction(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCompaction
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthCompaction
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *IndexInfo) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCompaction
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: IndexInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: IndexInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Tenant", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCompaction
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCompaction
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCompaction
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Tenant = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCompaction
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCompaction
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCompaction
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Path = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TimeRange", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCompaction
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCompaction
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCompaction
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.TimeRange == nil {
				m.TimeRange = &TimeRange{}
			}
			if err := m.TimeRange.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCompaction(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCompaction
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthCompaction
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *IndexingJobResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCompaction
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: IndexingJobResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: IndexingJobResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Indexes", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCompaction
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCompaction
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCompaction
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Indexes = append(m.Indexes, &IndexInfo{})
			if err := m.Indexes[len(m.Indexes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCompaction(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCompaction
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthCompaction
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipCompaction(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowCompaction
			}
			if iNdEx >= l {
				return 0, io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		wireType := int(wire & 0x7)
		switch wireType {
		case 0:
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowCompaction
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
			return iNdEx, nil
		case 1:
			iNdEx += 8
			return iNdEx, nil
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowCompaction
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if length < 0 {
				return 0, ErrInvalidLengthCompaction
			}
			iNdEx += length
			if iNdEx < 0 {
				return 0, ErrInvalidLengthCompaction
			}
			return iNdEx, nil
		case 3:
			for {
				var innerWire uint64
				var start int = iNdEx
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return 0, ErrIntOverflowCompaction
					}
					if iNdEx >= l {
						return 0, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					innerWire |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				innerWireType := int(innerWire & 0x7)
				if innerWireType == 4 {
					break
				}
				next, err := skipCompaction(dAtA[start:])
				if err != nil {
					return 0, err
				}
				iNdEx = start + next
				if iNdEx < 0 {
					return 0, ErrInvalidLengthCompaction
				}
			}
			return iNdEx, nil
		case 4:
			return iNdEx, nil
		case 5:
			iNdEx += 4
			return iNdEx, nil
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
	}
	panic("unreachable")
}

var (
	ErrInvalidLengthCompaction = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowCompaction   = fmt.Errorf("proto: integer overflow")
)