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

package querierpb

import (
	fmt "fmt"
	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	github_com_grafana_mimir_pkg_mimirpb "github.com/grafana/mimir/pkg/mimirpb"
	mimirpb "github.com/grafana/mimir/pkg/mimirpb"
	stats "github.com/grafana/mimir/pkg/querier/stats"
	planning "github.com/grafana/mimir/pkg/streamingpromql/planning"
	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 EvaluateQueryRequest struct {
	Plan      planning.EncodedQueryPlan `protobuf:"bytes,1,opt,name=plan,proto3" json:"plan"`
	Nodes     []EvaluationNode          `protobuf:"bytes,2,rep,name=nodes,proto3" json:"nodes"`
	BatchSize uint64                    `protobuf:"varint,4,opt,name=batchSize,proto3" json:"batchSize,omitempty"`
	// seriesMetadataBatchSize is the maximum number of series metadata entries to include in a single
	// EvaluateQueryResponseSeriesMetadata message. A non-zero value indicates that the query-frontend
	// supports receiving batched series metadata messages (ie. multiple EvaluateQueryResponseSeriesMetadata
	// messages per node).
	SeriesMetadataBatchSize uint64 `protobuf:"varint,5,opt,name=seriesMetadataBatchSize,proto3" json:"seriesMetadataBatchSize,omitempty"`
}

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

var xxx_messageInfo_EvaluateQueryRequest proto.InternalMessageInfo

func (m *EvaluateQueryRequest) GetPlan() planning.EncodedQueryPlan {
	if m != nil {
		return m.Plan
	}
	return planning.EncodedQueryPlan{}
}

func (m *EvaluateQueryRequest) GetNodes() []EvaluationNode {
	if m != nil {
		return m.Nodes
	}
	return nil
}

func (m *EvaluateQueryRequest) GetBatchSize() uint64 {
	if m != nil {
		return m.BatchSize
	}
	return 0
}

func (m *EvaluateQueryRequest) GetSeriesMetadataBatchSize() uint64 {
	if m != nil {
		return m.SeriesMetadataBatchSize
	}
	return 0
}

type EvaluationNode struct {
	NodeIndex int64                          `protobuf:"varint,1,opt,name=nodeIndex,proto3" json:"nodeIndex,omitempty"`
	TimeRange planning.EncodedQueryTimeRange `protobuf:"bytes,2,opt,name=timeRange,proto3" json:"timeRange"`
}

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

var xxx_messageInfo_EvaluationNode proto.InternalMessageInfo

func (m *EvaluationNode) GetNodeIndex() int64 {
	if m != nil {
		return m.NodeIndex
	}
	return 0
}

func (m *EvaluationNode) GetTimeRange() planning.EncodedQueryTimeRange {
	if m != nil {
		return m.TimeRange
	}
	return planning.EncodedQueryTimeRange{}
}

type EvaluateQueryResponse struct {
	// Types that are valid to be assigned to Message:
	//	*EvaluateQueryResponse_SeriesMetadata
	//	*EvaluateQueryResponse_StringValue
	//	*EvaluateQueryResponse_ScalarValue
	//	*EvaluateQueryResponse_InstantVectorSeriesData
	//	*EvaluateQueryResponse_RangeVectorStepData
	//	*EvaluateQueryResponse_EvaluationCompleted
	Message isEvaluateQueryResponse_Message `protobuf_oneof:"message"`
}

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

var xxx_messageInfo_EvaluateQueryResponse proto.InternalMessageInfo

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

type EvaluateQueryResponse_SeriesMetadata struct {
	SeriesMetadata *EvaluateQueryResponseSeriesMetadata `protobuf:"bytes,1,opt,name=seriesMetadata,proto3,oneof" json:"seriesMetadata,omitempty"`
}
type EvaluateQueryResponse_StringValue struct {
	StringValue *EvaluateQueryResponseStringValue `protobuf:"bytes,2,opt,name=stringValue,proto3,oneof" json:"stringValue,omitempty"`
}
type EvaluateQueryResponse_ScalarValue struct {
	ScalarValue *EvaluateQueryResponseScalarValue `protobuf:"bytes,3,opt,name=scalarValue,proto3,oneof" json:"scalarValue,omitempty"`
}
type EvaluateQueryResponse_InstantVectorSeriesData struct {
	InstantVectorSeriesData *EvaluateQueryResponseInstantVectorSeriesData `protobuf:"bytes,4,opt,name=instantVectorSeriesData,proto3,oneof" json:"instantVectorSeriesData,omitempty"`
}
type EvaluateQueryResponse_RangeVectorStepData struct {
	RangeVectorStepData *EvaluateQueryResponseRangeVectorStepData `protobuf:"bytes,5,opt,name=rangeVectorStepData,proto3,oneof" json:"rangeVectorStepData,omitempty"`
}
type EvaluateQueryResponse_EvaluationCompleted struct {
	EvaluationCompleted *EvaluateQueryResponseEvaluationCompleted `protobuf:"bytes,6,opt,name=evaluationCompleted,proto3,oneof" json:"evaluationCompleted,omitempty"`
}

func (*EvaluateQueryResponse_SeriesMetadata) isEvaluateQueryResponse_Message()          {}
func (*EvaluateQueryResponse_StringValue) isEvaluateQueryResponse_Message()             {}
func (*EvaluateQueryResponse_ScalarValue) isEvaluateQueryResponse_Message()             {}
func (*EvaluateQueryResponse_InstantVectorSeriesData) isEvaluateQueryResponse_Message() {}
func (*EvaluateQueryResponse_RangeVectorStepData) isEvaluateQueryResponse_Message()     {}
func (*EvaluateQueryResponse_EvaluationCompleted) isEvaluateQueryResponse_Message()     {}

func (m *EvaluateQueryResponse) GetMessage() isEvaluateQueryResponse_Message {
	if m != nil {
		return m.Message
	}
	return nil
}

func (m *EvaluateQueryResponse) GetSeriesMetadata() *EvaluateQueryResponseSeriesMetadata {
	if x, ok := m.GetMessage().(*EvaluateQueryResponse_SeriesMetadata); ok {
		return x.SeriesMetadata
	}
	return nil
}

func (m *EvaluateQueryResponse) GetStringValue() *EvaluateQueryResponseStringValue {
	if x, ok := m.GetMessage().(*EvaluateQueryResponse_StringValue); ok {
		return x.StringValue
	}
	return nil
}

func (m *EvaluateQueryResponse) GetScalarValue() *EvaluateQueryResponseScalarValue {
	if x, ok := m.GetMessage().(*EvaluateQueryResponse_ScalarValue); ok {
		return x.ScalarValue
	}
	return nil
}

func (m *EvaluateQueryResponse) GetInstantVectorSeriesData() *EvaluateQueryResponseInstantVectorSeriesData {
	if x, ok := m.GetMessage().(*EvaluateQueryResponse_InstantVectorSeriesData); ok {
		return x.InstantVectorSeriesData
	}
	return nil
}

func (m *EvaluateQueryResponse) GetRangeVectorStepData() *EvaluateQueryResponseRangeVectorStepData {
	if x, ok := m.GetMessage().(*EvaluateQueryResponse_RangeVectorStepData); ok {
		return x.RangeVectorStepData
	}
	return nil
}

func (m *EvaluateQueryResponse) GetEvaluationCompleted() *EvaluateQueryResponseEvaluationCompleted {
	if x, ok := m.GetMessage().(*EvaluateQueryResponse_EvaluationCompleted); ok {
		return x.EvaluationCompleted
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*EvaluateQueryResponse) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*EvaluateQueryResponse_SeriesMetadata)(nil),
		(*EvaluateQueryResponse_StringValue)(nil),
		(*EvaluateQueryResponse_ScalarValue)(nil),
		(*EvaluateQueryResponse_InstantVectorSeriesData)(nil),
		(*EvaluateQueryResponse_RangeVectorStepData)(nil),
		(*EvaluateQueryResponse_EvaluationCompleted)(nil),
	}
}

type EvaluateQueryResponseSeriesMetadata struct {
	NodeIndex int64            `protobuf:"varint,1,opt,name=nodeIndex,proto3" json:"nodeIndex,omitempty"`
	Series    []SeriesMetadata `protobuf:"bytes,2,rep,name=series,proto3" json:"series"`
	// totalSeriesCountForNode is non-zero if the EvaluateQueryRequest has a non-zero seriesMetadataBatchSize and the
	// querier supports batching series metadata messages.
	// Why send a total count rather than a "more messages to come" flag? Sending the count allows the query-frontend to
	// allocate a slice of exactly the right length to hold all series.
	TotalSeriesCountForNode int64 `protobuf:"varint,3,opt,name=totalSeriesCountForNode,proto3" json:"totalSeriesCountForNode,omitempty"`
}

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

var xxx_messageInfo_EvaluateQueryResponseSeriesMetadata proto.InternalMessageInfo

func (m *EvaluateQueryResponseSeriesMetadata) GetNodeIndex() int64 {
	if m != nil {
		return m.NodeIndex
	}
	return 0
}

func (m *EvaluateQueryResponseSeriesMetadata) GetSeries() []SeriesMetadata {
	if m != nil {
		return m.Series
	}
	return nil
}

func (m *EvaluateQueryResponseSeriesMetadata) GetTotalSeriesCountForNode() int64 {
	if m != nil {
		return m.TotalSeriesCountForNode
	}
	return 0
}

type SeriesMetadata struct {
	Labels   []github_com_grafana_mimir_pkg_mimirpb.LabelAdapter `protobuf:"bytes,1,rep,name=labels,proto3,customtype=github.com/grafana/mimir/pkg/mimirpb.LabelAdapter" json:"labels"`
	DropName bool                                                `protobuf:"varint,2,opt,name=dropName,proto3" json:"dropName,omitempty"`
}

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

var xxx_messageInfo_SeriesMetadata proto.InternalMessageInfo

func (m *SeriesMetadata) GetDropName() bool {
	if m != nil {
		return m.DropName
	}
	return false
}

type EvaluateQueryResponseStringValue struct {
	NodeIndex int64  `protobuf:"varint,1,opt,name=nodeIndex,proto3" json:"nodeIndex,omitempty"`
	Value     string `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
}

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

var xxx_messageInfo_EvaluateQueryResponseStringValue proto.InternalMessageInfo

func (m *EvaluateQueryResponseStringValue) GetNodeIndex() int64 {
	if m != nil {
		return m.NodeIndex
	}
	return 0
}

func (m *EvaluateQueryResponseStringValue) GetValue() string {
	if m != nil {
		return m.Value
	}
	return ""
}

type EvaluateQueryResponseScalarValue struct {
	NodeIndex int64            `protobuf:"varint,1,opt,name=nodeIndex,proto3" json:"nodeIndex,omitempty"`
	Values    []mimirpb.Sample `protobuf:"bytes,2,rep,name=values,proto3" json:"values"`
}

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

var xxx_messageInfo_EvaluateQueryResponseScalarValue proto.InternalMessageInfo

func (m *EvaluateQueryResponseScalarValue) GetNodeIndex() int64 {
	if m != nil {
		return m.NodeIndex
	}
	return 0
}

func (m *EvaluateQueryResponseScalarValue) GetValues() []mimirpb.Sample {
	if m != nil {
		return m.Values
	}
	return nil
}

type EvaluateQueryResponseInstantVectorSeriesData struct {
	NodeIndex int64                     `protobuf:"varint,1,opt,name=nodeIndex,proto3" json:"nodeIndex,omitempty"`
	Series    []InstantVectorSeriesData `protobuf:"bytes,2,rep,name=series,proto3" json:"series"`
}

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

var xxx_messageInfo_EvaluateQueryResponseInstantVectorSeriesData proto.InternalMessageInfo

func (m *EvaluateQueryResponseInstantVectorSeriesData) GetNodeIndex() int64 {
	if m != nil {
		return m.NodeIndex
	}
	return 0
}

func (m *EvaluateQueryResponseInstantVectorSeriesData) GetSeries() []InstantVectorSeriesData {
	if m != nil {
		return m.Series
	}
	return nil
}

type InstantVectorSeriesData struct {
	Floats     []mimirpb.Sample             `protobuf:"bytes,1,rep,name=floats,proto3" json:"floats"`
	Histograms []mimirpb.FloatHistogramPair `protobuf:"bytes,2,rep,name=histograms,proto3" json:"histograms"`
}

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

var xxx_messageInfo_InstantVectorSeriesData proto.InternalMessageInfo

func (m *InstantVectorSeriesData) GetFloats() []mimirpb.Sample {
	if m != nil {
		return m.Floats
	}
	return nil
}

func (m *InstantVectorSeriesData) GetHistograms() []mimirpb.FloatHistogramPair {
	if m != nil {
		return m.Histograms
	}
	return nil
}

type EvaluateQueryResponseRangeVectorStepData struct {
	NodeIndex   int64 `protobuf:"varint,1,opt,name=nodeIndex,proto3" json:"nodeIndex,omitempty"`
	SeriesIndex int64 `protobuf:"varint,2,opt,name=seriesIndex,proto3" json:"seriesIndex,omitempty"`
	// These timestamps have the same meaning as the corresponding fields on RangeVectorStepData.
	StepT      int64                        `protobuf:"varint,3,opt,name=step_t,json=stepT,proto3" json:"step_t,omitempty"`
	RangeStart int64                        `protobuf:"varint,4,opt,name=range_start,json=rangeStart,proto3" json:"range_start,omitempty"`
	RangeEnd   int64                        `protobuf:"varint,5,opt,name=range_end,json=rangeEnd,proto3" json:"range_end,omitempty"`
	Floats     []mimirpb.Sample             `protobuf:"bytes,6,rep,name=floats,proto3" json:"floats"`
	Histograms []mimirpb.FloatHistogramPair `protobuf:"bytes,7,rep,name=histograms,proto3" json:"histograms"`
}

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

var xxx_messageInfo_EvaluateQueryResponseRangeVectorStepData proto.InternalMessageInfo

func (m *EvaluateQueryResponseRangeVectorStepData) GetNodeIndex() int64 {
	if m != nil {
		return m.NodeIndex
	}
	return 0
}

func (m *EvaluateQueryResponseRangeVectorStepData) GetSeriesIndex() int64 {
	if m != nil {
		return m.SeriesIndex
	}
	return 0
}

func (m *EvaluateQueryResponseRangeVectorStepData) GetStepT() int64 {
	if m != nil {
		return m.StepT
	}
	return 0
}

func (m *EvaluateQueryResponseRangeVectorStepData) GetRangeStart() int64 {
	if m != nil {
		return m.RangeStart
	}
	return 0
}

func (m *EvaluateQueryResponseRangeVectorStepData) GetRangeEnd() int64 {
	if m != nil {
		return m.RangeEnd
	}
	return 0
}

func (m *EvaluateQueryResponseRangeVectorStepData) GetFloats() []mimirpb.Sample {
	if m != nil {
		return m.Floats
	}
	return nil
}

func (m *EvaluateQueryResponseRangeVectorStepData) GetHistograms() []mimirpb.FloatHistogramPair {
	if m != nil {
		return m.Histograms
	}
	return nil
}

type Error struct {
	Type    mimirpb.QueryErrorType `protobuf:"varint,1,opt,name=type,proto3,enum=cortexpb.QueryErrorType" json:"type,omitempty"`
	Message string                 `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
}

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

var xxx_messageInfo_Error proto.InternalMessageInfo

func (m *Error) GetType() mimirpb.QueryErrorType {
	if m != nil {
		return m.Type
	}
	return mimirpb.QUERY_ERROR_TYPE_NONE
}

func (m *Error) GetMessage() string {
	if m != nil {
		return m.Message
	}
	return ""
}

type EvaluateQueryResponseEvaluationCompleted struct {
	Annotations Annotations `protobuf:"bytes,1,opt,name=annotations,proto3" json:"annotations"`
	Stats       stats.Stats `protobuf:"bytes,2,opt,name=stats,proto3" json:"stats"`
}

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

var xxx_messageInfo_EvaluateQueryResponseEvaluationCompleted proto.InternalMessageInfo

func (m *EvaluateQueryResponseEvaluationCompleted) GetAnnotations() Annotations {
	if m != nil {
		return m.Annotations
	}
	return Annotations{}
}

func (m *EvaluateQueryResponseEvaluationCompleted) GetStats() stats.Stats {
	if m != nil {
		return m.Stats
	}
	return stats.Stats{}
}

type Annotations struct {
	Warnings []string `protobuf:"bytes,1,rep,name=warnings,proto3" json:"warnings,omitempty"`
	Infos    []string `protobuf:"bytes,2,rep,name=infos,proto3" json:"infos,omitempty"`
}

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

var xxx_messageInfo_Annotations proto.InternalMessageInfo

func (m *Annotations) GetWarnings() []string {
	if m != nil {
		return m.Warnings
	}
	return nil
}

func (m *Annotations) GetInfos() []string {
	if m != nil {
		return m.Infos
	}
	return nil
}

func init() {
	proto.RegisterType((*EvaluateQueryRequest)(nil), "querierpb.EvaluateQueryRequest")
	proto.RegisterType((*EvaluationNode)(nil), "querierpb.EvaluationNode")
	proto.RegisterType((*EvaluateQueryResponse)(nil), "querierpb.EvaluateQueryResponse")
	proto.RegisterType((*EvaluateQueryResponseSeriesMetadata)(nil), "querierpb.EvaluateQueryResponseSeriesMetadata")
	proto.RegisterType((*SeriesMetadata)(nil), "querierpb.SeriesMetadata")
	proto.RegisterType((*EvaluateQueryResponseStringValue)(nil), "querierpb.EvaluateQueryResponseStringValue")
	proto.RegisterType((*EvaluateQueryResponseScalarValue)(nil), "querierpb.EvaluateQueryResponseScalarValue")
	proto.RegisterType((*EvaluateQueryResponseInstantVectorSeriesData)(nil), "querierpb.EvaluateQueryResponseInstantVectorSeriesData")
	proto.RegisterType((*InstantVectorSeriesData)(nil), "querierpb.InstantVectorSeriesData")
	proto.RegisterType((*EvaluateQueryResponseRangeVectorStepData)(nil), "querierpb.EvaluateQueryResponseRangeVectorStepData")
	proto.RegisterType((*Error)(nil), "querierpb.Error")
	proto.RegisterType((*EvaluateQueryResponseEvaluationCompleted)(nil), "querierpb.EvaluateQueryResponseEvaluationCompleted")
	proto.RegisterType((*Annotations)(nil), "querierpb.Annotations")
}

func init() { proto.RegisterFile("querier.proto", fileDescriptor_7edfe438abd6b96f) }

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

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

	that1, ok := that.(*EvaluateQueryRequest)
	if !ok {
		that2, ok := that.(EvaluateQueryRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Plan.Equal(&that1.Plan) {
		return false
	}
	if len(this.Nodes) != len(that1.Nodes) {
		return false
	}
	for i := range this.Nodes {
		if !this.Nodes[i].Equal(&that1.Nodes[i]) {
			return false
		}
	}
	if this.BatchSize != that1.BatchSize {
		return false
	}
	if this.SeriesMetadataBatchSize != that1.SeriesMetadataBatchSize {
		return false
	}
	return true
}
func (this *EvaluationNode) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

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

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

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

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

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

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

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

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

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

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

	that1, ok := that.(*EvaluateQueryResponseStringValue)
	if !ok {
		that2, ok := that.(EvaluateQueryResponseStringValue)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.NodeIndex != that1.NodeIndex {
		return false
	}
	if this.Value != that1.Value {
		return false
	}
	return true
}
func (this *EvaluateQueryResponseScalarValue) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

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

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

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

	that1, ok := that.(*EvaluateQueryResponseRangeVectorStepData)
	if !ok {
		that2, ok := that.(EvaluateQueryResponseRangeVectorStepData)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.NodeIndex != that1.NodeIndex {
		return false
	}
	if this.SeriesIndex != that1.SeriesIndex {
		return false
	}
	if this.StepT != that1.StepT {
		return false
	}
	if this.RangeStart != that1.RangeStart {
		return false
	}
	if this.RangeEnd != that1.RangeEnd {
		return false
	}
	if len(this.Floats) != len(that1.Floats) {
		return false
	}
	for i := range this.Floats {
		if !this.Floats[i].Equal(&that1.Floats[i]) {
			return false
		}
	}
	if len(this.Histograms) != len(that1.Histograms) {
		return false
	}
	for i := range this.Histograms {
		if !this.Histograms[i].Equal(&that1.Histograms[i]) {
			return false
		}
	}
	return true
}
func (this *Error) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Error)
	if !ok {
		that2, ok := that.(Error)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Type != that1.Type {
		return false
	}
	if this.Message != that1.Message {
		return false
	}
	return true
}
func (this *EvaluateQueryResponseEvaluationCompleted) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

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

	that1, ok := that.(*Annotations)
	if !ok {
		that2, ok := that.(Annotations)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.Warnings) != len(that1.Warnings) {
		return false
	}
	for i := range this.Warnings {
		if this.Warnings[i] != that1.Warnings[i] {
			return false
		}
	}
	if len(this.Infos) != len(that1.Infos) {
		return false
	}
	for i := range this.Infos {
		if this.Infos[i] != that1.Infos[i] {
			return false
		}
	}
	return true
}
func (this *EvaluateQueryRequest) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 8)
	s = append(s, "&querierpb.EvaluateQueryRequest{")
	s = append(s, "Plan: "+strings.Replace(this.Plan.GoString(), `&`, ``, 1)+",\n")
	if this.Nodes != nil {
		vs := make([]EvaluationNode, len(this.Nodes))
		for i := range vs {
			vs[i] = this.Nodes[i]
		}
		s = append(s, "Nodes: "+fmt.Sprintf("%#v", vs)+",\n")
	}
	s = append(s, "BatchSize: "+fmt.Sprintf("%#v", this.BatchSize)+",\n")
	s = append(s, "SeriesMetadataBatchSize: "+fmt.Sprintf("%#v", this.SeriesMetadataBatchSize)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *EvaluationNode) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&querierpb.EvaluationNode{")
	s = append(s, "NodeIndex: "+fmt.Sprintf("%#v", this.NodeIndex)+",\n")
	s = append(s, "TimeRange: "+strings.Replace(this.TimeRange.GoString(), `&`, ``, 1)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *EvaluateQueryResponse) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 10)
	s = append(s, "&querierpb.EvaluateQueryResponse{")
	if this.Message != nil {
		s = append(s, "Message: "+fmt.Sprintf("%#v", this.Message)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *EvaluateQueryResponse_SeriesMetadata) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&querierpb.EvaluateQueryResponse_SeriesMetadata{` +
		`SeriesMetadata:` + fmt.Sprintf("%#v", this.SeriesMetadata) + `}`}, ", ")
	return s
}
func (this *EvaluateQueryResponse_StringValue) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&querierpb.EvaluateQueryResponse_StringValue{` +
		`StringValue:` + fmt.Sprintf("%#v", this.StringValue) + `}`}, ", ")
	return s
}
func (this *EvaluateQueryResponse_ScalarValue) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&querierpb.EvaluateQueryResponse_ScalarValue{` +
		`ScalarValue:` + fmt.Sprintf("%#v", this.ScalarValue) + `}`}, ", ")
	return s
}
func (this *EvaluateQueryResponse_InstantVectorSeriesData) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&querierpb.EvaluateQueryResponse_InstantVectorSeriesData{` +
		`InstantVectorSeriesData:` + fmt.Sprintf("%#v", this.InstantVectorSeriesData) + `}`}, ", ")
	return s
}
func (this *EvaluateQueryResponse_RangeVectorStepData) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&querierpb.EvaluateQueryResponse_RangeVectorStepData{` +
		`RangeVectorStepData:` + fmt.Sprintf("%#v", this.RangeVectorStepData) + `}`}, ", ")
	return s
}
func (this *EvaluateQueryResponse_EvaluationCompleted) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&querierpb.EvaluateQueryResponse_EvaluationCompleted{` +
		`EvaluationCompleted:` + fmt.Sprintf("%#v", this.EvaluationCompleted) + `}`}, ", ")
	return s
}
func (this *EvaluateQueryResponseSeriesMetadata) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&querierpb.EvaluateQueryResponseSeriesMetadata{")
	s = append(s, "NodeIndex: "+fmt.Sprintf("%#v", this.NodeIndex)+",\n")
	if this.Series != nil {
		vs := make([]SeriesMetadata, len(this.Series))
		for i := range vs {
			vs[i] = this.Series[i]
		}
		s = append(s, "Series: "+fmt.Sprintf("%#v", vs)+",\n")
	}
	s = append(s, "TotalSeriesCountForNode: "+fmt.Sprintf("%#v", this.TotalSeriesCountForNode)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *SeriesMetadata) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&querierpb.SeriesMetadata{")
	s = append(s, "Labels: "+fmt.Sprintf("%#v", this.Labels)+",\n")
	s = append(s, "DropName: "+fmt.Sprintf("%#v", this.DropName)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *EvaluateQueryResponseStringValue) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&querierpb.EvaluateQueryResponseStringValue{")
	s = append(s, "NodeIndex: "+fmt.Sprintf("%#v", this.NodeIndex)+",\n")
	s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *EvaluateQueryResponseScalarValue) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&querierpb.EvaluateQueryResponseScalarValue{")
	s = append(s, "NodeIndex: "+fmt.Sprintf("%#v", this.NodeIndex)+",\n")
	if this.Values != nil {
		vs := make([]mimirpb.Sample, len(this.Values))
		for i := range vs {
			vs[i] = this.Values[i]
		}
		s = append(s, "Values: "+fmt.Sprintf("%#v", vs)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *EvaluateQueryResponseInstantVectorSeriesData) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&querierpb.EvaluateQueryResponseInstantVectorSeriesData{")
	s = append(s, "NodeIndex: "+fmt.Sprintf("%#v", this.NodeIndex)+",\n")
	if this.Series != nil {
		vs := make([]InstantVectorSeriesData, len(this.Series))
		for i := range vs {
			vs[i] = this.Series[i]
		}
		s = append(s, "Series: "+fmt.Sprintf("%#v", vs)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *InstantVectorSeriesData) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&querierpb.InstantVectorSeriesData{")
	if this.Floats != nil {
		vs := make([]mimirpb.Sample, len(this.Floats))
		for i := range vs {
			vs[i] = this.Floats[i]
		}
		s = append(s, "Floats: "+fmt.Sprintf("%#v", vs)+",\n")
	}
	if this.Histograms != nil {
		vs := make([]mimirpb.FloatHistogramPair, len(this.Histograms))
		for i := range vs {
			vs[i] = this.Histograms[i]
		}
		s = append(s, "Histograms: "+fmt.Sprintf("%#v", vs)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *EvaluateQueryResponseRangeVectorStepData) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 11)
	s = append(s, "&querierpb.EvaluateQueryResponseRangeVectorStepData{")
	s = append(s, "NodeIndex: "+fmt.Sprintf("%#v", this.NodeIndex)+",\n")
	s = append(s, "SeriesIndex: "+fmt.Sprintf("%#v", this.SeriesIndex)+",\n")
	s = append(s, "StepT: "+fmt.Sprintf("%#v", this.StepT)+",\n")
	s = append(s, "RangeStart: "+fmt.Sprintf("%#v", this.RangeStart)+",\n")
	s = append(s, "RangeEnd: "+fmt.Sprintf("%#v", this.RangeEnd)+",\n")
	if this.Floats != nil {
		vs := make([]mimirpb.Sample, len(this.Floats))
		for i := range vs {
			vs[i] = this.Floats[i]
		}
		s = append(s, "Floats: "+fmt.Sprintf("%#v", vs)+",\n")
	}
	if this.Histograms != nil {
		vs := make([]mimirpb.FloatHistogramPair, len(this.Histograms))
		for i := range vs {
			vs[i] = this.Histograms[i]
		}
		s = append(s, "Histograms: "+fmt.Sprintf("%#v", vs)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Error) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&querierpb.Error{")
	s = append(s, "Type: "+fmt.Sprintf("%#v", this.Type)+",\n")
	s = append(s, "Message: "+fmt.Sprintf("%#v", this.Message)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *EvaluateQueryResponseEvaluationCompleted) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&querierpb.EvaluateQueryResponseEvaluationCompleted{")
	s = append(s, "Annotations: "+strings.Replace(this.Annotations.GoString(), `&`, ``, 1)+",\n")
	s = append(s, "Stats: "+strings.Replace(this.Stats.GoString(), `&`, ``, 1)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Annotations) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&querierpb.Annotations{")
	s = append(s, "Warnings: "+fmt.Sprintf("%#v", this.Warnings)+",\n")
	s = append(s, "Infos: "+fmt.Sprintf("%#v", this.Infos)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func valueToGoStringQuerier(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 *EvaluateQueryRequest) 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 *EvaluateQueryRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EvaluateQueryRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.SeriesMetadataBatchSize != 0 {
		i = encodeVarintQuerier(dAtA, i, uint64(m.SeriesMetadataBatchSize))
		i--
		dAtA[i] = 0x28
	}
	if m.BatchSize != 0 {
		i = encodeVarintQuerier(dAtA, i, uint64(m.BatchSize))
		i--
		dAtA[i] = 0x20
	}
	if len(m.Nodes) > 0 {
		for iNdEx := len(m.Nodes) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Nodes[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintQuerier(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	{
		size, err := m.Plan.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintQuerier(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

func (m *EvaluationNode) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.TimeRange.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintQuerier(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if m.NodeIndex != 0 {
		i = encodeVarintQuerier(dAtA, i, uint64(m.NodeIndex))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *EvaluateQueryResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Message != nil {
		{
			size := m.Message.Size()
			i -= size
			if _, err := m.Message.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	return len(dAtA) - i, nil
}

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

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

func (m *EvaluateQueryResponse_StringValue) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.StringValue != nil {
		{
			size, err := m.StringValue.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintQuerier(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	return len(dAtA) - i, nil
}
func (m *EvaluateQueryResponse_ScalarValue) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EvaluateQueryResponse_ScalarValue) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.ScalarValue != nil {
		{
			size, err := m.ScalarValue.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintQuerier(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	return len(dAtA) - i, nil
}
func (m *EvaluateQueryResponse_InstantVectorSeriesData) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EvaluateQueryResponse_InstantVectorSeriesData) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.InstantVectorSeriesData != nil {
		{
			size, err := m.InstantVectorSeriesData.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintQuerier(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	return len(dAtA) - i, nil
}
func (m *EvaluateQueryResponse_RangeVectorStepData) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EvaluateQueryResponse_RangeVectorStepData) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.RangeVectorStepData != nil {
		{
			size, err := m.RangeVectorStepData.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintQuerier(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	return len(dAtA) - i, nil
}
func (m *EvaluateQueryResponse_EvaluationCompleted) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EvaluateQueryResponse_EvaluationCompleted) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.EvaluationCompleted != nil {
		{
			size, err := m.EvaluationCompleted.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintQuerier(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	return len(dAtA) - i, nil
}
func (m *EvaluateQueryResponseSeriesMetadata) 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 *EvaluateQueryResponseSeriesMetadata) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EvaluateQueryResponseSeriesMetadata) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.TotalSeriesCountForNode != 0 {
		i = encodeVarintQuerier(dAtA, i, uint64(m.TotalSeriesCountForNode))
		i--
		dAtA[i] = 0x18
	}
	if len(m.Series) > 0 {
		for iNdEx := len(m.Series) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Series[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintQuerier(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if m.NodeIndex != 0 {
		i = encodeVarintQuerier(dAtA, i, uint64(m.NodeIndex))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *SeriesMetadata) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.DropName {
		i--
		if m.DropName {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x10
	}
	if len(m.Labels) > 0 {
		for iNdEx := len(m.Labels) - 1; iNdEx >= 0; iNdEx-- {
			{
				size := m.Labels[iNdEx].Size()
				i -= size
				if _, err := m.Labels[iNdEx].MarshalTo(dAtA[i:]); err != nil {
					return 0, err
				}
				i = encodeVarintQuerier(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *EvaluateQueryResponseScalarValue) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Values) > 0 {
		for iNdEx := len(m.Values) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Values[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintQuerier(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if m.NodeIndex != 0 {
		i = encodeVarintQuerier(dAtA, i, uint64(m.NodeIndex))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *EvaluateQueryResponseInstantVectorSeriesData) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Series) > 0 {
		for iNdEx := len(m.Series) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Series[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintQuerier(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if m.NodeIndex != 0 {
		i = encodeVarintQuerier(dAtA, i, uint64(m.NodeIndex))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *EvaluateQueryResponseRangeVectorStepData) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Histograms) > 0 {
		for iNdEx := len(m.Histograms) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Histograms[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintQuerier(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x3a
		}
	}
	if len(m.Floats) > 0 {
		for iNdEx := len(m.Floats) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Floats[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintQuerier(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x32
		}
	}
	if m.RangeEnd != 0 {
		i = encodeVarintQuerier(dAtA, i, uint64(m.RangeEnd))
		i--
		dAtA[i] = 0x28
	}
	if m.RangeStart != 0 {
		i = encodeVarintQuerier(dAtA, i, uint64(m.RangeStart))
		i--
		dAtA[i] = 0x20
	}
	if m.StepT != 0 {
		i = encodeVarintQuerier(dAtA, i, uint64(m.StepT))
		i--
		dAtA[i] = 0x18
	}
	if m.SeriesIndex != 0 {
		i = encodeVarintQuerier(dAtA, i, uint64(m.SeriesIndex))
		i--
		dAtA[i] = 0x10
	}
	if m.NodeIndex != 0 {
		i = encodeVarintQuerier(dAtA, i, uint64(m.NodeIndex))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *EvaluateQueryResponseEvaluationCompleted) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.Stats.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintQuerier(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	{
		size, err := m.Annotations.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintQuerier(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

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

func encodeVarintQuerier(dAtA []byte, offset int, v uint64) int {
	offset -= sovQuerier(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *EvaluateQueryRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Plan.Size()
	n += 1 + l + sovQuerier(uint64(l))
	if len(m.Nodes) > 0 {
		for _, e := range m.Nodes {
			l = e.Size()
			n += 1 + l + sovQuerier(uint64(l))
		}
	}
	if m.BatchSize != 0 {
		n += 1 + sovQuerier(uint64(m.BatchSize))
	}
	if m.SeriesMetadataBatchSize != 0 {
		n += 1 + sovQuerier(uint64(m.SeriesMetadataBatchSize))
	}
	return n
}

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

func (m *EvaluateQueryResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Message != nil {
		n += m.Message.Size()
	}
	return n
}

func (m *EvaluateQueryResponse_SeriesMetadata) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.SeriesMetadata != nil {
		l = m.SeriesMetadata.Size()
		n += 1 + l + sovQuerier(uint64(l))
	}
	return n
}
func (m *EvaluateQueryResponse_StringValue) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.StringValue != nil {
		l = m.StringValue.Size()
		n += 1 + l + sovQuerier(uint64(l))
	}
	return n
}
func (m *EvaluateQueryResponse_ScalarValue) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ScalarValue != nil {
		l = m.ScalarValue.Size()
		n += 1 + l + sovQuerier(uint64(l))
	}
	return n
}
func (m *EvaluateQueryResponse_InstantVectorSeriesData) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.InstantVectorSeriesData != nil {
		l = m.InstantVectorSeriesData.Size()
		n += 1 + l + sovQuerier(uint64(l))
	}
	return n
}
func (m *EvaluateQueryResponse_RangeVectorStepData) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.RangeVectorStepData != nil {
		l = m.RangeVectorStepData.Size()
		n += 1 + l + sovQuerier(uint64(l))
	}
	return n
}
func (m *EvaluateQueryResponse_EvaluationCompleted) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.EvaluationCompleted != nil {
		l = m.EvaluationCompleted.Size()
		n += 1 + l + sovQuerier(uint64(l))
	}
	return n
}
func (m *EvaluateQueryResponseSeriesMetadata) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.NodeIndex != 0 {
		n += 1 + sovQuerier(uint64(m.NodeIndex))
	}
	if len(m.Series) > 0 {
		for _, e := range m.Series {
			l = e.Size()
			n += 1 + l + sovQuerier(uint64(l))
		}
	}
	if m.TotalSeriesCountForNode != 0 {
		n += 1 + sovQuerier(uint64(m.TotalSeriesCountForNode))
	}
	return n
}

func (m *SeriesMetadata) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Labels) > 0 {
		for _, e := range m.Labels {
			l = e.Size()
			n += 1 + l + sovQuerier(uint64(l))
		}
	}
	if m.DropName {
		n += 2
	}
	return n
}

func (m *EvaluateQueryResponseStringValue) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.NodeIndex != 0 {
		n += 1 + sovQuerier(uint64(m.NodeIndex))
	}
	l = len(m.Value)
	if l > 0 {
		n += 1 + l + sovQuerier(uint64(l))
	}
	return n
}

func (m *EvaluateQueryResponseScalarValue) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.NodeIndex != 0 {
		n += 1 + sovQuerier(uint64(m.NodeIndex))
	}
	if len(m.Values) > 0 {
		for _, e := range m.Values {
			l = e.Size()
			n += 1 + l + sovQuerier(uint64(l))
		}
	}
	return n
}

func (m *EvaluateQueryResponseInstantVectorSeriesData) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.NodeIndex != 0 {
		n += 1 + sovQuerier(uint64(m.NodeIndex))
	}
	if len(m.Series) > 0 {
		for _, e := range m.Series {
			l = e.Size()
			n += 1 + l + sovQuerier(uint64(l))
		}
	}
	return n
}

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

func (m *EvaluateQueryResponseRangeVectorStepData) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.NodeIndex != 0 {
		n += 1 + sovQuerier(uint64(m.NodeIndex))
	}
	if m.SeriesIndex != 0 {
		n += 1 + sovQuerier(uint64(m.SeriesIndex))
	}
	if m.StepT != 0 {
		n += 1 + sovQuerier(uint64(m.StepT))
	}
	if m.RangeStart != 0 {
		n += 1 + sovQuerier(uint64(m.RangeStart))
	}
	if m.RangeEnd != 0 {
		n += 1 + sovQuerier(uint64(m.RangeEnd))
	}
	if len(m.Floats) > 0 {
		for _, e := range m.Floats {
			l = e.Size()
			n += 1 + l + sovQuerier(uint64(l))
		}
	}
	if len(m.Histograms) > 0 {
		for _, e := range m.Histograms {
			l = e.Size()
			n += 1 + l + sovQuerier(uint64(l))
		}
	}
	return n
}

func (m *Error) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Type != 0 {
		n += 1 + sovQuerier(uint64(m.Type))
	}
	l = len(m.Message)
	if l > 0 {
		n += 1 + l + sovQuerier(uint64(l))
	}
	return n
}

func (m *EvaluateQueryResponseEvaluationCompleted) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Annotations.Size()
	n += 1 + l + sovQuerier(uint64(l))
	l = m.Stats.Size()
	n += 1 + l + sovQuerier(uint64(l))
	return n
}

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

func sovQuerier(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozQuerier(x uint64) (n int) {
	return sovQuerier(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (this *EvaluateQueryRequest) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForNodes := "[]EvaluationNode{"
	for _, f := range this.Nodes {
		repeatedStringForNodes += strings.Replace(strings.Replace(f.String(), "EvaluationNode", "EvaluationNode", 1), `&`, ``, 1) + ","
	}
	repeatedStringForNodes += "}"
	s := strings.Join([]string{`&EvaluateQueryRequest{`,
		`Plan:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Plan), "EncodedQueryPlan", "planning.EncodedQueryPlan", 1), `&`, ``, 1) + `,`,
		`Nodes:` + repeatedStringForNodes + `,`,
		`BatchSize:` + fmt.Sprintf("%v", this.BatchSize) + `,`,
		`SeriesMetadataBatchSize:` + fmt.Sprintf("%v", this.SeriesMetadataBatchSize) + `,`,
		`}`,
	}, "")
	return s
}
func (this *EvaluationNode) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&EvaluationNode{`,
		`NodeIndex:` + fmt.Sprintf("%v", this.NodeIndex) + `,`,
		`TimeRange:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.TimeRange), "EncodedQueryTimeRange", "planning.EncodedQueryTimeRange", 1), `&`, ``, 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *EvaluateQueryResponse) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&EvaluateQueryResponse{`,
		`Message:` + fmt.Sprintf("%v", this.Message) + `,`,
		`}`,
	}, "")
	return s
}
func (this *EvaluateQueryResponse_SeriesMetadata) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&EvaluateQueryResponse_SeriesMetadata{`,
		`SeriesMetadata:` + strings.Replace(fmt.Sprintf("%v", this.SeriesMetadata), "EvaluateQueryResponseSeriesMetadata", "EvaluateQueryResponseSeriesMetadata", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *EvaluateQueryResponse_StringValue) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&EvaluateQueryResponse_StringValue{`,
		`StringValue:` + strings.Replace(fmt.Sprintf("%v", this.StringValue), "EvaluateQueryResponseStringValue", "EvaluateQueryResponseStringValue", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *EvaluateQueryResponse_ScalarValue) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&EvaluateQueryResponse_ScalarValue{`,
		`ScalarValue:` + strings.Replace(fmt.Sprintf("%v", this.ScalarValue), "EvaluateQueryResponseScalarValue", "EvaluateQueryResponseScalarValue", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *EvaluateQueryResponse_InstantVectorSeriesData) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&EvaluateQueryResponse_InstantVectorSeriesData{`,
		`InstantVectorSeriesData:` + strings.Replace(fmt.Sprintf("%v", this.InstantVectorSeriesData), "EvaluateQueryResponseInstantVectorSeriesData", "EvaluateQueryResponseInstantVectorSeriesData", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *EvaluateQueryResponse_RangeVectorStepData) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&EvaluateQueryResponse_RangeVectorStepData{`,
		`RangeVectorStepData:` + strings.Replace(fmt.Sprintf("%v", this.RangeVectorStepData), "EvaluateQueryResponseRangeVectorStepData", "EvaluateQueryResponseRangeVectorStepData", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *EvaluateQueryResponse_EvaluationCompleted) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&EvaluateQueryResponse_EvaluationCompleted{`,
		`EvaluationCompleted:` + strings.Replace(fmt.Sprintf("%v", this.EvaluationCompleted), "EvaluateQueryResponseEvaluationCompleted", "EvaluateQueryResponseEvaluationCompleted", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *EvaluateQueryResponseSeriesMetadata) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForSeries := "[]SeriesMetadata{"
	for _, f := range this.Series {
		repeatedStringForSeries += strings.Replace(strings.Replace(f.String(), "SeriesMetadata", "SeriesMetadata", 1), `&`, ``, 1) + ","
	}
	repeatedStringForSeries += "}"
	s := strings.Join([]string{`&EvaluateQueryResponseSeriesMetadata{`,
		`NodeIndex:` + fmt.Sprintf("%v", this.NodeIndex) + `,`,
		`Series:` + repeatedStringForSeries + `,`,
		`TotalSeriesCountForNode:` + fmt.Sprintf("%v", this.TotalSeriesCountForNode) + `,`,
		`}`,
	}, "")
	return s
}
func (this *SeriesMetadata) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&SeriesMetadata{`,
		`Labels:` + fmt.Sprintf("%v", this.Labels) + `,`,
		`DropName:` + fmt.Sprintf("%v", this.DropName) + `,`,
		`}`,
	}, "")
	return s
}
func (this *EvaluateQueryResponseStringValue) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&EvaluateQueryResponseStringValue{`,
		`NodeIndex:` + fmt.Sprintf("%v", this.NodeIndex) + `,`,
		`Value:` + fmt.Sprintf("%v", this.Value) + `,`,
		`}`,
	}, "")
	return s
}
func (this *EvaluateQueryResponseScalarValue) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForValues := "[]Sample{"
	for _, f := range this.Values {
		repeatedStringForValues += fmt.Sprintf("%v", f) + ","
	}
	repeatedStringForValues += "}"
	s := strings.Join([]string{`&EvaluateQueryResponseScalarValue{`,
		`NodeIndex:` + fmt.Sprintf("%v", this.NodeIndex) + `,`,
		`Values:` + repeatedStringForValues + `,`,
		`}`,
	}, "")
	return s
}
func (this *EvaluateQueryResponseInstantVectorSeriesData) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForSeries := "[]InstantVectorSeriesData{"
	for _, f := range this.Series {
		repeatedStringForSeries += strings.Replace(strings.Replace(f.String(), "InstantVectorSeriesData", "InstantVectorSeriesData", 1), `&`, ``, 1) + ","
	}
	repeatedStringForSeries += "}"
	s := strings.Join([]string{`&EvaluateQueryResponseInstantVectorSeriesData{`,
		`NodeIndex:` + fmt.Sprintf("%v", this.NodeIndex) + `,`,
		`Series:` + repeatedStringForSeries + `,`,
		`}`,
	}, "")
	return s
}
func (this *InstantVectorSeriesData) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForFloats := "[]Sample{"
	for _, f := range this.Floats {
		repeatedStringForFloats += fmt.Sprintf("%v", f) + ","
	}
	repeatedStringForFloats += "}"
	repeatedStringForHistograms := "[]FloatHistogramPair{"
	for _, f := range this.Histograms {
		repeatedStringForHistograms += fmt.Sprintf("%v", f) + ","
	}
	repeatedStringForHistograms += "}"
	s := strings.Join([]string{`&InstantVectorSeriesData{`,
		`Floats:` + repeatedStringForFloats + `,`,
		`Histograms:` + repeatedStringForHistograms + `,`,
		`}`,
	}, "")
	return s
}
func (this *EvaluateQueryResponseRangeVectorStepData) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForFloats := "[]Sample{"
	for _, f := range this.Floats {
		repeatedStringForFloats += fmt.Sprintf("%v", f) + ","
	}
	repeatedStringForFloats += "}"
	repeatedStringForHistograms := "[]FloatHistogramPair{"
	for _, f := range this.Histograms {
		repeatedStringForHistograms += fmt.Sprintf("%v", f) + ","
	}
	repeatedStringForHistograms += "}"
	s := strings.Join([]string{`&EvaluateQueryResponseRangeVectorStepData{`,
		`NodeIndex:` + fmt.Sprintf("%v", this.NodeIndex) + `,`,
		`SeriesIndex:` + fmt.Sprintf("%v", this.SeriesIndex) + `,`,
		`StepT:` + fmt.Sprintf("%v", this.StepT) + `,`,
		`RangeStart:` + fmt.Sprintf("%v", this.RangeStart) + `,`,
		`RangeEnd:` + fmt.Sprintf("%v", this.RangeEnd) + `,`,
		`Floats:` + repeatedStringForFloats + `,`,
		`Histograms:` + repeatedStringForHistograms + `,`,
		`}`,
	}, "")
	return s
}
func (this *Error) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Error{`,
		`Type:` + fmt.Sprintf("%v", this.Type) + `,`,
		`Message:` + fmt.Sprintf("%v", this.Message) + `,`,
		`}`,
	}, "")
	return s
}
func (this *EvaluateQueryResponseEvaluationCompleted) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&EvaluateQueryResponseEvaluationCompleted{`,
		`Annotations:` + strings.Replace(strings.Replace(this.Annotations.String(), "Annotations", "Annotations", 1), `&`, ``, 1) + `,`,
		`Stats:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Stats), "Stats", "stats.Stats", 1), `&`, ``, 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Annotations) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Annotations{`,
		`Warnings:` + fmt.Sprintf("%v", this.Warnings) + `,`,
		`Infos:` + fmt.Sprintf("%v", this.Infos) + `,`,
		`}`,
	}, "")
	return s
}
func valueToStringQuerier(v interface{}) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("*%v", pv)
}
func (m *EvaluateQueryRequest) 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 ErrIntOverflowQuerier
			}
			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: EvaluateQueryRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EvaluateQueryRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Plan", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuerier
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQuerier
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQuerier
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Plan.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Nodes", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuerier
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQuerier
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQuerier
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Nodes = append(m.Nodes, EvaluationNode{})
			if err := m.Nodes[len(m.Nodes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BatchSize", wireType)
			}
			m.BatchSize = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuerier
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BatchSize |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SeriesMetadataBatchSize", wireType)
			}
			m.SeriesMetadataBatchSize = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuerier
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SeriesMetadataBatchSize |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipQuerier(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuerier
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EvaluateQueryResponse) 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 ErrIntOverflowQuerier
			}
			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: EvaluateQueryResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EvaluateQueryResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SeriesMetadata", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuerier
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQuerier
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQuerier
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EvaluateQueryResponseSeriesMetadata{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Message = &EvaluateQueryResponse_SeriesMetadata{v}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StringValue", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuerier
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQuerier
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQuerier
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EvaluateQueryResponseStringValue{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Message = &EvaluateQueryResponse_StringValue{v}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ScalarValue", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuerier
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQuerier
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQuerier
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EvaluateQueryResponseScalarValue{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Message = &EvaluateQueryResponse_ScalarValue{v}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field InstantVectorSeriesData", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuerier
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQuerier
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQuerier
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EvaluateQueryResponseInstantVectorSeriesData{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Message = &EvaluateQueryResponse_InstantVectorSeriesData{v}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RangeVectorStepData", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuerier
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQuerier
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQuerier
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EvaluateQueryResponseRangeVectorStepData{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Message = &EvaluateQueryResponse_RangeVectorStepData{v}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EvaluationCompleted", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuerier
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQuerier
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQuerier
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EvaluateQueryResponseEvaluationCompleted{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Message = &EvaluateQueryResponse_EvaluationCompleted{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipQuerier(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuerier
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

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

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

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EvaluateQueryResponseRangeVectorStepData) 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 ErrIntOverflowQuerier
			}
			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: EvaluateQueryResponseRangeVectorStepData: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EvaluateQueryResponseRangeVectorStepData: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NodeIndex", wireType)
			}
			m.NodeIndex = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuerier
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.NodeIndex |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SeriesIndex", wireType)
			}
			m.SeriesIndex = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuerier
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SeriesIndex |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StepT", wireType)
			}
			m.StepT = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuerier
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.StepT |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RangeStart", wireType)
			}
			m.RangeStart = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuerier
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RangeStart |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RangeEnd", wireType)
			}
			m.RangeEnd = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuerier
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RangeEnd |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Floats", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuerier
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQuerier
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQuerier
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Floats = append(m.Floats, mimirpb.Sample{})
			if err := m.Floats[len(m.Floats)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Histograms", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuerier
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQuerier
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQuerier
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Histograms = append(m.Histograms, mimirpb.FloatHistogramPair{})
			if err := m.Histograms[len(m.Histograms)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipQuerier(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuerier
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Error) 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 ErrIntOverflowQuerier
			}
			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: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			m.Type = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuerier
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= mimirpb.QueryErrorType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuerier
				}
				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 ErrInvalidLengthQuerier
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQuerier
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Message = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipQuerier(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuerier
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipQuerier(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	depth := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowQuerier
			}
			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, ErrIntOverflowQuerier
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
		case 1:
			iNdEx += 8
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowQuerier
				}
				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, ErrInvalidLengthQuerier
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupQuerier
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthQuerier
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthQuerier        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowQuerier          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupQuerier = fmt.Errorf("proto: unexpected end of group")
)
