hints.pb.go

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

package hintspb

import (
	fmt "fmt"
	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	storepb "github.com/grafana/mimir/pkg/storegateway/storepb"
	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

type SeriesRequestHints struct {
	/// block_matchers is a list of label matchers that are evaluated against each single block's
	/// labels to filter which blocks get queried. If the list is empty, no per-block filtering
	/// is applied.
	BlockMatchers []storepb.LabelMatcher `protobuf:"bytes,1,rep,name=block_matchers,json=blockMatchers,proto3" json:"block_matchers"`
}

func (m *SeriesRequestHints) Reset()      { *m = SeriesRequestHints{} }
func (*SeriesRequestHints) ProtoMessage() {}
func (*SeriesRequestHints) Descriptor() ([]byte, []int) {
	return fileDescriptor_522be8e0d2634375, []int{0}
}
func (m *SeriesRequestHints) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SeriesRequestHints) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_SeriesRequestHints.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 *SeriesRequestHints) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SeriesRequestHints.Merge(m, src)
}
func (m *SeriesRequestHints) XXX_Size() int {
	return m.Size()
}
func (m *SeriesRequestHints) XXX_DiscardUnknown() {
	xxx_messageInfo_SeriesRequestHints.DiscardUnknown(m)
}

var xxx_messageInfo_SeriesRequestHints proto.InternalMessageInfo

type SeriesResponseHints struct {
	/// queried_blocks is the list of blocks that have been queried.
	QueriedBlocks []Block `protobuf:"bytes,1,rep,name=queried_blocks,json=queriedBlocks,proto3" json:"queried_blocks"`
}

func (m *SeriesResponseHints) Reset()      { *m = SeriesResponseHints{} }
func (*SeriesResponseHints) ProtoMessage() {}
func (*SeriesResponseHints) Descriptor() ([]byte, []int) {
	return fileDescriptor_522be8e0d2634375, []int{1}
}
func (m *SeriesResponseHints) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SeriesResponseHints) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_SeriesResponseHints.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 *SeriesResponseHints) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SeriesResponseHints.Merge(m, src)
}
func (m *SeriesResponseHints) XXX_Size() int {
	return m.Size()
}
func (m *SeriesResponseHints) XXX_DiscardUnknown() {
	xxx_messageInfo_SeriesResponseHints.DiscardUnknown(m)
}

var xxx_messageInfo_SeriesResponseHints proto.InternalMessageInfo

type Block struct {
	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
}

func (m *Block) Reset()      { *m = Block{} }
func (*Block) ProtoMessage() {}
func (*Block) Descriptor() ([]byte, []int) {
	return fileDescriptor_522be8e0d2634375, []int{2}
}
func (m *Block) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Block) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Block.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 *Block) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Block.Merge(m, src)
}
func (m *Block) XXX_Size() int {
	return m.Size()
}
func (m *Block) XXX_DiscardUnknown() {
	xxx_messageInfo_Block.DiscardUnknown(m)
}

var xxx_messageInfo_Block proto.InternalMessageInfo

type LabelNamesRequestHints struct {
	/// block_matchers is a list of label matchers that are evaluated against each single block's
	/// labels to filter which blocks get queried. If the list is empty, no per-block filtering
	/// is applied.
	BlockMatchers []storepb.LabelMatcher `protobuf:"bytes,1,rep,name=block_matchers,json=blockMatchers,proto3" json:"block_matchers"`
}

func (m *LabelNamesRequestHints) Reset()      { *m = LabelNamesRequestHints{} }
func (*LabelNamesRequestHints) ProtoMessage() {}
func (*LabelNamesRequestHints) Descriptor() ([]byte, []int) {
	return fileDescriptor_522be8e0d2634375, []int{3}
}
func (m *LabelNamesRequestHints) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *LabelNamesRequestHints) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_LabelNamesRequestHints.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 *LabelNamesRequestHints) XXX_Merge(src proto.Message) {
	xxx_messageInfo_LabelNamesRequestHints.Merge(m, src)
}
func (m *LabelNamesRequestHints) XXX_Size() int {
	return m.Size()
}
func (m *LabelNamesRequestHints) XXX_DiscardUnknown() {
	xxx_messageInfo_LabelNamesRequestHints.DiscardUnknown(m)
}

var xxx_messageInfo_LabelNamesRequestHints proto.InternalMessageInfo

type LabelNamesResponseHints struct {
	/// queried_blocks is the list of blocks that have been queried.
	QueriedBlocks []Block `protobuf:"bytes,1,rep,name=queried_blocks,json=queriedBlocks,proto3" json:"queried_blocks"`
}

func (m *LabelNamesResponseHints) Reset()      { *m = LabelNamesResponseHints{} }
func (*LabelNamesResponseHints) ProtoMessage() {}
func (*LabelNamesResponseHints) Descriptor() ([]byte, []int) {
	return fileDescriptor_522be8e0d2634375, []int{4}
}
func (m *LabelNamesResponseHints) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *LabelNamesResponseHints) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_LabelNamesResponseHints.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 *LabelNamesResponseHints) XXX_Merge(src proto.Message) {
	xxx_messageInfo_LabelNamesResponseHints.Merge(m, src)
}
func (m *LabelNamesResponseHints) XXX_Size() int {
	return m.Size()
}
func (m *LabelNamesResponseHints) XXX_DiscardUnknown() {
	xxx_messageInfo_LabelNamesResponseHints.DiscardUnknown(m)
}

var xxx_messageInfo_LabelNamesResponseHints proto.InternalMessageInfo

type LabelValuesRequestHints struct {
	/// block_matchers is a list of label matchers that are evaluated against each single block's
	/// labels to filter which blocks get queried. If the list is empty, no per-block filtering
	/// is applied.
	BlockMatchers []storepb.LabelMatcher `protobuf:"bytes,1,rep,name=block_matchers,json=blockMatchers,proto3" json:"block_matchers"`
}

func (m *LabelValuesRequestHints) Reset()      { *m = LabelValuesRequestHints{} }
func (*LabelValuesRequestHints) ProtoMessage() {}
func (*LabelValuesRequestHints) Descriptor() ([]byte, []int) {
	return fileDescriptor_522be8e0d2634375, []int{5}
}
func (m *LabelValuesRequestHints) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *LabelValuesRequestHints) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_LabelValuesRequestHints.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 *LabelValuesRequestHints) XXX_Merge(src proto.Message) {
	xxx_messageInfo_LabelValuesRequestHints.Merge(m, src)
}
func (m *LabelValuesRequestHints) XXX_Size() int {
	return m.Size()
}
func (m *LabelValuesRequestHints) XXX_DiscardUnknown() {
	xxx_messageInfo_LabelValuesRequestHints.DiscardUnknown(m)
}

var xxx_messageInfo_LabelValuesRequestHints proto.InternalMessageInfo

type LabelValuesResponseHints struct {
	/// queried_blocks is the list of blocks that have been queried.
	QueriedBlocks []Block `protobuf:"bytes,1,rep,name=queried_blocks,json=queriedBlocks,proto3" json:"queried_blocks"`
}

func (m *LabelValuesResponseHints) Reset()      { *m = LabelValuesResponseHints{} }
func (*LabelValuesResponseHints) ProtoMessage() {}
func (*LabelValuesResponseHints) Descriptor() ([]byte, []int) {
	return fileDescriptor_522be8e0d2634375, []int{6}
}
func (m *LabelValuesResponseHints) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *LabelValuesResponseHints) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_LabelValuesResponseHints.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 *LabelValuesResponseHints) XXX_Merge(src proto.Message) {
	xxx_messageInfo_LabelValuesResponseHints.Merge(m, src)
}
func (m *LabelValuesResponseHints) XXX_Size() int {
	return m.Size()
}
func (m *LabelValuesResponseHints) XXX_DiscardUnknown() {
	xxx_messageInfo_LabelValuesResponseHints.DiscardUnknown(m)
}

var xxx_messageInfo_LabelValuesResponseHints proto.InternalMessageInfo

func init() {
	proto.RegisterType((*SeriesRequestHints)(nil), "hintspb.SeriesRequestHints")
	proto.RegisterType((*SeriesResponseHints)(nil), "hintspb.SeriesResponseHints")
	proto.RegisterType((*Block)(nil), "hintspb.Block")
	proto.RegisterType((*LabelNamesRequestHints)(nil), "hintspb.LabelNamesRequestHints")
	proto.RegisterType((*LabelNamesResponseHints)(nil), "hintspb.LabelNamesResponseHints")
	proto.RegisterType((*LabelValuesRequestHints)(nil), "hintspb.LabelValuesRequestHints")
	proto.RegisterType((*LabelValuesResponseHints)(nil), "hintspb.LabelValuesResponseHints")
}

func init() { proto.RegisterFile("hints.proto", fileDescriptor_522be8e0d2634375) }

var fileDescriptor_522be8e0d2634375 = []byte{
	// 358 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x92, 0xb1, 0x4e, 0xfb, 0x30,
	0x10, 0xc6, 0xed, 0xfe, 0xff, 0x80, 0x70, 0x45, 0x86, 0x80, 0x68, 0xd5, 0xe1, 0xa8, 0x32, 0x75,
	0x21, 0x91, 0x60, 0x44, 0x0c, 0xed, 0xc4, 0x00, 0x0c, 0x41, 0x6a, 0x25, 0x40, 0xaa, 0x9c, 0xd6,
	0x4d, 0xa2, 0x36, 0x71, 0x1a, 0x3b, 0x42, 0xdd, 0x78, 0x04, 0x1e, 0x83, 0x47, 0xe9, 0xd8, 0xb1,
	0x13, 0x22, 0xe9, 0xc2, 0xd8, 0x47, 0x40, 0x75, 0x12, 0xa9, 0xec, 0xd9, 0xfc, 0x7d, 0x77, 0xf7,
	0xf3, 0x77, 0xd2, 0x91, 0xba, 0xe7, 0x87, 0x52, 0x98, 0x51, 0xcc, 0x25, 0xd7, 0x8f, 0x94, 0x88,
	0x9c, 0xd6, 0xa5, 0xeb, 0x4b, 0x2f, 0x71, 0xcc, 0x11, 0x0f, 0x2c, 0x97, 0xbb, 0xdc, 0x52, 0x75,
	0x27, 0x99, 0x28, 0xa5, 0x84, 0x7a, 0xe5, 0x73, 0xad, 0xdb, 0xfd, 0xf6, 0x98, 0x4e, 0x68, 0x48,
	0xad, 0xc0, 0x0f, 0xfc, 0xd8, 0x8a, 0xa6, 0xae, 0x25, 0x24, 0x8f, 0x99, 0x4b, 0x25, 0x7b, 0xa3,
	0x8b, 0x5c, 0x44, 0x8e, 0x25, 0x17, 0x11, 0x2b, 0xbe, 0x35, 0x06, 0x44, 0x7f, 0x62, 0xb1, 0xcf,
	0x84, 0xcd, 0xe6, 0x09, 0x13, 0xf2, 0x6e, 0x97, 0x42, 0xef, 0x12, 0xcd, 0x99, 0xf1, 0xd1, 0x74,
	0x18, 0x50, 0x39, 0xf2, 0x58, 0x2c, 0x9a, 0xb8, 0xfd, 0xaf, 0x53, 0xbf, 0x3a, 0x33, 0xa5, 0x47,
	0x43, 0x2e, 0xcc, 0x7b, 0xea, 0xb0, 0xd9, 0x43, 0x5e, 0xec, 0xfd, 0x5f, 0x7e, 0x5d, 0x20, 0xfb,
	0x44, 0x4d, 0x14, 0x9e, 0x30, 0x6c, 0x72, 0x5a, 0x82, 0x45, 0xc4, 0x43, 0xc1, 0x72, 0xf2, 0x0d,
	0xd1, 0xe6, 0xc9, 0xce, 0x1f, 0x0f, 0x55, 0x7f, 0x49, 0xd6, 0xcc, 0x62, 0x7f, 0xb3, 0xb7, 0xb3,
	0x4b, 0x66, 0xd1, 0xab, 0x3c, 0x61, 0x34, 0xc8, 0x81, 0x7a, 0xe9, 0x1a, 0xa9, 0xf9, 0xe3, 0x26,
	0x6e, 0xe3, 0xce, 0xb1, 0x5d, 0xf3, 0xc7, 0xc6, 0x0b, 0x39, 0x57, 0x89, 0x1e, 0x69, 0x50, 0xfd,
	0x26, 0x7d, 0xd2, 0xd8, 0x87, 0x57, 0xb6, 0xcd, 0x6b, 0xc1, 0xed, 0xd3, 0x59, 0x52, 0x7d, 0xea,
	0x01, 0x69, 0xfe, 0xa1, 0x57, 0x15, 0xbb, 0xd7, 0x5d, 0xa6, 0x80, 0x56, 0x29, 0xa0, 0x75, 0x0a,
	0x68, 0x9b, 0x02, 0x7e, 0xcf, 0x00, 0x7f, 0x66, 0x80, 0x97, 0x19, 0xe0, 0x55, 0x06, 0xf8, 0x3b,
	0x03, 0xfc, 0x93, 0x01, 0xda, 0x66, 0x80, 0x3f, 0x36, 0x80, 0x56, 0x1b, 0x40, 0xeb, 0x0d, 0xa0,
	0xe7, 0xf2, 0xc4, 0x9d, 0x43, 0x75, 0x7b, 0xd7, 0xbf, 0x01, 0x00, 0x00, 0xff, 0xff, 0xe1, 0x13,
	0x56, 0x30, 0x01, 0x03, 0x00, 0x00,
}

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

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

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

	that1, ok := that.(*Block)
	if !ok {
		that2, ok := that.(Block)
		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
	}
	return true
}
func (this *LabelNamesRequestHints) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

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

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

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

	that1, ok := that.(*LabelValuesResponseHints)
	if !ok {
		that2, ok := that.(LabelValuesResponseHints)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.QueriedBlocks) != len(that1.QueriedBlocks) {
		return false
	}
	for i := range this.QueriedBlocks {
		if !this.QueriedBlocks[i].Equal(&that1.QueriedBlocks[i]) {
			return false
		}
	}
	return true
}
func (this *SeriesRequestHints) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&hintspb.SeriesRequestHints{")
	if this.BlockMatchers != nil {
		vs := make([]*storepb.LabelMatcher, len(this.BlockMatchers))
		for i := range vs {
			vs[i] = &this.BlockMatchers[i]
		}
		s = append(s, "BlockMatchers: "+fmt.Sprintf("%#v", vs)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *SeriesResponseHints) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&hintspb.SeriesResponseHints{")
	if this.QueriedBlocks != nil {
		vs := make([]*Block, len(this.QueriedBlocks))
		for i := range vs {
			vs[i] = &this.QueriedBlocks[i]
		}
		s = append(s, "QueriedBlocks: "+fmt.Sprintf("%#v", vs)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Block) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&hintspb.Block{")
	s = append(s, "Id: "+fmt.Sprintf("%#v", this.Id)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *LabelNamesRequestHints) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&hintspb.LabelNamesRequestHints{")
	if this.BlockMatchers != nil {
		vs := make([]*storepb.LabelMatcher, len(this.BlockMatchers))
		for i := range vs {
			vs[i] = &this.BlockMatchers[i]
		}
		s = append(s, "BlockMatchers: "+fmt.Sprintf("%#v", vs)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *LabelNamesResponseHints) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&hintspb.LabelNamesResponseHints{")
	if this.QueriedBlocks != nil {
		vs := make([]*Block, len(this.QueriedBlocks))
		for i := range vs {
			vs[i] = &this.QueriedBlocks[i]
		}
		s = append(s, "QueriedBlocks: "+fmt.Sprintf("%#v", vs)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *LabelValuesRequestHints) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&hintspb.LabelValuesRequestHints{")
	if this.BlockMatchers != nil {
		vs := make([]*storepb.LabelMatcher, len(this.BlockMatchers))
		for i := range vs {
			vs[i] = &this.BlockMatchers[i]
		}
		s = append(s, "BlockMatchers: "+fmt.Sprintf("%#v", vs)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *LabelValuesResponseHints) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&hintspb.LabelValuesResponseHints{")
	if this.QueriedBlocks != nil {
		vs := make([]*Block, len(this.QueriedBlocks))
		for i := range vs {
			vs[i] = &this.QueriedBlocks[i]
		}
		s = append(s, "QueriedBlocks: "+fmt.Sprintf("%#v", vs)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func valueToGoStringHints(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 *SeriesRequestHints) 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 *SeriesRequestHints) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *SeriesResponseHints) 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 *SeriesResponseHints) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *Block) 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 *Block) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Block) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintHints(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *LabelNamesRequestHints) 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 *LabelNamesRequestHints) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *LabelNamesResponseHints) 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 *LabelNamesResponseHints) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *LabelValuesRequestHints) 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 *LabelValuesRequestHints) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *LabelValuesResponseHints) 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 *LabelValuesResponseHints) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func encodeVarintHints(dAtA []byte, offset int, v uint64) int {
	offset -= sovHints(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *SeriesRequestHints) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.BlockMatchers) > 0 {
		for _, e := range m.BlockMatchers {
			l = e.Size()
			n += 1 + l + sovHints(uint64(l))
		}
	}
	return n
}

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

func (m *Block) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovHints(uint64(l))
	}
	return n
}

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

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

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

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

func sovHints(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozHints(x uint64) (n int) {
	return sovHints(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (this *SeriesRequestHints) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForBlockMatchers := "[]LabelMatcher{"
	for _, f := range this.BlockMatchers {
		repeatedStringForBlockMatchers += fmt.Sprintf("%v", f) + ","
	}
	repeatedStringForBlockMatchers += "}"
	s := strings.Join([]string{`&SeriesRequestHints{`,
		`BlockMatchers:` + repeatedStringForBlockMatchers + `,`,
		`}`,
	}, "")
	return s
}
func (this *SeriesResponseHints) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForQueriedBlocks := "[]Block{"
	for _, f := range this.QueriedBlocks {
		repeatedStringForQueriedBlocks += strings.Replace(strings.Replace(f.String(), "Block", "Block", 1), `&`, ``, 1) + ","
	}
	repeatedStringForQueriedBlocks += "}"
	s := strings.Join([]string{`&SeriesResponseHints{`,
		`QueriedBlocks:` + repeatedStringForQueriedBlocks + `,`,
		`}`,
	}, "")
	return s
}
func (this *Block) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Block{`,
		`Id:` + fmt.Sprintf("%v", this.Id) + `,`,
		`}`,
	}, "")
	return s
}
func (this *LabelNamesRequestHints) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForBlockMatchers := "[]LabelMatcher{"
	for _, f := range this.BlockMatchers {
		repeatedStringForBlockMatchers += fmt.Sprintf("%v", f) + ","
	}
	repeatedStringForBlockMatchers += "}"
	s := strings.Join([]string{`&LabelNamesRequestHints{`,
		`BlockMatchers:` + repeatedStringForBlockMatchers + `,`,
		`}`,
	}, "")
	return s
}
func (this *LabelNamesResponseHints) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForQueriedBlocks := "[]Block{"
	for _, f := range this.QueriedBlocks {
		repeatedStringForQueriedBlocks += strings.Replace(strings.Replace(f.String(), "Block", "Block", 1), `&`, ``, 1) + ","
	}
	repeatedStringForQueriedBlocks += "}"
	s := strings.Join([]string{`&LabelNamesResponseHints{`,
		`QueriedBlocks:` + repeatedStringForQueriedBlocks + `,`,
		`}`,
	}, "")
	return s
}
func (this *LabelValuesRequestHints) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForBlockMatchers := "[]LabelMatcher{"
	for _, f := range this.BlockMatchers {
		repeatedStringForBlockMatchers += fmt.Sprintf("%v", f) + ","
	}
	repeatedStringForBlockMatchers += "}"
	s := strings.Join([]string{`&LabelValuesRequestHints{`,
		`BlockMatchers:` + repeatedStringForBlockMatchers + `,`,
		`}`,
	}, "")
	return s
}
func (this *LabelValuesResponseHints) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForQueriedBlocks := "[]Block{"
	for _, f := range this.QueriedBlocks {
		repeatedStringForQueriedBlocks += strings.Replace(strings.Replace(f.String(), "Block", "Block", 1), `&`, ``, 1) + ","
	}
	repeatedStringForQueriedBlocks += "}"
	s := strings.Join([]string{`&LabelValuesResponseHints{`,
		`QueriedBlocks:` + repeatedStringForQueriedBlocks + `,`,
		`}`,
	}, "")
	return s
}
func valueToStringHints(v interface{}) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("*%v", pv)
}
func (m *SeriesRequestHints) 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 ErrIntOverflowHints
			}
			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: SeriesRequestHints: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SeriesRequestHints: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockMatchers", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHints
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHints
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHints
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BlockMatchers = append(m.BlockMatchers, storepb.LabelMatcher{})
			if err := m.BlockMatchers[len(m.BlockMatchers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipHints(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthHints
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthHints
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SeriesResponseHints) 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 ErrIntOverflowHints
			}
			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: SeriesResponseHints: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SeriesResponseHints: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field QueriedBlocks", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHints
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHints
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHints
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.QueriedBlocks = append(m.QueriedBlocks, Block{})
			if err := m.QueriedBlocks[len(m.QueriedBlocks)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipHints(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthHints
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthHints
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Block) 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 ErrIntOverflowHints
			}
			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: Block: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Block: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHints
				}
				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 ErrInvalidLengthHints
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthHints
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Id = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipHints(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthHints
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthHints
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *LabelNamesRequestHints) 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 ErrIntOverflowHints
			}
			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: LabelNamesRequestHints: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: LabelNamesRequestHints: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockMatchers", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHints
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHints
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHints
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BlockMatchers = append(m.BlockMatchers, storepb.LabelMatcher{})
			if err := m.BlockMatchers[len(m.BlockMatchers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipHints(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthHints
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthHints
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *LabelNamesResponseHints) 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 ErrIntOverflowHints
			}
			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: LabelNamesResponseHints: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: LabelNamesResponseHints: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field QueriedBlocks", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHints
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHints
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHints
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.QueriedBlocks = append(m.QueriedBlocks, Block{})
			if err := m.QueriedBlocks[len(m.QueriedBlocks)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipHints(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthHints
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthHints
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *LabelValuesRequestHints) 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 ErrIntOverflowHints
			}
			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: LabelValuesRequestHints: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: LabelValuesRequestHints: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockMatchers", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHints
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHints
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHints
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BlockMatchers = append(m.BlockMatchers, storepb.LabelMatcher{})
			if err := m.BlockMatchers[len(m.BlockMatchers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipHints(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthHints
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthHints
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *LabelValuesResponseHints) 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 ErrIntOverflowHints
			}
			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: LabelValuesResponseHints: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: LabelValuesResponseHints: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field QueriedBlocks", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHints
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHints
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHints
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.QueriedBlocks = append(m.QueriedBlocks, Block{})
			if err := m.QueriedBlocks[len(m.QueriedBlocks)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipHints(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthHints
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthHints
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipHints(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, ErrIntOverflowHints
			}
			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, ErrIntOverflowHints
				}
				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, ErrIntOverflowHints
				}
				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, ErrInvalidLengthHints
			}
			iNdEx += length
			if iNdEx < 0 {
				return 0, ErrInvalidLengthHints
			}
			return iNdEx, nil
		case 3:
			for {
				var innerWire uint64
				var start int = iNdEx
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return 0, ErrIntOverflowHints
					}
					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 := skipHints(dAtA[start:])
				if err != nil {
					return 0, err
				}
				iNdEx = start + next
				if iNdEx < 0 {
					return 0, ErrInvalidLengthHints
				}
			}
			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 (
	ErrInvalidLengthHints = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowHints   = fmt.Errorf("proto: integer overflow")
)