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

package mimirpb

import (
	bytes "bytes"
	encoding_binary "encoding/binary"
	fmt "fmt"
	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	github_com_prometheus_prometheus_model_histogram "github.com/prometheus/prometheus/model/histogram"
	io "io"
	math "math"
	math_bits "math/bits"
	reflect "reflect"
	slices "slices"
	strconv "strconv"
	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 ErrorCause int32

const (
	ERROR_CAUSE_UNKNOWN                ErrorCause = 0
	ERROR_CAUSE_REPLICAS_DID_NOT_MATCH ErrorCause = 1
	ERROR_CAUSE_TOO_MANY_CLUSTERS      ErrorCause = 2
	ERROR_CAUSE_BAD_DATA               ErrorCause = 3
	ERROR_CAUSE_INGESTION_RATE_LIMITED ErrorCause = 4
	ERROR_CAUSE_REQUEST_RATE_LIMITED   ErrorCause = 5
	ERROR_CAUSE_INSTANCE_LIMIT         ErrorCause = 6
	ERROR_CAUSE_SERVICE_UNAVAILABLE    ErrorCause = 7
	ERROR_CAUSE_TSDB_UNAVAILABLE       ErrorCause = 8
	ERROR_CAUSE_TOO_BUSY               ErrorCause = 9
	ERROR_CAUSE_CIRCUIT_BREAKER_OPEN   ErrorCause = 10
	ERROR_CAUSE_METHOD_NOT_ALLOWED     ErrorCause = 11
	ERROR_CAUSE_TENANT_LIMIT           ErrorCause = 12
	ERROR_CAUSE_ACTIVE_SERIES_LIMITED  ErrorCause = 13
)

var ErrorCause_name = map[int32]string{
	0:  "ERROR_CAUSE_UNKNOWN",
	1:  "ERROR_CAUSE_REPLICAS_DID_NOT_MATCH",
	2:  "ERROR_CAUSE_TOO_MANY_CLUSTERS",
	3:  "ERROR_CAUSE_BAD_DATA",
	4:  "ERROR_CAUSE_INGESTION_RATE_LIMITED",
	5:  "ERROR_CAUSE_REQUEST_RATE_LIMITED",
	6:  "ERROR_CAUSE_INSTANCE_LIMIT",
	7:  "ERROR_CAUSE_SERVICE_UNAVAILABLE",
	8:  "ERROR_CAUSE_TSDB_UNAVAILABLE",
	9:  "ERROR_CAUSE_TOO_BUSY",
	10: "ERROR_CAUSE_CIRCUIT_BREAKER_OPEN",
	11: "ERROR_CAUSE_METHOD_NOT_ALLOWED",
	12: "ERROR_CAUSE_TENANT_LIMIT",
	13: "ERROR_CAUSE_ACTIVE_SERIES_LIMITED",
}

var ErrorCause_value = map[string]int32{
	"ERROR_CAUSE_UNKNOWN":                0,
	"ERROR_CAUSE_REPLICAS_DID_NOT_MATCH": 1,
	"ERROR_CAUSE_TOO_MANY_CLUSTERS":      2,
	"ERROR_CAUSE_BAD_DATA":               3,
	"ERROR_CAUSE_INGESTION_RATE_LIMITED": 4,
	"ERROR_CAUSE_REQUEST_RATE_LIMITED":   5,
	"ERROR_CAUSE_INSTANCE_LIMIT":         6,
	"ERROR_CAUSE_SERVICE_UNAVAILABLE":    7,
	"ERROR_CAUSE_TSDB_UNAVAILABLE":       8,
	"ERROR_CAUSE_TOO_BUSY":               9,
	"ERROR_CAUSE_CIRCUIT_BREAKER_OPEN":   10,
	"ERROR_CAUSE_METHOD_NOT_ALLOWED":     11,
	"ERROR_CAUSE_TENANT_LIMIT":           12,
	"ERROR_CAUSE_ACTIVE_SERIES_LIMITED":  13,
}

func (ErrorCause) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_86d4d7485f544059, []int{0}
}

// These values correspond to the possible status values defined in https://github.com/prometheus/prometheus/blob/main/web/api/v1/api.go.
type QueryStatus int32

const (
	QUERY_STATUS_ERROR   QueryStatus = 0
	QUERY_STATUS_SUCCESS QueryStatus = 1
)

var QueryStatus_name = map[int32]string{
	0: "QUERY_STATUS_ERROR",
	1: "QUERY_STATUS_SUCCESS",
}

var QueryStatus_value = map[string]int32{
	"QUERY_STATUS_ERROR":   0,
	"QUERY_STATUS_SUCCESS": 1,
}

func (QueryStatus) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_86d4d7485f544059, []int{1}
}

// These values correspond to the possible error type values defined in https://github.com/prometheus/prometheus/blob/main/web/api/v1/api.go.
type QueryErrorType int32

const (
	QUERY_ERROR_TYPE_NONE              QueryErrorType = 0
	QUERY_ERROR_TYPE_TIMEOUT           QueryErrorType = 1
	QUERY_ERROR_TYPE_CANCELED          QueryErrorType = 2
	QUERY_ERROR_TYPE_EXECUTION         QueryErrorType = 3
	QUERY_ERROR_TYPE_BAD_DATA          QueryErrorType = 4
	QUERY_ERROR_TYPE_INTERNAL          QueryErrorType = 5
	QUERY_ERROR_TYPE_UNAVAILABLE       QueryErrorType = 6
	QUERY_ERROR_TYPE_NOT_FOUND         QueryErrorType = 7
	QUERY_ERROR_TYPE_NOT_ACCEPTABLE    QueryErrorType = 8
	QUERY_ERROR_TYPE_TOO_MANY_REQUESTS QueryErrorType = 9
	QUERY_ERROR_TYPE_TOO_LARGE_ENTRY   QueryErrorType = 10
)

var QueryErrorType_name = map[int32]string{
	0:  "QUERY_ERROR_TYPE_NONE",
	1:  "QUERY_ERROR_TYPE_TIMEOUT",
	2:  "QUERY_ERROR_TYPE_CANCELED",
	3:  "QUERY_ERROR_TYPE_EXECUTION",
	4:  "QUERY_ERROR_TYPE_BAD_DATA",
	5:  "QUERY_ERROR_TYPE_INTERNAL",
	6:  "QUERY_ERROR_TYPE_UNAVAILABLE",
	7:  "QUERY_ERROR_TYPE_NOT_FOUND",
	8:  "QUERY_ERROR_TYPE_NOT_ACCEPTABLE",
	9:  "QUERY_ERROR_TYPE_TOO_MANY_REQUESTS",
	10: "QUERY_ERROR_TYPE_TOO_LARGE_ENTRY",
}

var QueryErrorType_value = map[string]int32{
	"QUERY_ERROR_TYPE_NONE":              0,
	"QUERY_ERROR_TYPE_TIMEOUT":           1,
	"QUERY_ERROR_TYPE_CANCELED":          2,
	"QUERY_ERROR_TYPE_EXECUTION":         3,
	"QUERY_ERROR_TYPE_BAD_DATA":          4,
	"QUERY_ERROR_TYPE_INTERNAL":          5,
	"QUERY_ERROR_TYPE_UNAVAILABLE":       6,
	"QUERY_ERROR_TYPE_NOT_FOUND":         7,
	"QUERY_ERROR_TYPE_NOT_ACCEPTABLE":    8,
	"QUERY_ERROR_TYPE_TOO_MANY_REQUESTS": 9,
	"QUERY_ERROR_TYPE_TOO_LARGE_ENTRY":   10,
}

func (QueryErrorType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_86d4d7485f544059, []int{2}
}

type WriteRequest_SourceEnum int32

const (
	API  WriteRequest_SourceEnum = 0
	RULE WriteRequest_SourceEnum = 1
	OTLP WriteRequest_SourceEnum = 2
)

var WriteRequest_SourceEnum_name = map[int32]string{
	0: "API",
	1: "RULE",
	2: "OTLP",
}

var WriteRequest_SourceEnum_value = map[string]int32{
	"API":  0,
	"RULE": 1,
	"OTLP": 2,
}

func (WriteRequest_SourceEnum) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_86d4d7485f544059, []int{0, 0}
}

type MetricMetadata_MetricType int32

const (
	UNKNOWN        MetricMetadata_MetricType = 0
	COUNTER        MetricMetadata_MetricType = 1
	GAUGE          MetricMetadata_MetricType = 2
	HISTOGRAM      MetricMetadata_MetricType = 3
	GAUGEHISTOGRAM MetricMetadata_MetricType = 4
	SUMMARY        MetricMetadata_MetricType = 5
	INFO           MetricMetadata_MetricType = 6
	STATESET       MetricMetadata_MetricType = 7
)

var MetricMetadata_MetricType_name = map[int32]string{
	0: "UNKNOWN",
	1: "COUNTER",
	2: "GAUGE",
	3: "HISTOGRAM",
	4: "GAUGEHISTOGRAM",
	5: "SUMMARY",
	6: "INFO",
	7: "STATESET",
}

var MetricMetadata_MetricType_value = map[string]int32{
	"UNKNOWN":        0,
	"COUNTER":        1,
	"GAUGE":          2,
	"HISTOGRAM":      3,
	"GAUGEHISTOGRAM": 4,
	"SUMMARY":        5,
	"INFO":           6,
	"STATESET":       7,
}

func (MetricMetadata_MetricType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_86d4d7485f544059, []int{6, 0}
}

type Histogram_ResetHint int32

const (
	Histogram_UNKNOWN Histogram_ResetHint = 0
	Histogram_YES     Histogram_ResetHint = 1
	Histogram_NO      Histogram_ResetHint = 2
	Histogram_GAUGE   Histogram_ResetHint = 3
)

var Histogram_ResetHint_name = map[int32]string{
	0: "UNKNOWN",
	1: "YES",
	2: "NO",
	3: "GAUGE",
}

var Histogram_ResetHint_value = map[string]int32{
	"UNKNOWN": 0,
	"YES":     1,
	"NO":      2,
	"GAUGE":   3,
}

func (Histogram_ResetHint) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_86d4d7485f544059, []int{9, 0}
}

type MetadataRW2_MetricType int32

const (
	METRIC_TYPE_UNSPECIFIED    MetadataRW2_MetricType = 0
	METRIC_TYPE_COUNTER        MetadataRW2_MetricType = 1
	METRIC_TYPE_GAUGE          MetadataRW2_MetricType = 2
	METRIC_TYPE_HISTOGRAM      MetadataRW2_MetricType = 3
	METRIC_TYPE_GAUGEHISTOGRAM MetadataRW2_MetricType = 4
	METRIC_TYPE_SUMMARY        MetadataRW2_MetricType = 5
	METRIC_TYPE_INFO           MetadataRW2_MetricType = 6
	METRIC_TYPE_STATESET       MetadataRW2_MetricType = 7
)

var MetadataRW2_MetricType_name = map[int32]string{
	0: "METRIC_TYPE_UNSPECIFIED",
	1: "METRIC_TYPE_COUNTER",
	2: "METRIC_TYPE_GAUGE",
	3: "METRIC_TYPE_HISTOGRAM",
	4: "METRIC_TYPE_GAUGEHISTOGRAM",
	5: "METRIC_TYPE_SUMMARY",
	6: "METRIC_TYPE_INFO",
	7: "METRIC_TYPE_STATESET",
}

var MetadataRW2_MetricType_value = map[string]int32{
	"METRIC_TYPE_UNSPECIFIED":    0,
	"METRIC_TYPE_COUNTER":        1,
	"METRIC_TYPE_GAUGE":          2,
	"METRIC_TYPE_HISTOGRAM":      3,
	"METRIC_TYPE_GAUGEHISTOGRAM": 4,
	"METRIC_TYPE_SUMMARY":        5,
	"METRIC_TYPE_INFO":           6,
	"METRIC_TYPE_STATESET":       7,
}

func (MetadataRW2_MetricType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_86d4d7485f544059, []int{27, 0}
}

type WriteRequest struct {
	// Keep reference to buffer for unsafe references.
	BufferHolder
	// sourceBufferHolders is populated when the WriteRequest is synthesized
	// from other WriteRequests, e. g. when batching, and thus holds references
	// to those source buffers. The WriteRequest must hold a strong reference to
	// each of these buffers.
	sourceBufferHolders map[uintptr]BufferHolder

	Timeseries []PreallocTimeseries    `protobuf:"bytes,1,rep,name=timeseries,proto3,customtype=PreallocTimeseries" json:"timeseries"`
	Source     WriteRequest_SourceEnum `protobuf:"varint,2,opt,name=Source,proto3,enum=cortexpb.WriteRequest_SourceEnum" json:"Source,omitempty"`
	Metadata   []*MetricMetadata       `protobuf:"bytes,3,rep,name=metadata,proto3" json:"metadata,omitempty"`
	// Remote Write 2.0 specific fields. Only used when the extra internal
	// field UnmarshalFromRW2 is true.
	SymbolsRW2    []string        `protobuf:"bytes,4,rep,name=symbolsRW2,proto3" json:"symbolsRW2,omitempty"`
	TimeseriesRW2 []TimeSeriesRW2 `protobuf:"bytes,5,rep,name=timeseriesRW2,proto3" json:"timeseriesRW2"`
	// Skip validation of label names and values.
	SkipLabelValidation bool `protobuf:"varint,1000,opt,name=skip_label_validation,json=skipLabelValidation,proto3" json:"skip_label_validation,omitempty"`
	// Skip label count validation.
	SkipLabelCountValidation bool `protobuf:"varint,1001,opt,name=skip_label_count_validation,json=skipLabelCountValidation,proto3" json:"skip_label_count_validation,omitempty"`

	// Skip unmarshaling of exemplars.
	skipUnmarshalingExemplars bool
	// Skip normalization of metadata metric names when unmarshalling the request.
	skipNormalizeMetadataMetricName bool
	// Skip deduplication of metric metadata by family name.
	skipDeduplicateMetadata bool
	// Unmarshal from Remote Write 2.0. if rw2symbols is not nil.
	unmarshalFromRW2 bool
	rw2symbols       rw2PagedSymbols
}

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

var xxx_messageInfo_WriteRequest proto.InternalMessageInfo

func (m *WriteRequest) GetSource() WriteRequest_SourceEnum {
	if m != nil {
		return m.Source
	}
	return API
}

func (m *WriteRequest) GetMetadata() []*MetricMetadata {
	if m != nil {
		return m.Metadata
	}
	return nil
}

func (m *WriteRequest) GetSymbolsRW2() []string {
	if m != nil {
		return m.SymbolsRW2
	}
	return nil
}

func (m *WriteRequest) GetTimeseriesRW2() []TimeSeriesRW2 {
	if m != nil {
		return m.TimeseriesRW2
	}
	return nil
}

func (m *WriteRequest) GetSkipLabelValidation() bool {
	if m != nil {
		return m.SkipLabelValidation
	}
	return false
}

func (m *WriteRequest) GetSkipLabelCountValidation() bool {
	if m != nil {
		return m.SkipLabelCountValidation
	}
	return false
}

type WriteResponse struct {
}

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

var xxx_messageInfo_WriteResponse proto.InternalMessageInfo

type ErrorDetails struct {
	Cause           ErrorCause `protobuf:"varint,1,opt,name=Cause,proto3,enum=cortexpb.ErrorCause" json:"Cause,omitempty"`
	Soft            bool       `protobuf:"varint,2,opt,name=Soft,proto3" json:"Soft,omitempty"`
	RejectedSamples int64      `protobuf:"varint,3,opt,name=RejectedSamples,proto3" json:"RejectedSamples,omitempty"`
}

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

var xxx_messageInfo_ErrorDetails proto.InternalMessageInfo

func (m *ErrorDetails) GetCause() ErrorCause {
	if m != nil {
		return m.Cause
	}
	return ERROR_CAUSE_UNKNOWN
}

func (m *ErrorDetails) GetSoft() bool {
	if m != nil {
		return m.Soft
	}
	return false
}

func (m *ErrorDetails) GetRejectedSamples() int64 {
	if m != nil {
		return m.RejectedSamples
	}
	return 0
}

// # DO NOT SHALLOW-COPY
//
// Data referenced from a PreallocTimeseries may change once the timeseries is
// returned to the shared pool. This includes usually immutable references, like
// strings. If needed, use DeepCopyTimeseries instead.
type TimeSeries struct {
	Labels []UnsafeMutableLabel `protobuf:"bytes,1,rep,name=labels,proto3,customtype=UnsafeMutableLabel" json:"labels"`
	// Sorted by time, oldest sample first.
	Samples    []Sample    `protobuf:"bytes,2,rep,name=samples,proto3" json:"samples"`
	Exemplars  []Exemplar  `protobuf:"bytes,3,rep,name=exemplars,proto3" json:"exemplars"`
	Histograms []Histogram `protobuf:"bytes,4,rep,name=histograms,proto3" json:"histograms"`
	// Copy from remote write 2.0.
	// Note that the "optional" keyword is omitted due to
	// https://cloud.google.com/apis/design/design_patterns.md#optional_primitive_fields
	// Zero value means value not set. If you need to use exactly zero value for
	// the timestamp, use 1 millisecond before or after.
	CreatedTimestamp int64 `protobuf:"varint,6,opt,name=created_timestamp,json=createdTimestamp,proto3" json:"created_timestamp,omitempty"`

	// Skip unmarshaling of exemplars.
	SkipUnmarshalingExemplars bool
}

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

var xxx_messageInfo_TimeSeries proto.InternalMessageInfo

func (m *TimeSeries) GetSamples() []Sample {
	if m != nil {
		return m.Samples
	}
	return nil
}

func (m *TimeSeries) GetExemplars() []Exemplar {
	if m != nil {
		return m.Exemplars
	}
	return nil
}

func (m *TimeSeries) GetHistograms() []Histogram {
	if m != nil {
		return m.Histograms
	}
	return nil
}

func (m *TimeSeries) GetCreatedTimestamp() int64 {
	if m != nil {
		return m.CreatedTimestamp
	}
	return 0
}

type LabelPair struct {
	Name  []byte `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Value []byte `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
}

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

var xxx_messageInfo_LabelPair proto.InternalMessageInfo

func (m *LabelPair) GetName() []byte {
	if m != nil {
		return m.Name
	}
	return nil
}

func (m *LabelPair) GetValue() []byte {
	if m != nil {
		return m.Value
	}
	return nil
}

type Sample struct {
	// Fields order MUST match promql.FPoint so that we can cast types between them.
	TimestampMs int64   `protobuf:"varint,2,opt,name=timestamp_ms,json=timestampMs,proto3" json:"timestamp_ms,omitempty"`
	Value       float64 `protobuf:"fixed64,1,opt,name=value,proto3" json:"value,omitempty"`
}

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

var xxx_messageInfo_Sample proto.InternalMessageInfo

func (m *Sample) GetTimestampMs() int64 {
	if m != nil {
		return m.TimestampMs
	}
	return 0
}

func (m *Sample) GetValue() float64 {
	if m != nil {
		return m.Value
	}
	return 0
}

type MetricMetadata struct {
	Type             MetricMetadata_MetricType `protobuf:"varint,1,opt,name=type,proto3,enum=cortexpb.MetricMetadata_MetricType" json:"type,omitempty"`
	MetricFamilyName string                    `protobuf:"bytes,2,opt,name=metric_family_name,json=metricFamilyName,proto3" json:"metric_family_name,omitempty"`
	Help             string                    `protobuf:"bytes,4,opt,name=help,proto3" json:"help,omitempty"`
	Unit             string                    `protobuf:"bytes,5,opt,name=unit,proto3" json:"unit,omitempty"`
}

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

var xxx_messageInfo_MetricMetadata proto.InternalMessageInfo

func (m *MetricMetadata) GetType() MetricMetadata_MetricType {
	if m != nil {
		return m.Type
	}
	return UNKNOWN
}

func (m *MetricMetadata) GetMetricFamilyName() string {
	if m != nil {
		return m.MetricFamilyName
	}
	return ""
}

func (m *MetricMetadata) GetHelp() string {
	if m != nil {
		return m.Help
	}
	return ""
}

func (m *MetricMetadata) GetUnit() string {
	if m != nil {
		return m.Unit
	}
	return ""
}

type Metric struct {
	Labels []UnsafeMutableLabel `protobuf:"bytes,1,rep,name=labels,proto3,customtype=UnsafeMutableLabel" json:"labels"`
}

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

var xxx_messageInfo_Metric proto.InternalMessageInfo

type Exemplar struct {
	// Exemplar labels, different than series labels
	Labels      []UnsafeMutableLabel `protobuf:"bytes,1,rep,name=labels,proto3,customtype=UnsafeMutableLabel" json:"labels"`
	Value       float64              `protobuf:"fixed64,2,opt,name=value,proto3" json:"value,omitempty"`
	TimestampMs int64                `protobuf:"varint,3,opt,name=timestamp_ms,json=timestampMs,proto3" json:"timestamp_ms,omitempty"`
}

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

var xxx_messageInfo_Exemplar proto.InternalMessageInfo

func (m *Exemplar) GetValue() float64 {
	if m != nil {
		return m.Value
	}
	return 0
}

func (m *Exemplar) GetTimestampMs() int64 {
	if m != nil {
		return m.TimestampMs
	}
	return 0
}

// This is based on https://github.com/prometheus/prometheus/blob/main/prompb/types.proto
type Histogram struct {
	// Types that are valid to be assigned to Count:
	//
	//	*Histogram_CountInt
	//	*Histogram_CountFloat
	Count isHistogram_Count `protobuf_oneof:"count"`
	Sum   float64           `protobuf:"fixed64,3,opt,name=sum,proto3" json:"sum,omitempty"`
	// The schema defines the bucket schema. Currently, valid numbers
	// are -4 <= n <= 8. They are all for base-2 bucket schemas, where 1
	// is a bucket boundary in each case, and then each power of two is
	// divided into 2^n logarithmic buckets. Or in other words, each
	// bucket boundary is the previous boundary times 2^(2^-n). In the
	// future, more bucket schemas may be added using numbers < -4 or >
	// 8.
	Schema        int32   `protobuf:"zigzag32,4,opt,name=schema,proto3" json:"schema,omitempty"`
	ZeroThreshold float64 `protobuf:"fixed64,5,opt,name=zero_threshold,json=zeroThreshold,proto3" json:"zero_threshold,omitempty"`
	// Types that are valid to be assigned to ZeroCount:
	//
	//	*Histogram_ZeroCountInt
	//	*Histogram_ZeroCountFloat
	ZeroCount isHistogram_ZeroCount `protobuf_oneof:"zero_count"`
	// Negative Buckets.
	NegativeSpans []BucketSpan `protobuf:"bytes,8,rep,name=negative_spans,json=negativeSpans,proto3" json:"negative_spans"`
	// Use either "negative_deltas" or "negative_counts", the former for
	// regular histograms with integer counts, the latter for float
	// histograms.
	NegativeDeltas []int64   `protobuf:"zigzag64,9,rep,packed,name=negative_deltas,json=negativeDeltas,proto3" json:"negative_deltas,omitempty"`
	NegativeCounts []float64 `protobuf:"fixed64,10,rep,packed,name=negative_counts,json=negativeCounts,proto3" json:"negative_counts,omitempty"`
	// Positive Buckets.
	PositiveSpans []BucketSpan `protobuf:"bytes,11,rep,name=positive_spans,json=positiveSpans,proto3" json:"positive_spans"`
	// Use either "positive_deltas" or "positive_counts", the former for
	// regular histograms with integer counts, the latter for float
	// histograms.
	PositiveDeltas []int64             `protobuf:"zigzag64,12,rep,packed,name=positive_deltas,json=positiveDeltas,proto3" json:"positive_deltas,omitempty"`
	PositiveCounts []float64           `protobuf:"fixed64,13,rep,packed,name=positive_counts,json=positiveCounts,proto3" json:"positive_counts,omitempty"`
	ResetHint      Histogram_ResetHint `protobuf:"varint,14,opt,name=reset_hint,json=resetHint,proto3,enum=cortexpb.Histogram_ResetHint" json:"reset_hint,omitempty"`
	// timestamp is in ms format
	Timestamp int64 `protobuf:"varint,15,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
	// custom_values are not part of the specification, DO NOT use in remote write clients.
	// Used only for converting from OpenTelemetry to Prometheus internally and
	// to unmarshal Remote Write 2.0 messages.
	CustomValues []float64 `protobuf:"fixed64,16,rep,packed,name=custom_values,json=customValues,proto3" json:"custom_values,omitempty"`
}

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

var xxx_messageInfo_Histogram proto.InternalMessageInfo

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

type Histogram_CountInt struct {
	CountInt uint64 `protobuf:"varint,1,opt,name=count_int,json=countInt,proto3,oneof" json:"count_int,omitempty"`
}
type Histogram_CountFloat struct {
	CountFloat float64 `protobuf:"fixed64,2,opt,name=count_float,json=countFloat,proto3,oneof" json:"count_float,omitempty"`
}
type Histogram_ZeroCountInt struct {
	ZeroCountInt uint64 `protobuf:"varint,6,opt,name=zero_count_int,json=zeroCountInt,proto3,oneof" json:"zero_count_int,omitempty"`
}
type Histogram_ZeroCountFloat struct {
	ZeroCountFloat float64 `protobuf:"fixed64,7,opt,name=zero_count_float,json=zeroCountFloat,proto3,oneof" json:"zero_count_float,omitempty"`
}

func (*Histogram_CountInt) isHistogram_Count()           {}
func (*Histogram_CountFloat) isHistogram_Count()         {}
func (*Histogram_ZeroCountInt) isHistogram_ZeroCount()   {}
func (*Histogram_ZeroCountFloat) isHistogram_ZeroCount() {}

func (m *Histogram) GetCount() isHistogram_Count {
	if m != nil {
		return m.Count
	}
	return nil
}
func (m *Histogram) GetZeroCount() isHistogram_ZeroCount {
	if m != nil {
		return m.ZeroCount
	}
	return nil
}

func (m *Histogram) GetCountInt() uint64 {
	if x, ok := m.GetCount().(*Histogram_CountInt); ok {
		return x.CountInt
	}
	return 0
}

func (m *Histogram) GetCountFloat() float64 {
	if x, ok := m.GetCount().(*Histogram_CountFloat); ok {
		return x.CountFloat
	}
	return 0
}

func (m *Histogram) GetSum() float64 {
	if m != nil {
		return m.Sum
	}
	return 0
}

func (m *Histogram) GetSchema() int32 {
	if m != nil {
		return m.Schema
	}
	return 0
}

func (m *Histogram) GetZeroThreshold() float64 {
	if m != nil {
		return m.ZeroThreshold
	}
	return 0
}

func (m *Histogram) GetZeroCountInt() uint64 {
	if x, ok := m.GetZeroCount().(*Histogram_ZeroCountInt); ok {
		return x.ZeroCountInt
	}
	return 0
}

func (m *Histogram) GetZeroCountFloat() float64 {
	if x, ok := m.GetZeroCount().(*Histogram_ZeroCountFloat); ok {
		return x.ZeroCountFloat
	}
	return 0
}

func (m *Histogram) GetNegativeSpans() []BucketSpan {
	if m != nil {
		return m.NegativeSpans
	}
	return nil
}

func (m *Histogram) GetNegativeDeltas() []int64 {
	if m != nil {
		return m.NegativeDeltas
	}
	return nil
}

func (m *Histogram) GetNegativeCounts() []float64 {
	if m != nil {
		return m.NegativeCounts
	}
	return nil
}

func (m *Histogram) GetPositiveSpans() []BucketSpan {
	if m != nil {
		return m.PositiveSpans
	}
	return nil
}

func (m *Histogram) GetPositiveDeltas() []int64 {
	if m != nil {
		return m.PositiveDeltas
	}
	return nil
}

func (m *Histogram) GetPositiveCounts() []float64 {
	if m != nil {
		return m.PositiveCounts
	}
	return nil
}

func (m *Histogram) GetResetHint() Histogram_ResetHint {
	if m != nil {
		return m.ResetHint
	}
	return Histogram_UNKNOWN
}

func (m *Histogram) GetTimestamp() int64 {
	if m != nil {
		return m.Timestamp
	}
	return 0
}

func (m *Histogram) GetCustomValues() []float64 {
	if m != nil {
		return m.CustomValues
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*Histogram) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*Histogram_CountInt)(nil),
		(*Histogram_CountFloat)(nil),
		(*Histogram_ZeroCountInt)(nil),
		(*Histogram_ZeroCountFloat)(nil),
	}
}

// FloatHistogram is based on https://github.com/prometheus/prometheus/blob/main/model/histogram/float_histogram.go.
// The fields below must be the same types and in the same order as Prometheus' histogram.FloatHistogram type so we can cast between
// them safely.
type FloatHistogram struct {
	CounterResetHint github_com_prometheus_prometheus_model_histogram.CounterResetHint `protobuf:"varint,14,opt,name=counter_reset_hint,json=counterResetHint,proto3,casttype=github.com/prometheus/prometheus/model/histogram.CounterResetHint" json:"counter_reset_hint,omitempty"`
	Schema           int32                                                             `protobuf:"zigzag32,4,opt,name=schema,proto3" json:"schema,omitempty"`
	ZeroThreshold    float64                                                           `protobuf:"fixed64,5,opt,name=zero_threshold,json=zeroThreshold,proto3" json:"zero_threshold,omitempty"`
	ZeroCount        float64                                                           `protobuf:"fixed64,7,opt,name=zero_count,json=zeroCount,proto3" json:"zero_count,omitempty"`
	Count            float64                                                           `protobuf:"fixed64,2,opt,name=count,proto3" json:"count,omitempty"`
	Sum              float64                                                           `protobuf:"fixed64,3,opt,name=sum,proto3" json:"sum,omitempty"`
	PositiveSpans    []BucketSpan                                                      `protobuf:"bytes,11,rep,name=positive_spans,json=positiveSpans,proto3" json:"positive_spans"`
	NegativeSpans    []BucketSpan                                                      `protobuf:"bytes,8,rep,name=negative_spans,json=negativeSpans,proto3" json:"negative_spans"`
	PositiveBuckets  []float64                                                         `protobuf:"fixed64,13,rep,packed,name=positive_buckets,json=positiveBuckets,proto3" json:"positive_buckets,omitempty"`
	NegativeBuckets  []float64                                                         `protobuf:"fixed64,10,rep,packed,name=negative_buckets,json=negativeBuckets,proto3" json:"negative_buckets,omitempty"`
	CustomValues     []float64                                                         `protobuf:"fixed64,16,rep,packed,name=custom_values,json=customValues,proto3" json:"custom_values,omitempty"`
}

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

var xxx_messageInfo_FloatHistogram proto.InternalMessageInfo

func (m *FloatHistogram) GetCounterResetHint() github_com_prometheus_prometheus_model_histogram.CounterResetHint {
	if m != nil {
		return m.CounterResetHint
	}
	return 0
}

func (m *FloatHistogram) GetSchema() int32 {
	if m != nil {
		return m.Schema
	}
	return 0
}

func (m *FloatHistogram) GetZeroThreshold() float64 {
	if m != nil {
		return m.ZeroThreshold
	}
	return 0
}

func (m *FloatHistogram) GetZeroCount() float64 {
	if m != nil {
		return m.ZeroCount
	}
	return 0
}

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

func (m *FloatHistogram) GetSum() float64 {
	if m != nil {
		return m.Sum
	}
	return 0
}

func (m *FloatHistogram) GetPositiveSpans() []BucketSpan {
	if m != nil {
		return m.PositiveSpans
	}
	return nil
}

func (m *FloatHistogram) GetNegativeSpans() []BucketSpan {
	if m != nil {
		return m.NegativeSpans
	}
	return nil
}

func (m *FloatHistogram) GetPositiveBuckets() []float64 {
	if m != nil {
		return m.PositiveBuckets
	}
	return nil
}

func (m *FloatHistogram) GetNegativeBuckets() []float64 {
	if m != nil {
		return m.NegativeBuckets
	}
	return nil
}

func (m *FloatHistogram) GetCustomValues() []float64 {
	if m != nil {
		return m.CustomValues
	}
	return nil
}

// A BucketSpan defines a number of consecutive buckets with their
// offset. Logically, it would be more straightforward to include the
// bucket counts in the Span. However, the protobuf representation is
// more compact in the way the data is structured here (with all the
// buckets in a single array separate from the Spans).
//
// BucketSpan is based on Prometheus' histogram.Span type defined in https://github.com/prometheus/prometheus/blob/main/model/histogram/histogram.go.
// The fields below must be the same types and in the same order Prometheus' histogram.Span type so we can cast between
// them safely.
type BucketSpan struct {
	Offset int32  `protobuf:"zigzag32,1,opt,name=offset,proto3" json:"offset,omitempty"`
	Length uint32 `protobuf:"varint,2,opt,name=length,proto3" json:"length,omitempty"`
}

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

var xxx_messageInfo_BucketSpan proto.InternalMessageInfo

func (m *BucketSpan) GetOffset() int32 {
	if m != nil {
		return m.Offset
	}
	return 0
}

func (m *BucketSpan) GetLength() uint32 {
	if m != nil {
		return m.Length
	}
	return 0
}

type FloatHistogramPair struct {
	// Fields order MUST match promql.HPoint so that we can cast types between them.
	TimestampMs int64           `protobuf:"varint,2,opt,name=timestamp_ms,json=timestampMs,proto3" json:"timestamp_ms,omitempty"`
	Histogram   *FloatHistogram `protobuf:"bytes,1,opt,name=histogram,proto3" json:"histogram,omitempty"`
}

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

var xxx_messageInfo_FloatHistogramPair proto.InternalMessageInfo

func (m *FloatHistogramPair) GetTimestampMs() int64 {
	if m != nil {
		return m.TimestampMs
	}
	return 0
}

func (m *FloatHistogramPair) GetHistogram() *FloatHistogram {
	if m != nil {
		return m.Histogram
	}
	return nil
}

// SampleHistogram is based on https://github.com/prometheus/common/blob/main/model/value_histogram.go
// for compatibility with PromQL API results
// Must keep the same order and type of fields for casting
type SampleHistogram struct {
	Count   float64            `protobuf:"fixed64,1,opt,name=count,proto3" json:"count,omitempty"`
	Sum     float64            `protobuf:"fixed64,2,opt,name=sum,proto3" json:"sum,omitempty"`
	Buckets []*HistogramBucket `protobuf:"bytes,3,rep,name=buckets,proto3" json:"buckets,omitempty"`
}

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

var xxx_messageInfo_SampleHistogram proto.InternalMessageInfo

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

func (m *SampleHistogram) GetSum() float64 {
	if m != nil {
		return m.Sum
	}
	return 0
}

func (m *SampleHistogram) GetBuckets() []*HistogramBucket {
	if m != nil {
		return m.Buckets
	}
	return nil
}

// Must keep the same order and type of fields for casting, see SampleHistogram
type HistogramBucket struct {
	Boundaries int32   `protobuf:"varint,1,opt,name=boundaries,proto3" json:"boundaries,omitempty"`
	Lower      float64 `protobuf:"fixed64,2,opt,name=lower,proto3" json:"lower,omitempty"`
	Upper      float64 `protobuf:"fixed64,3,opt,name=upper,proto3" json:"upper,omitempty"`
	Count      float64 `protobuf:"fixed64,4,opt,name=count,proto3" json:"count,omitempty"`
}

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

var xxx_messageInfo_HistogramBucket proto.InternalMessageInfo

func (m *HistogramBucket) GetBoundaries() int32 {
	if m != nil {
		return m.Boundaries
	}
	return 0
}

func (m *HistogramBucket) GetLower() float64 {
	if m != nil {
		return m.Lower
	}
	return 0
}

func (m *HistogramBucket) GetUpper() float64 {
	if m != nil {
		return m.Upper
	}
	return 0
}

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

// Must keep the same order and type of fields for casting, see SampleHistogram
type SampleHistogramPair struct {
	Timestamp int64            `protobuf:"varint,2,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
	Histogram *SampleHistogram `protobuf:"bytes,1,opt,name=histogram,proto3" json:"histogram,omitempty"`
}

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

var xxx_messageInfo_SampleHistogramPair proto.InternalMessageInfo

func (m *SampleHistogramPair) GetTimestamp() int64 {
	if m != nil {
		return m.Timestamp
	}
	return 0
}

func (m *SampleHistogramPair) GetHistogram() *SampleHistogram {
	if m != nil {
		return m.Histogram
	}
	return nil
}

type QueryResponse struct {
	Status    QueryStatus    `protobuf:"varint,1,opt,name=status,proto3,enum=cortexpb.QueryStatus" json:"status,omitempty"`
	ErrorType QueryErrorType `protobuf:"varint,2,opt,name=error_type,json=errorType,proto3,enum=cortexpb.QueryErrorType" json:"error_type,omitempty"`
	Error     string         `protobuf:"bytes,3,opt,name=error,proto3" json:"error,omitempty"`
	// Types that are valid to be assigned to Data:
	//
	//	*QueryResponse_String_
	//	*QueryResponse_Vector
	//	*QueryResponse_Scalar
	//	*QueryResponse_Matrix
	Data     isQueryResponse_Data `protobuf_oneof:"data"`
	Warnings []string             `protobuf:"bytes,8,rep,name=warnings,proto3" json:"warnings,omitempty"`
	Infos    []string             `protobuf:"bytes,9,rep,name=infos,proto3" json:"infos,omitempty"`
}

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

var xxx_messageInfo_QueryResponse proto.InternalMessageInfo

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

type QueryResponse_String_ struct {
	String_ *StringData `protobuf:"bytes,4,opt,name=string,proto3,oneof" json:"string,omitempty"`
}
type QueryResponse_Vector struct {
	Vector *VectorData `protobuf:"bytes,5,opt,name=vector,proto3,oneof" json:"vector,omitempty"`
}
type QueryResponse_Scalar struct {
	Scalar *ScalarData `protobuf:"bytes,6,opt,name=scalar,proto3,oneof" json:"scalar,omitempty"`
}
type QueryResponse_Matrix struct {
	Matrix *MatrixData `protobuf:"bytes,7,opt,name=matrix,proto3,oneof" json:"matrix,omitempty"`
}

func (*QueryResponse_String_) isQueryResponse_Data() {}
func (*QueryResponse_Vector) isQueryResponse_Data()  {}
func (*QueryResponse_Scalar) isQueryResponse_Data()  {}
func (*QueryResponse_Matrix) isQueryResponse_Data()  {}

func (m *QueryResponse) GetData() isQueryResponse_Data {
	if m != nil {
		return m.Data
	}
	return nil
}

func (m *QueryResponse) GetStatus() QueryStatus {
	if m != nil {
		return m.Status
	}
	return QUERY_STATUS_ERROR
}

func (m *QueryResponse) GetErrorType() QueryErrorType {
	if m != nil {
		return m.ErrorType
	}
	return QUERY_ERROR_TYPE_NONE
}

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

func (m *QueryResponse) GetString_() *StringData {
	if x, ok := m.GetData().(*QueryResponse_String_); ok {
		return x.String_
	}
	return nil
}

func (m *QueryResponse) GetVector() *VectorData {
	if x, ok := m.GetData().(*QueryResponse_Vector); ok {
		return x.Vector
	}
	return nil
}

func (m *QueryResponse) GetScalar() *ScalarData {
	if x, ok := m.GetData().(*QueryResponse_Scalar); ok {
		return x.Scalar
	}
	return nil
}

func (m *QueryResponse) GetMatrix() *MatrixData {
	if x, ok := m.GetData().(*QueryResponse_Matrix); ok {
		return x.Matrix
	}
	return nil
}

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

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

// XXX_OneofWrappers is for the internal use of the proto package.
func (*QueryResponse) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*QueryResponse_String_)(nil),
		(*QueryResponse_Vector)(nil),
		(*QueryResponse_Scalar)(nil),
		(*QueryResponse_Matrix)(nil),
	}
}

type StringData struct {
	Value       string `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
	TimestampMs int64  `protobuf:"varint,2,opt,name=timestamp_ms,json=timestampMs,proto3" json:"timestamp_ms,omitempty"`
}

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

var xxx_messageInfo_StringData proto.InternalMessageInfo

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

func (m *StringData) GetTimestampMs() int64 {
	if m != nil {
		return m.TimestampMs
	}
	return 0
}

type VectorData struct {
	Samples    []VectorSample    `protobuf:"bytes,1,rep,name=samples,proto3" json:"samples"`
	Histograms []VectorHistogram `protobuf:"bytes,2,rep,name=histograms,proto3" json:"histograms"`
}

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

var xxx_messageInfo_VectorData proto.InternalMessageInfo

func (m *VectorData) GetSamples() []VectorSample {
	if m != nil {
		return m.Samples
	}
	return nil
}

func (m *VectorData) GetHistograms() []VectorHistogram {
	if m != nil {
		return m.Histograms
	}
	return nil
}

type VectorSample struct {
	// Why not use a map<...> here? We want to preserve the order of the labels, as labels.Labels expects them to be sorted.
	Metric      []string `protobuf:"bytes,1,rep,name=metric,proto3" json:"metric,omitempty"`
	Value       float64  `protobuf:"fixed64,2,opt,name=value,proto3" json:"value,omitempty"`
	TimestampMs int64    `protobuf:"varint,3,opt,name=timestamp_ms,json=timestampMs,proto3" json:"timestamp_ms,omitempty"`
}

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

var xxx_messageInfo_VectorSample proto.InternalMessageInfo

func (m *VectorSample) GetMetric() []string {
	if m != nil {
		return m.Metric
	}
	return nil
}

func (m *VectorSample) GetValue() float64 {
	if m != nil {
		return m.Value
	}
	return 0
}

func (m *VectorSample) GetTimestampMs() int64 {
	if m != nil {
		return m.TimestampMs
	}
	return 0
}

type VectorHistogram struct {
	// Why not use a map<...> here? We want to preserve the order of the labels, as labels.Labels expects them to be sorted.
	Metric      []string       `protobuf:"bytes,1,rep,name=metric,proto3" json:"metric,omitempty"`
	Histogram   FloatHistogram `protobuf:"bytes,2,opt,name=histogram,proto3" json:"histogram"`
	TimestampMs int64          `protobuf:"varint,3,opt,name=timestamp_ms,json=timestampMs,proto3" json:"timestamp_ms,omitempty"`
}

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

var xxx_messageInfo_VectorHistogram proto.InternalMessageInfo

func (m *VectorHistogram) GetMetric() []string {
	if m != nil {
		return m.Metric
	}
	return nil
}

func (m *VectorHistogram) GetHistogram() FloatHistogram {
	if m != nil {
		return m.Histogram
	}
	return FloatHistogram{}
}

func (m *VectorHistogram) GetTimestampMs() int64 {
	if m != nil {
		return m.TimestampMs
	}
	return 0
}

type ScalarData struct {
	Value       float64 `protobuf:"fixed64,1,opt,name=value,proto3" json:"value,omitempty"`
	TimestampMs int64   `protobuf:"varint,2,opt,name=timestamp_ms,json=timestampMs,proto3" json:"timestamp_ms,omitempty"`
}

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

var xxx_messageInfo_ScalarData proto.InternalMessageInfo

func (m *ScalarData) GetValue() float64 {
	if m != nil {
		return m.Value
	}
	return 0
}

func (m *ScalarData) GetTimestampMs() int64 {
	if m != nil {
		return m.TimestampMs
	}
	return 0
}

type MatrixData struct {
	Series []MatrixSeries `protobuf:"bytes,1,rep,name=series,proto3" json:"series"`
}

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

var xxx_messageInfo_MatrixData proto.InternalMessageInfo

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

type MatrixSeries struct {
	// Why not use a map<...> here? We want to preserve the order of the labels.
	Metric     []string             `protobuf:"bytes,1,rep,name=metric,proto3" json:"metric,omitempty"`
	Samples    []Sample             `protobuf:"bytes,2,rep,name=samples,proto3" json:"samples"`
	Histograms []FloatHistogramPair `protobuf:"bytes,3,rep,name=histograms,proto3" json:"histograms"`
}

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

var xxx_messageInfo_MatrixSeries proto.InternalMessageInfo

func (m *MatrixSeries) GetMetric() []string {
	if m != nil {
		return m.Metric
	}
	return nil
}

func (m *MatrixSeries) GetSamples() []Sample {
	if m != nil {
		return m.Samples
	}
	return nil
}

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

type WriteRequestRW2 struct {
	Symbols    []string        `protobuf:"bytes,4,rep,name=symbols,proto3" json:"symbols,omitempty"`
	Timeseries []TimeSeriesRW2 `protobuf:"bytes,5,rep,name=timeseries,proto3" json:"timeseries"`
}

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

var xxx_messageInfo_WriteRequestRW2 proto.InternalMessageInfo

func (m *WriteRequestRW2) GetSymbols() []string {
	if m != nil {
		return m.Symbols
	}
	return nil
}

func (m *WriteRequestRW2) GetTimeseries() []TimeSeriesRW2 {
	if m != nil {
		return m.Timeseries
	}
	return nil
}

type TimeSeriesRW2 struct {
	// labels_refs is a list of label name-value pair references, encoded
	// as indices to the Request.symbols array. This list's length is always
	// a multiple of two, and the underlying labels should be sorted lexicographically.
	//
	// Note that there might be multiple TimeSeries objects in the same
	// Requests with the same labels e.g. for different exemplars, metadata
	// or created timestamp.
	LabelsRefs []uint32 `protobuf:"varint,1,rep,packed,name=labels_refs,json=labelsRefs,proto3" json:"labels_refs,omitempty"`
	// Timeseries messages can either specify samples or (native) histogram samples
	// (histogram field), but not both. For a typical sender (real-time metric
	// streaming), in healthy cases, there will be only one sample or histogram.
	//
	// Samples and histograms are sorted by timestamp (older first).
	Samples    []Sample    `protobuf:"bytes,2,rep,name=samples,proto3" json:"samples"`
	Histograms []Histogram `protobuf:"bytes,3,rep,name=histograms,proto3" json:"histograms"`
	// exemplars represents an optional set of exemplars attached to this series' samples.
	Exemplars []ExemplarRW2 `protobuf:"bytes,4,rep,name=exemplars,proto3" json:"exemplars"`
	// metadata represents the metadata associated with the given series' samples.
	Metadata MetadataRW2 `protobuf:"bytes,5,opt,name=metadata,proto3" json:"metadata"`
	// created_timestamp represents an optional created timestamp associated with
	// this series' samples in ms format, typically for counter or histogram type
	// metrics. Created timestamp represents the time when the counter started
	// counting (sometimes referred to as start timestamp), which can increase
	// the accuracy of query results.
	//
	// Note that some receivers might require this and in return fail to
	// ingest such samples within the Request.
	//
	// For Go, see github.com/prometheus/prometheus/model/timestamp/timestamp.go
	// for conversion from/to time.Time to Prometheus timestamp.
	//
	// Note that the "optional" keyword is omitted due to
	// https://cloud.google.com/apis/design/design_patterns.md#optional_primitive_fields
	// Zero value means value not set. If you need to use exactly zero value for
	// the timestamp, use 1 millisecond before or after.
	CreatedTimestamp int64 `protobuf:"varint,6,opt,name=created_timestamp,json=createdTimestamp,proto3" json:"created_timestamp,omitempty"`
}

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

var xxx_messageInfo_TimeSeriesRW2 proto.InternalMessageInfo

func (m *TimeSeriesRW2) GetLabelsRefs() []uint32 {
	if m != nil {
		return m.LabelsRefs
	}
	return nil
}

func (m *TimeSeriesRW2) GetSamples() []Sample {
	if m != nil {
		return m.Samples
	}
	return nil
}

func (m *TimeSeriesRW2) GetHistograms() []Histogram {
	if m != nil {
		return m.Histograms
	}
	return nil
}

func (m *TimeSeriesRW2) GetExemplars() []ExemplarRW2 {
	if m != nil {
		return m.Exemplars
	}
	return nil
}

func (m *TimeSeriesRW2) GetMetadata() MetadataRW2 {
	if m != nil {
		return m.Metadata
	}
	return MetadataRW2{}
}

func (m *TimeSeriesRW2) GetCreatedTimestamp() int64 {
	if m != nil {
		return m.CreatedTimestamp
	}
	return 0
}

type ExemplarRW2 struct {
	// labels_refs is an optional list of label name-value pair references, encoded
	// as indices to the Request.symbols array. This list's len is always
	// a multiple of 2, and the underlying labels should be sorted lexicographically.
	// If the exemplar references a trace it should use the `trace_id` label name, as a best practice.
	LabelsRefs []uint32 `protobuf:"varint,1,rep,packed,name=labels_refs,json=labelsRefs,proto3" json:"labels_refs,omitempty"`
	// value represents an exact example value. This can be useful when the exemplar
	// is attached to a histogram, which only gives an estimated value through buckets.
	Value float64 `protobuf:"fixed64,2,opt,name=value,proto3" json:"value,omitempty"`
	// timestamp represents the timestamp of the exemplar in ms.
	//
	// For Go, see github.com/prometheus/prometheus/model/timestamp/timestamp.go
	// for conversion from/to time.Time to Prometheus timestamp.
	Timestamp int64 `protobuf:"varint,3,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
}

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

var xxx_messageInfo_ExemplarRW2 proto.InternalMessageInfo

func (m *ExemplarRW2) GetLabelsRefs() []uint32 {
	if m != nil {
		return m.LabelsRefs
	}
	return nil
}

func (m *ExemplarRW2) GetValue() float64 {
	if m != nil {
		return m.Value
	}
	return 0
}

func (m *ExemplarRW2) GetTimestamp() int64 {
	if m != nil {
		return m.Timestamp
	}
	return 0
}

type MetadataRW2 struct {
	Type MetadataRW2_MetricType `protobuf:"varint,1,opt,name=type,proto3,enum=cortexpb.MetadataRW2_MetricType" json:"type,omitempty"`
	// help_ref is a reference to the Request.symbols array representing help
	// text for the metric. Help is optional, reference should point to an empty string in
	// such a case.
	HelpRef uint32 `protobuf:"varint,3,opt,name=help_ref,json=helpRef,proto3" json:"help_ref,omitempty"`
	// unit_ref is a reference to the Request.symbols array representing a unit
	// for the metric. Unit is optional, reference should point to an empty string in
	// such a case.
	UnitRef uint32 `protobuf:"varint,4,opt,name=unit_ref,json=unitRef,proto3" json:"unit_ref,omitempty"`
}

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

var xxx_messageInfo_MetadataRW2 proto.InternalMessageInfo

func (m *MetadataRW2) GetType() MetadataRW2_MetricType {
	if m != nil {
		return m.Type
	}
	return METRIC_TYPE_UNSPECIFIED
}

func (m *MetadataRW2) GetHelpRef() uint32 {
	if m != nil {
		return m.HelpRef
	}
	return 0
}

func (m *MetadataRW2) GetUnitRef() uint32 {
	if m != nil {
		return m.UnitRef
	}
	return 0
}

func init() {
	proto.RegisterEnum("cortexpb.ErrorCause", ErrorCause_name, ErrorCause_value)
	proto.RegisterEnum("cortexpb.QueryStatus", QueryStatus_name, QueryStatus_value)
	proto.RegisterEnum("cortexpb.QueryErrorType", QueryErrorType_name, QueryErrorType_value)
	proto.RegisterEnum("cortexpb.WriteRequest_SourceEnum", WriteRequest_SourceEnum_name, WriteRequest_SourceEnum_value)
	proto.RegisterEnum("cortexpb.MetricMetadata_MetricType", MetricMetadata_MetricType_name, MetricMetadata_MetricType_value)
	proto.RegisterEnum("cortexpb.Histogram_ResetHint", Histogram_ResetHint_name, Histogram_ResetHint_value)
	proto.RegisterEnum("cortexpb.MetadataRW2_MetricType", MetadataRW2_MetricType_name, MetadataRW2_MetricType_value)
	proto.RegisterType((*WriteRequest)(nil), "cortexpb.WriteRequest")
	proto.RegisterType((*WriteResponse)(nil), "cortexpb.WriteResponse")
	proto.RegisterType((*ErrorDetails)(nil), "cortexpb.ErrorDetails")
	proto.RegisterType((*TimeSeries)(nil), "cortexpb.TimeSeries")
	proto.RegisterType((*LabelPair)(nil), "cortexpb.LabelPair")
	proto.RegisterType((*Sample)(nil), "cortexpb.Sample")
	proto.RegisterType((*MetricMetadata)(nil), "cortexpb.MetricMetadata")
	proto.RegisterType((*Metric)(nil), "cortexpb.Metric")
	proto.RegisterType((*Exemplar)(nil), "cortexpb.Exemplar")
	proto.RegisterType((*Histogram)(nil), "cortexpb.Histogram")
	proto.RegisterType((*FloatHistogram)(nil), "cortexpb.FloatHistogram")
	proto.RegisterType((*BucketSpan)(nil), "cortexpb.BucketSpan")
	proto.RegisterType((*FloatHistogramPair)(nil), "cortexpb.FloatHistogramPair")
	proto.RegisterType((*SampleHistogram)(nil), "cortexpb.SampleHistogram")
	proto.RegisterType((*HistogramBucket)(nil), "cortexpb.HistogramBucket")
	proto.RegisterType((*SampleHistogramPair)(nil), "cortexpb.SampleHistogramPair")
	proto.RegisterType((*QueryResponse)(nil), "cortexpb.QueryResponse")
	proto.RegisterType((*StringData)(nil), "cortexpb.StringData")
	proto.RegisterType((*VectorData)(nil), "cortexpb.VectorData")
	proto.RegisterType((*VectorSample)(nil), "cortexpb.VectorSample")
	proto.RegisterType((*VectorHistogram)(nil), "cortexpb.VectorHistogram")
	proto.RegisterType((*ScalarData)(nil), "cortexpb.ScalarData")
	proto.RegisterType((*MatrixData)(nil), "cortexpb.MatrixData")
	proto.RegisterType((*MatrixSeries)(nil), "cortexpb.MatrixSeries")
	proto.RegisterType((*WriteRequestRW2)(nil), "cortexpb.WriteRequestRW2")
	proto.RegisterType((*TimeSeriesRW2)(nil), "cortexpb.TimeSeriesRW2")
	proto.RegisterType((*ExemplarRW2)(nil), "cortexpb.ExemplarRW2")
	proto.RegisterType((*MetadataRW2)(nil), "cortexpb.MetadataRW2")
}

func init() { proto.RegisterFile("mimir.proto", fileDescriptor_86d4d7485f544059) }

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

func (x ErrorCause) String() string {
	s, ok := ErrorCause_name[int32(x)]
	if ok {
		return s
	}
	return strconv.Itoa(int(x))
}
func (x QueryStatus) String() string {
	s, ok := QueryStatus_name[int32(x)]
	if ok {
		return s
	}
	return strconv.Itoa(int(x))
}
func (x QueryErrorType) String() string {
	s, ok := QueryErrorType_name[int32(x)]
	if ok {
		return s
	}
	return strconv.Itoa(int(x))
}
func (x WriteRequest_SourceEnum) String() string {
	s, ok := WriteRequest_SourceEnum_name[int32(x)]
	if ok {
		return s
	}
	return strconv.Itoa(int(x))
}
func (x MetricMetadata_MetricType) String() string {
	s, ok := MetricMetadata_MetricType_name[int32(x)]
	if ok {
		return s
	}
	return strconv.Itoa(int(x))
}
func (x Histogram_ResetHint) String() string {
	s, ok := Histogram_ResetHint_name[int32(x)]
	if ok {
		return s
	}
	return strconv.Itoa(int(x))
}
func (x MetadataRW2_MetricType) String() string {
	s, ok := MetadataRW2_MetricType_name[int32(x)]
	if ok {
		return s
	}
	return strconv.Itoa(int(x))
}
func (this *WriteRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*WriteRequest)
	if !ok {
		that2, ok := that.(WriteRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.Timeseries) != len(that1.Timeseries) {
		return false
	}
	for i := range this.Timeseries {
		if !this.Timeseries[i].Equal(that1.Timeseries[i]) {
			return false
		}
	}
	if this.Source != that1.Source {
		return false
	}
	if len(this.Metadata) != len(that1.Metadata) {
		return false
	}
	for i := range this.Metadata {
		if !this.Metadata[i].Equal(that1.Metadata[i]) {
			return false
		}
	}
	if len(this.SymbolsRW2) != len(that1.SymbolsRW2) {
		return false
	}
	for i := range this.SymbolsRW2 {
		if this.SymbolsRW2[i] != that1.SymbolsRW2[i] {
			return false
		}
	}
	if len(this.TimeseriesRW2) != len(that1.TimeseriesRW2) {
		return false
	}
	for i := range this.TimeseriesRW2 {
		if !this.TimeseriesRW2[i].Equal(&that1.TimeseriesRW2[i]) {
			return false
		}
	}
	if this.SkipLabelValidation != that1.SkipLabelValidation {
		return false
	}
	if this.SkipLabelCountValidation != that1.SkipLabelCountValidation {
		return false
	}
	return true
}
func (this *WriteResponse) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

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

	that1, ok := that.(*ErrorDetails)
	if !ok {
		that2, ok := that.(ErrorDetails)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Cause != that1.Cause {
		return false
	}
	if this.Soft != that1.Soft {
		return false
	}
	if this.RejectedSamples != that1.RejectedSamples {
		return false
	}
	return true
}
func (this *TimeSeries) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*TimeSeries)
	if !ok {
		that2, ok := that.(TimeSeries)
		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 len(this.Samples) != len(that1.Samples) {
		return false
	}
	for i := range this.Samples {
		if !this.Samples[i].Equal(&that1.Samples[i]) {
			return false
		}
	}
	if len(this.Exemplars) != len(that1.Exemplars) {
		return false
	}
	for i := range this.Exemplars {
		if !this.Exemplars[i].Equal(&that1.Exemplars[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
		}
	}
	if this.CreatedTimestamp != that1.CreatedTimestamp {
		return false
	}
	return true
}
func (this *LabelPair) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*LabelPair)
	if !ok {
		that2, ok := that.(LabelPair)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !bytes.Equal(this.Name, that1.Name) {
		return false
	}
	if !bytes.Equal(this.Value, that1.Value) {
		return false
	}
	return true
}
func (this *Sample) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

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

	that1, ok := that.(*MetricMetadata)
	if !ok {
		that2, ok := that.(MetricMetadata)
		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.MetricFamilyName != that1.MetricFamilyName {
		return false
	}
	if this.Help != that1.Help {
		return false
	}
	if this.Unit != that1.Unit {
		return false
	}
	return true
}
func (this *Metric) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

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

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

	that1, ok := that.(*Histogram)
	if !ok {
		that2, ok := that.(Histogram)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if that1.Count == nil {
		if this.Count != nil {
			return false
		}
	} else if this.Count == nil {
		return false
	} else if !this.Count.Equal(that1.Count) {
		return false
	}
	if this.Sum != that1.Sum {
		return false
	}
	if this.Schema != that1.Schema {
		return false
	}
	if this.ZeroThreshold != that1.ZeroThreshold {
		return false
	}
	if that1.ZeroCount == nil {
		if this.ZeroCount != nil {
			return false
		}
	} else if this.ZeroCount == nil {
		return false
	} else if !this.ZeroCount.Equal(that1.ZeroCount) {
		return false
	}
	if len(this.NegativeSpans) != len(that1.NegativeSpans) {
		return false
	}
	for i := range this.NegativeSpans {
		if !this.NegativeSpans[i].Equal(&that1.NegativeSpans[i]) {
			return false
		}
	}
	if len(this.NegativeDeltas) != len(that1.NegativeDeltas) {
		return false
	}
	for i := range this.NegativeDeltas {
		if this.NegativeDeltas[i] != that1.NegativeDeltas[i] {
			return false
		}
	}
	if len(this.NegativeCounts) != len(that1.NegativeCounts) {
		return false
	}
	for i := range this.NegativeCounts {
		if this.NegativeCounts[i] != that1.NegativeCounts[i] {
			return false
		}
	}
	if len(this.PositiveSpans) != len(that1.PositiveSpans) {
		return false
	}
	for i := range this.PositiveSpans {
		if !this.PositiveSpans[i].Equal(&that1.PositiveSpans[i]) {
			return false
		}
	}
	if len(this.PositiveDeltas) != len(that1.PositiveDeltas) {
		return false
	}
	for i := range this.PositiveDeltas {
		if this.PositiveDeltas[i] != that1.PositiveDeltas[i] {
			return false
		}
	}
	if len(this.PositiveCounts) != len(that1.PositiveCounts) {
		return false
	}
	for i := range this.PositiveCounts {
		if this.PositiveCounts[i] != that1.PositiveCounts[i] {
			return false
		}
	}
	if this.ResetHint != that1.ResetHint {
		return false
	}
	if this.Timestamp != that1.Timestamp {
		return false
	}
	if len(this.CustomValues) != len(that1.CustomValues) {
		return false
	}
	for i := range this.CustomValues {
		if this.CustomValues[i] != that1.CustomValues[i] {
			return false
		}
	}
	return true
}
func (this *Histogram_CountInt) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

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

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

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

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

	that1, ok := that.(*FloatHistogram)
	if !ok {
		that2, ok := that.(FloatHistogram)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.CounterResetHint != that1.CounterResetHint {
		return false
	}
	if this.Schema != that1.Schema {
		return false
	}
	if this.ZeroThreshold != that1.ZeroThreshold {
		return false
	}
	if this.ZeroCount != that1.ZeroCount {
		return false
	}
	if this.Count != that1.Count {
		return false
	}
	if this.Sum != that1.Sum {
		return false
	}
	if len(this.PositiveSpans) != len(that1.PositiveSpans) {
		return false
	}
	for i := range this.PositiveSpans {
		if !this.PositiveSpans[i].Equal(&that1.PositiveSpans[i]) {
			return false
		}
	}
	if len(this.NegativeSpans) != len(that1.NegativeSpans) {
		return false
	}
	for i := range this.NegativeSpans {
		if !this.NegativeSpans[i].Equal(&that1.NegativeSpans[i]) {
			return false
		}
	}
	if len(this.PositiveBuckets) != len(that1.PositiveBuckets) {
		return false
	}
	for i := range this.PositiveBuckets {
		if this.PositiveBuckets[i] != that1.PositiveBuckets[i] {
			return false
		}
	}
	if len(this.NegativeBuckets) != len(that1.NegativeBuckets) {
		return false
	}
	for i := range this.NegativeBuckets {
		if this.NegativeBuckets[i] != that1.NegativeBuckets[i] {
			return false
		}
	}
	if len(this.CustomValues) != len(that1.CustomValues) {
		return false
	}
	for i := range this.CustomValues {
		if this.CustomValues[i] != that1.CustomValues[i] {
			return false
		}
	}
	return true
}
func (this *BucketSpan) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*BucketSpan)
	if !ok {
		that2, ok := that.(BucketSpan)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Offset != that1.Offset {
		return false
	}
	if this.Length != that1.Length {
		return false
	}
	return true
}
func (this *FloatHistogramPair) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*FloatHistogramPair)
	if !ok {
		that2, ok := that.(FloatHistogramPair)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.TimestampMs != that1.TimestampMs {
		return false
	}
	if !this.Histogram.Equal(that1.Histogram) {
		return false
	}
	return true
}
func (this *SampleHistogram) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

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

	that1, ok := that.(*HistogramBucket)
	if !ok {
		that2, ok := that.(HistogramBucket)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Boundaries != that1.Boundaries {
		return false
	}
	if this.Lower != that1.Lower {
		return false
	}
	if this.Upper != that1.Upper {
		return false
	}
	if this.Count != that1.Count {
		return false
	}
	return true
}
func (this *SampleHistogramPair) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*SampleHistogramPair)
	if !ok {
		that2, ok := that.(SampleHistogramPair)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Timestamp != that1.Timestamp {
		return false
	}
	if !this.Histogram.Equal(that1.Histogram) {
		return false
	}
	return true
}
func (this *QueryResponse) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*QueryResponse)
	if !ok {
		that2, ok := that.(QueryResponse)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Status != that1.Status {
		return false
	}
	if this.ErrorType != that1.ErrorType {
		return false
	}
	if this.Error != that1.Error {
		return false
	}
	if that1.Data == nil {
		if this.Data != nil {
			return false
		}
	} else if this.Data == nil {
		return false
	} else if !this.Data.Equal(that1.Data) {
		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 *QueryResponse_String_) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

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

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

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

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

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

	that1, ok := that.(*VectorData)
	if !ok {
		that2, ok := that.(VectorData)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.Samples) != len(that1.Samples) {
		return false
	}
	for i := range this.Samples {
		if !this.Samples[i].Equal(&that1.Samples[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 *VectorSample) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

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

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

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

	that1, ok := that.(*MatrixData)
	if !ok {
		that2, ok := that.(MatrixData)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		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 *MatrixSeries) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*MatrixSeries)
	if !ok {
		that2, ok := that.(MatrixSeries)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.Metric) != len(that1.Metric) {
		return false
	}
	for i := range this.Metric {
		if this.Metric[i] != that1.Metric[i] {
			return false
		}
	}
	if len(this.Samples) != len(that1.Samples) {
		return false
	}
	for i := range this.Samples {
		if !this.Samples[i].Equal(&that1.Samples[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 *WriteRequestRW2) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

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

	that1, ok := that.(*TimeSeriesRW2)
	if !ok {
		that2, ok := that.(TimeSeriesRW2)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.LabelsRefs) != len(that1.LabelsRefs) {
		return false
	}
	for i := range this.LabelsRefs {
		if this.LabelsRefs[i] != that1.LabelsRefs[i] {
			return false
		}
	}
	if len(this.Samples) != len(that1.Samples) {
		return false
	}
	for i := range this.Samples {
		if !this.Samples[i].Equal(&that1.Samples[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
		}
	}
	if len(this.Exemplars) != len(that1.Exemplars) {
		return false
	}
	for i := range this.Exemplars {
		if !this.Exemplars[i].Equal(&that1.Exemplars[i]) {
			return false
		}
	}
	if !this.Metadata.Equal(&that1.Metadata) {
		return false
	}
	if this.CreatedTimestamp != that1.CreatedTimestamp {
		return false
	}
	return true
}
func (this *ExemplarRW2) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

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

	that1, ok := that.(*MetadataRW2)
	if !ok {
		that2, ok := that.(MetadataRW2)
		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.HelpRef != that1.HelpRef {
		return false
	}
	if this.UnitRef != that1.UnitRef {
		return false
	}
	return true
}
func (this *WriteRequest) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 11)
	s = append(s, "&mimirpb.WriteRequest{")
	s = append(s, "Timeseries: "+fmt.Sprintf("%#v", this.Timeseries)+",\n")
	s = append(s, "Source: "+fmt.Sprintf("%#v", this.Source)+",\n")
	if this.Metadata != nil {
		s = append(s, "Metadata: "+fmt.Sprintf("%#v", this.Metadata)+",\n")
	}
	s = append(s, "SymbolsRW2: "+fmt.Sprintf("%#v", this.SymbolsRW2)+",\n")
	if this.TimeseriesRW2 != nil {
		vs := make([]TimeSeriesRW2, len(this.TimeseriesRW2))
		for i := range vs {
			vs[i] = this.TimeseriesRW2[i]
		}
		s = append(s, "TimeseriesRW2: "+fmt.Sprintf("%#v", vs)+",\n")
	}
	s = append(s, "SkipLabelValidation: "+fmt.Sprintf("%#v", this.SkipLabelValidation)+",\n")
	s = append(s, "SkipLabelCountValidation: "+fmt.Sprintf("%#v", this.SkipLabelCountValidation)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *WriteResponse) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 4)
	s = append(s, "&mimirpb.WriteResponse{")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *ErrorDetails) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&mimirpb.ErrorDetails{")
	s = append(s, "Cause: "+fmt.Sprintf("%#v", this.Cause)+",\n")
	s = append(s, "Soft: "+fmt.Sprintf("%#v", this.Soft)+",\n")
	s = append(s, "RejectedSamples: "+fmt.Sprintf("%#v", this.RejectedSamples)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *TimeSeries) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 9)
	s = append(s, "&mimirpb.TimeSeries{")
	s = append(s, "Labels: "+fmt.Sprintf("%#v", this.Labels)+",\n")
	if this.Samples != nil {
		vs := make([]Sample, len(this.Samples))
		for i := range vs {
			vs[i] = this.Samples[i]
		}
		s = append(s, "Samples: "+fmt.Sprintf("%#v", vs)+",\n")
	}
	if this.Exemplars != nil {
		vs := make([]Exemplar, len(this.Exemplars))
		for i := range vs {
			vs[i] = this.Exemplars[i]
		}
		s = append(s, "Exemplars: "+fmt.Sprintf("%#v", vs)+",\n")
	}
	if this.Histograms != nil {
		vs := make([]Histogram, len(this.Histograms))
		for i := range vs {
			vs[i] = this.Histograms[i]
		}
		s = append(s, "Histograms: "+fmt.Sprintf("%#v", vs)+",\n")
	}
	s = append(s, "CreatedTimestamp: "+fmt.Sprintf("%#v", this.CreatedTimestamp)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *LabelPair) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&mimirpb.LabelPair{")
	s = append(s, "Name: "+fmt.Sprintf("%#v", this.Name)+",\n")
	s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Sample) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&mimirpb.Sample{")
	s = append(s, "TimestampMs: "+fmt.Sprintf("%#v", this.TimestampMs)+",\n")
	s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *MetricMetadata) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 8)
	s = append(s, "&mimirpb.MetricMetadata{")
	s = append(s, "Type: "+fmt.Sprintf("%#v", this.Type)+",\n")
	s = append(s, "MetricFamilyName: "+fmt.Sprintf("%#v", this.MetricFamilyName)+",\n")
	s = append(s, "Help: "+fmt.Sprintf("%#v", this.Help)+",\n")
	s = append(s, "Unit: "+fmt.Sprintf("%#v", this.Unit)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Metric) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&mimirpb.Metric{")
	s = append(s, "Labels: "+fmt.Sprintf("%#v", this.Labels)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Exemplar) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&mimirpb.Exemplar{")
	s = append(s, "Labels: "+fmt.Sprintf("%#v", this.Labels)+",\n")
	s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n")
	s = append(s, "TimestampMs: "+fmt.Sprintf("%#v", this.TimestampMs)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Histogram) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 20)
	s = append(s, "&mimirpb.Histogram{")
	if this.Count != nil {
		s = append(s, "Count: "+fmt.Sprintf("%#v", this.Count)+",\n")
	}
	s = append(s, "Sum: "+fmt.Sprintf("%#v", this.Sum)+",\n")
	s = append(s, "Schema: "+fmt.Sprintf("%#v", this.Schema)+",\n")
	s = append(s, "ZeroThreshold: "+fmt.Sprintf("%#v", this.ZeroThreshold)+",\n")
	if this.ZeroCount != nil {
		s = append(s, "ZeroCount: "+fmt.Sprintf("%#v", this.ZeroCount)+",\n")
	}
	if this.NegativeSpans != nil {
		vs := make([]BucketSpan, len(this.NegativeSpans))
		for i := range vs {
			vs[i] = this.NegativeSpans[i]
		}
		s = append(s, "NegativeSpans: "+fmt.Sprintf("%#v", vs)+",\n")
	}
	s = append(s, "NegativeDeltas: "+fmt.Sprintf("%#v", this.NegativeDeltas)+",\n")
	s = append(s, "NegativeCounts: "+fmt.Sprintf("%#v", this.NegativeCounts)+",\n")
	if this.PositiveSpans != nil {
		vs := make([]BucketSpan, len(this.PositiveSpans))
		for i := range vs {
			vs[i] = this.PositiveSpans[i]
		}
		s = append(s, "PositiveSpans: "+fmt.Sprintf("%#v", vs)+",\n")
	}
	s = append(s, "PositiveDeltas: "+fmt.Sprintf("%#v", this.PositiveDeltas)+",\n")
	s = append(s, "PositiveCounts: "+fmt.Sprintf("%#v", this.PositiveCounts)+",\n")
	s = append(s, "ResetHint: "+fmt.Sprintf("%#v", this.ResetHint)+",\n")
	s = append(s, "Timestamp: "+fmt.Sprintf("%#v", this.Timestamp)+",\n")
	s = append(s, "CustomValues: "+fmt.Sprintf("%#v", this.CustomValues)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Histogram_CountInt) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&mimirpb.Histogram_CountInt{` +
		`CountInt:` + fmt.Sprintf("%#v", this.CountInt) + `}`}, ", ")
	return s
}
func (this *Histogram_CountFloat) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&mimirpb.Histogram_CountFloat{` +
		`CountFloat:` + fmt.Sprintf("%#v", this.CountFloat) + `}`}, ", ")
	return s
}
func (this *Histogram_ZeroCountInt) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&mimirpb.Histogram_ZeroCountInt{` +
		`ZeroCountInt:` + fmt.Sprintf("%#v", this.ZeroCountInt) + `}`}, ", ")
	return s
}
func (this *Histogram_ZeroCountFloat) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&mimirpb.Histogram_ZeroCountFloat{` +
		`ZeroCountFloat:` + fmt.Sprintf("%#v", this.ZeroCountFloat) + `}`}, ", ")
	return s
}
func (this *FloatHistogram) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 15)
	s = append(s, "&mimirpb.FloatHistogram{")
	s = append(s, "CounterResetHint: "+fmt.Sprintf("%#v", this.CounterResetHint)+",\n")
	s = append(s, "Schema: "+fmt.Sprintf("%#v", this.Schema)+",\n")
	s = append(s, "ZeroThreshold: "+fmt.Sprintf("%#v", this.ZeroThreshold)+",\n")
	s = append(s, "ZeroCount: "+fmt.Sprintf("%#v", this.ZeroCount)+",\n")
	s = append(s, "Count: "+fmt.Sprintf("%#v", this.Count)+",\n")
	s = append(s, "Sum: "+fmt.Sprintf("%#v", this.Sum)+",\n")
	if this.PositiveSpans != nil {
		vs := make([]BucketSpan, len(this.PositiveSpans))
		for i := range vs {
			vs[i] = this.PositiveSpans[i]
		}
		s = append(s, "PositiveSpans: "+fmt.Sprintf("%#v", vs)+",\n")
	}
	if this.NegativeSpans != nil {
		vs := make([]BucketSpan, len(this.NegativeSpans))
		for i := range vs {
			vs[i] = this.NegativeSpans[i]
		}
		s = append(s, "NegativeSpans: "+fmt.Sprintf("%#v", vs)+",\n")
	}
	s = append(s, "PositiveBuckets: "+fmt.Sprintf("%#v", this.PositiveBuckets)+",\n")
	s = append(s, "NegativeBuckets: "+fmt.Sprintf("%#v", this.NegativeBuckets)+",\n")
	s = append(s, "CustomValues: "+fmt.Sprintf("%#v", this.CustomValues)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *BucketSpan) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&mimirpb.BucketSpan{")
	s = append(s, "Offset: "+fmt.Sprintf("%#v", this.Offset)+",\n")
	s = append(s, "Length: "+fmt.Sprintf("%#v", this.Length)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *FloatHistogramPair) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&mimirpb.FloatHistogramPair{")
	s = append(s, "TimestampMs: "+fmt.Sprintf("%#v", this.TimestampMs)+",\n")
	if this.Histogram != nil {
		s = append(s, "Histogram: "+fmt.Sprintf("%#v", this.Histogram)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *SampleHistogram) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&mimirpb.SampleHistogram{")
	s = append(s, "Count: "+fmt.Sprintf("%#v", this.Count)+",\n")
	s = append(s, "Sum: "+fmt.Sprintf("%#v", this.Sum)+",\n")
	if this.Buckets != nil {
		s = append(s, "Buckets: "+fmt.Sprintf("%#v", this.Buckets)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *HistogramBucket) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 8)
	s = append(s, "&mimirpb.HistogramBucket{")
	s = append(s, "Boundaries: "+fmt.Sprintf("%#v", this.Boundaries)+",\n")
	s = append(s, "Lower: "+fmt.Sprintf("%#v", this.Lower)+",\n")
	s = append(s, "Upper: "+fmt.Sprintf("%#v", this.Upper)+",\n")
	s = append(s, "Count: "+fmt.Sprintf("%#v", this.Count)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *SampleHistogramPair) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&mimirpb.SampleHistogramPair{")
	s = append(s, "Timestamp: "+fmt.Sprintf("%#v", this.Timestamp)+",\n")
	if this.Histogram != nil {
		s = append(s, "Histogram: "+fmt.Sprintf("%#v", this.Histogram)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *QueryResponse) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 13)
	s = append(s, "&mimirpb.QueryResponse{")
	s = append(s, "Status: "+fmt.Sprintf("%#v", this.Status)+",\n")
	s = append(s, "ErrorType: "+fmt.Sprintf("%#v", this.ErrorType)+",\n")
	s = append(s, "Error: "+fmt.Sprintf("%#v", this.Error)+",\n")
	if this.Data != nil {
		s = append(s, "Data: "+fmt.Sprintf("%#v", this.Data)+",\n")
	}
	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 (this *QueryResponse_String_) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&mimirpb.QueryResponse_String_{` +
		`String_:` + fmt.Sprintf("%#v", this.String_) + `}`}, ", ")
	return s
}
func (this *QueryResponse_Vector) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&mimirpb.QueryResponse_Vector{` +
		`Vector:` + fmt.Sprintf("%#v", this.Vector) + `}`}, ", ")
	return s
}
func (this *QueryResponse_Scalar) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&mimirpb.QueryResponse_Scalar{` +
		`Scalar:` + fmt.Sprintf("%#v", this.Scalar) + `}`}, ", ")
	return s
}
func (this *QueryResponse_Matrix) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&mimirpb.QueryResponse_Matrix{` +
		`Matrix:` + fmt.Sprintf("%#v", this.Matrix) + `}`}, ", ")
	return s
}
func (this *StringData) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&mimirpb.StringData{")
	s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n")
	s = append(s, "TimestampMs: "+fmt.Sprintf("%#v", this.TimestampMs)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *VectorData) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&mimirpb.VectorData{")
	if this.Samples != nil {
		vs := make([]VectorSample, len(this.Samples))
		for i := range vs {
			vs[i] = this.Samples[i]
		}
		s = append(s, "Samples: "+fmt.Sprintf("%#v", vs)+",\n")
	}
	if this.Histograms != nil {
		vs := make([]VectorHistogram, 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 *VectorSample) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&mimirpb.VectorSample{")
	s = append(s, "Metric: "+fmt.Sprintf("%#v", this.Metric)+",\n")
	s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n")
	s = append(s, "TimestampMs: "+fmt.Sprintf("%#v", this.TimestampMs)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *VectorHistogram) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&mimirpb.VectorHistogram{")
	s = append(s, "Metric: "+fmt.Sprintf("%#v", this.Metric)+",\n")
	s = append(s, "Histogram: "+strings.Replace(this.Histogram.GoString(), `&`, ``, 1)+",\n")
	s = append(s, "TimestampMs: "+fmt.Sprintf("%#v", this.TimestampMs)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *ScalarData) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&mimirpb.ScalarData{")
	s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n")
	s = append(s, "TimestampMs: "+fmt.Sprintf("%#v", this.TimestampMs)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *MatrixData) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&mimirpb.MatrixData{")
	if this.Series != nil {
		vs := make([]MatrixSeries, 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 *MatrixSeries) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&mimirpb.MatrixSeries{")
	s = append(s, "Metric: "+fmt.Sprintf("%#v", this.Metric)+",\n")
	if this.Samples != nil {
		vs := make([]Sample, len(this.Samples))
		for i := range vs {
			vs[i] = this.Samples[i]
		}
		s = append(s, "Samples: "+fmt.Sprintf("%#v", vs)+",\n")
	}
	if this.Histograms != nil {
		vs := make([]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 *WriteRequestRW2) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&mimirpb.WriteRequestRW2{")
	s = append(s, "Symbols: "+fmt.Sprintf("%#v", this.Symbols)+",\n")
	if this.Timeseries != nil {
		vs := make([]TimeSeriesRW2, len(this.Timeseries))
		for i := range vs {
			vs[i] = this.Timeseries[i]
		}
		s = append(s, "Timeseries: "+fmt.Sprintf("%#v", vs)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *TimeSeriesRW2) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 10)
	s = append(s, "&mimirpb.TimeSeriesRW2{")
	s = append(s, "LabelsRefs: "+fmt.Sprintf("%#v", this.LabelsRefs)+",\n")
	if this.Samples != nil {
		vs := make([]Sample, len(this.Samples))
		for i := range vs {
			vs[i] = this.Samples[i]
		}
		s = append(s, "Samples: "+fmt.Sprintf("%#v", vs)+",\n")
	}
	if this.Histograms != nil {
		vs := make([]Histogram, len(this.Histograms))
		for i := range vs {
			vs[i] = this.Histograms[i]
		}
		s = append(s, "Histograms: "+fmt.Sprintf("%#v", vs)+",\n")
	}
	if this.Exemplars != nil {
		vs := make([]ExemplarRW2, len(this.Exemplars))
		for i := range vs {
			vs[i] = this.Exemplars[i]
		}
		s = append(s, "Exemplars: "+fmt.Sprintf("%#v", vs)+",\n")
	}
	s = append(s, "Metadata: "+strings.Replace(this.Metadata.GoString(), `&`, ``, 1)+",\n")
	s = append(s, "CreatedTimestamp: "+fmt.Sprintf("%#v", this.CreatedTimestamp)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *ExemplarRW2) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&mimirpb.ExemplarRW2{")
	s = append(s, "LabelsRefs: "+fmt.Sprintf("%#v", this.LabelsRefs)+",\n")
	s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n")
	s = append(s, "Timestamp: "+fmt.Sprintf("%#v", this.Timestamp)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *MetadataRW2) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&mimirpb.MetadataRW2{")
	s = append(s, "Type: "+fmt.Sprintf("%#v", this.Type)+",\n")
	s = append(s, "HelpRef: "+fmt.Sprintf("%#v", this.HelpRef)+",\n")
	s = append(s, "UnitRef: "+fmt.Sprintf("%#v", this.UnitRef)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func valueToGoStringMimir(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 *WriteRequest) 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 *WriteRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *WriteRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.SkipLabelCountValidation {
		i--
		if m.SkipLabelCountValidation {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x3e
		i--
		dAtA[i] = 0xc8
	}
	if m.SkipLabelValidation {
		i--
		if m.SkipLabelValidation {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x3e
		i--
		dAtA[i] = 0xc0
	}
	if len(m.TimeseriesRW2) > 0 {
		for iNdEx := len(m.TimeseriesRW2) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.TimeseriesRW2[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintMimir(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x2a
		}
	}
	if len(m.SymbolsRW2) > 0 {
		for iNdEx := len(m.SymbolsRW2) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.SymbolsRW2[iNdEx])
			copy(dAtA[i:], m.SymbolsRW2[iNdEx])
			i = encodeVarintMimir(dAtA, i, uint64(len(m.SymbolsRW2[iNdEx])))
			i--
			dAtA[i] = 0x22
		}
	}
	if len(m.Metadata) > 0 {
		for iNdEx := len(m.Metadata) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Metadata[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintMimir(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.Source != 0 {
		i = encodeVarintMimir(dAtA, i, uint64(m.Source))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Timeseries) > 0 {
		for iNdEx := len(m.Timeseries) - 1; iNdEx >= 0; iNdEx-- {
			{
				size := m.Timeseries[iNdEx].Size()
				i -= size
				if _, err := m.Timeseries[iNdEx].MarshalTo(dAtA[i:]); err != nil {
					return 0, err
				}
				i = encodeVarintMimir(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

func (m *WriteResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

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

func (m *ErrorDetails) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.RejectedSamples != 0 {
		i = encodeVarintMimir(dAtA, i, uint64(m.RejectedSamples))
		i--
		dAtA[i] = 0x18
	}
	if m.Soft {
		i--
		if m.Soft {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x10
	}
	if m.Cause != 0 {
		i = encodeVarintMimir(dAtA, i, uint64(m.Cause))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *TimeSeries) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.CreatedTimestamp != 0 {
		i = encodeVarintMimir(dAtA, i, uint64(m.CreatedTimestamp))
		i--
		dAtA[i] = 0x30
	}
	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 = encodeVarintMimir(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x22
		}
	}
	if len(m.Exemplars) > 0 {
		for iNdEx := len(m.Exemplars) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Exemplars[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintMimir(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.Samples) > 0 {
		for iNdEx := len(m.Samples) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Samples[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintMimir(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	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 = encodeVarintMimir(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

func (m *LabelPair) 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 = encodeVarintMimir(dAtA, i, uint64(len(m.Value)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintMimir(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *Sample) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.TimestampMs != 0 {
		i = encodeVarintMimir(dAtA, i, uint64(m.TimestampMs))
		i--
		dAtA[i] = 0x10
	}
	if m.Value != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Value))))
		i--
		dAtA[i] = 0x9
	}
	return len(dAtA) - i, nil
}

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

func (m *MetricMetadata) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Unit) > 0 {
		i -= len(m.Unit)
		copy(dAtA[i:], m.Unit)
		i = encodeVarintMimir(dAtA, i, uint64(len(m.Unit)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.Help) > 0 {
		i -= len(m.Help)
		copy(dAtA[i:], m.Help)
		i = encodeVarintMimir(dAtA, i, uint64(len(m.Help)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.MetricFamilyName) > 0 {
		i -= len(m.MetricFamilyName)
		copy(dAtA[i:], m.MetricFamilyName)
		i = encodeVarintMimir(dAtA, i, uint64(len(m.MetricFamilyName)))
		i--
		dAtA[i] = 0x12
	}
	if m.Type != 0 {
		i = encodeVarintMimir(dAtA, i, uint64(m.Type))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *Metric) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	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 = encodeVarintMimir(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

func (m *Exemplar) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.TimestampMs != 0 {
		i = encodeVarintMimir(dAtA, i, uint64(m.TimestampMs))
		i--
		dAtA[i] = 0x18
	}
	if m.Value != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Value))))
		i--
		dAtA[i] = 0x11
	}
	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 = encodeVarintMimir(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

func (m *Histogram) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.CustomValues) > 0 {
		for iNdEx := len(m.CustomValues) - 1; iNdEx >= 0; iNdEx-- {
			f1 := math.Float64bits(float64(m.CustomValues[iNdEx]))
			i -= 8
			encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(f1))
		}
		i = encodeVarintMimir(dAtA, i, uint64(len(m.CustomValues)*8))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x82
	}
	if m.Timestamp != 0 {
		i = encodeVarintMimir(dAtA, i, uint64(m.Timestamp))
		i--
		dAtA[i] = 0x78
	}
	if m.ResetHint != 0 {
		i = encodeVarintMimir(dAtA, i, uint64(m.ResetHint))
		i--
		dAtA[i] = 0x70
	}
	if len(m.PositiveCounts) > 0 {
		for iNdEx := len(m.PositiveCounts) - 1; iNdEx >= 0; iNdEx-- {
			f2 := math.Float64bits(float64(m.PositiveCounts[iNdEx]))
			i -= 8
			encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(f2))
		}
		i = encodeVarintMimir(dAtA, i, uint64(len(m.PositiveCounts)*8))
		i--
		dAtA[i] = 0x6a
	}
	if len(m.PositiveDeltas) > 0 {
		var j3 int
		dAtA5 := make([]byte, len(m.PositiveDeltas)*10)
		for _, num := range m.PositiveDeltas {
			x4 := (uint64(num) << 1) ^ uint64((num >> 63))
			for x4 >= 1<<7 {
				dAtA5[j3] = uint8(uint64(x4)&0x7f | 0x80)
				j3++
				x4 >>= 7
			}
			dAtA5[j3] = uint8(x4)
			j3++
		}
		i -= j3
		copy(dAtA[i:], dAtA5[:j3])
		i = encodeVarintMimir(dAtA, i, uint64(j3))
		i--
		dAtA[i] = 0x62
	}
	if len(m.PositiveSpans) > 0 {
		for iNdEx := len(m.PositiveSpans) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.PositiveSpans[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintMimir(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x5a
		}
	}
	if len(m.NegativeCounts) > 0 {
		for iNdEx := len(m.NegativeCounts) - 1; iNdEx >= 0; iNdEx-- {
			f6 := math.Float64bits(float64(m.NegativeCounts[iNdEx]))
			i -= 8
			encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(f6))
		}
		i = encodeVarintMimir(dAtA, i, uint64(len(m.NegativeCounts)*8))
		i--
		dAtA[i] = 0x52
	}
	if len(m.NegativeDeltas) > 0 {
		var j7 int
		dAtA9 := make([]byte, len(m.NegativeDeltas)*10)
		for _, num := range m.NegativeDeltas {
			x8 := (uint64(num) << 1) ^ uint64((num >> 63))
			for x8 >= 1<<7 {
				dAtA9[j7] = uint8(uint64(x8)&0x7f | 0x80)
				j7++
				x8 >>= 7
			}
			dAtA9[j7] = uint8(x8)
			j7++
		}
		i -= j7
		copy(dAtA[i:], dAtA9[:j7])
		i = encodeVarintMimir(dAtA, i, uint64(j7))
		i--
		dAtA[i] = 0x4a
	}
	if len(m.NegativeSpans) > 0 {
		for iNdEx := len(m.NegativeSpans) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.NegativeSpans[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintMimir(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x42
		}
	}
	if m.ZeroCount != nil {
		{
			size := m.ZeroCount.Size()
			i -= size
			if _, err := m.ZeroCount.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	if m.ZeroThreshold != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.ZeroThreshold))))
		i--
		dAtA[i] = 0x29
	}
	if m.Schema != 0 {
		i = encodeVarintMimir(dAtA, i, uint64((uint32(m.Schema)<<1)^uint32((m.Schema>>31))))
		i--
		dAtA[i] = 0x20
	}
	if m.Sum != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Sum))))
		i--
		dAtA[i] = 0x19
	}
	if m.Count != nil {
		{
			size := m.Count.Size()
			i -= size
			if _, err := m.Count.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	return len(dAtA) - i, nil
}

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

func (m *Histogram_CountInt) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	i = encodeVarintMimir(dAtA, i, uint64(m.CountInt))
	i--
	dAtA[i] = 0x8
	return len(dAtA) - i, nil
}
func (m *Histogram_CountFloat) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Histogram_CountFloat) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	i -= 8
	encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.CountFloat))))
	i--
	dAtA[i] = 0x11
	return len(dAtA) - i, nil
}
func (m *Histogram_ZeroCountInt) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Histogram_ZeroCountInt) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	i = encodeVarintMimir(dAtA, i, uint64(m.ZeroCountInt))
	i--
	dAtA[i] = 0x30
	return len(dAtA) - i, nil
}
func (m *Histogram_ZeroCountFloat) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Histogram_ZeroCountFloat) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	i -= 8
	encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.ZeroCountFloat))))
	i--
	dAtA[i] = 0x39
	return len(dAtA) - i, nil
}
func (m *FloatHistogram) 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 *FloatHistogram) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *FloatHistogram) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.CustomValues) > 0 {
		for iNdEx := len(m.CustomValues) - 1; iNdEx >= 0; iNdEx-- {
			f10 := math.Float64bits(float64(m.CustomValues[iNdEx]))
			i -= 8
			encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(f10))
		}
		i = encodeVarintMimir(dAtA, i, uint64(len(m.CustomValues)*8))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x82
	}
	if m.CounterResetHint != 0 {
		i = encodeVarintMimir(dAtA, i, uint64(m.CounterResetHint))
		i--
		dAtA[i] = 0x70
	}
	if len(m.PositiveBuckets) > 0 {
		for iNdEx := len(m.PositiveBuckets) - 1; iNdEx >= 0; iNdEx-- {
			f11 := math.Float64bits(float64(m.PositiveBuckets[iNdEx]))
			i -= 8
			encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(f11))
		}
		i = encodeVarintMimir(dAtA, i, uint64(len(m.PositiveBuckets)*8))
		i--
		dAtA[i] = 0x6a
	}
	if len(m.PositiveSpans) > 0 {
		for iNdEx := len(m.PositiveSpans) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.PositiveSpans[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintMimir(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x5a
		}
	}
	if len(m.NegativeBuckets) > 0 {
		for iNdEx := len(m.NegativeBuckets) - 1; iNdEx >= 0; iNdEx-- {
			f12 := math.Float64bits(float64(m.NegativeBuckets[iNdEx]))
			i -= 8
			encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(f12))
		}
		i = encodeVarintMimir(dAtA, i, uint64(len(m.NegativeBuckets)*8))
		i--
		dAtA[i] = 0x52
	}
	if len(m.NegativeSpans) > 0 {
		for iNdEx := len(m.NegativeSpans) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.NegativeSpans[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintMimir(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x42
		}
	}
	if m.ZeroCount != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.ZeroCount))))
		i--
		dAtA[i] = 0x39
	}
	if m.ZeroThreshold != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.ZeroThreshold))))
		i--
		dAtA[i] = 0x29
	}
	if m.Schema != 0 {
		i = encodeVarintMimir(dAtA, i, uint64((uint32(m.Schema)<<1)^uint32((m.Schema>>31))))
		i--
		dAtA[i] = 0x20
	}
	if m.Sum != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Sum))))
		i--
		dAtA[i] = 0x19
	}
	if m.Count != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Count))))
		i--
		dAtA[i] = 0x11
	}
	return len(dAtA) - i, nil
}

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

func (m *BucketSpan) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Length != 0 {
		i = encodeVarintMimir(dAtA, i, uint64(m.Length))
		i--
		dAtA[i] = 0x10
	}
	if m.Offset != 0 {
		i = encodeVarintMimir(dAtA, i, uint64((uint32(m.Offset)<<1)^uint32((m.Offset>>31))))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *FloatHistogramPair) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.TimestampMs != 0 {
		i = encodeVarintMimir(dAtA, i, uint64(m.TimestampMs))
		i--
		dAtA[i] = 0x10
	}
	if m.Histogram != nil {
		{
			size, err := m.Histogram.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMimir(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *SampleHistogram) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Buckets) > 0 {
		for iNdEx := len(m.Buckets) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Buckets[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintMimir(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.Sum != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Sum))))
		i--
		dAtA[i] = 0x11
	}
	if m.Count != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Count))))
		i--
		dAtA[i] = 0x9
	}
	return len(dAtA) - i, nil
}

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

func (m *HistogramBucket) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Count != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Count))))
		i--
		dAtA[i] = 0x21
	}
	if m.Upper != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Upper))))
		i--
		dAtA[i] = 0x19
	}
	if m.Lower != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Lower))))
		i--
		dAtA[i] = 0x11
	}
	if m.Boundaries != 0 {
		i = encodeVarintMimir(dAtA, i, uint64(m.Boundaries))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *SampleHistogramPair) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Timestamp != 0 {
		i = encodeVarintMimir(dAtA, i, uint64(m.Timestamp))
		i--
		dAtA[i] = 0x10
	}
	if m.Histogram != nil {
		{
			size, err := m.Histogram.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMimir(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *QueryResponse) 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 = encodeVarintMimir(dAtA, i, uint64(len(m.Infos[iNdEx])))
			i--
			dAtA[i] = 0x4a
		}
	}
	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 = encodeVarintMimir(dAtA, i, uint64(len(m.Warnings[iNdEx])))
			i--
			dAtA[i] = 0x42
		}
	}
	if m.Data != nil {
		{
			size := m.Data.Size()
			i -= size
			if _, err := m.Data.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	if len(m.Error) > 0 {
		i -= len(m.Error)
		copy(dAtA[i:], m.Error)
		i = encodeVarintMimir(dAtA, i, uint64(len(m.Error)))
		i--
		dAtA[i] = 0x1a
	}
	if m.ErrorType != 0 {
		i = encodeVarintMimir(dAtA, i, uint64(m.ErrorType))
		i--
		dAtA[i] = 0x10
	}
	if m.Status != 0 {
		i = encodeVarintMimir(dAtA, i, uint64(m.Status))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *QueryResponse_Scalar) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Scalar != nil {
		{
			size, err := m.Scalar.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMimir(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	return len(dAtA) - i, nil
}
func (m *QueryResponse_Matrix) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *QueryResponse_Matrix) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Matrix != nil {
		{
			size, err := m.Matrix.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMimir(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x3a
	}
	return len(dAtA) - i, nil
}
func (m *StringData) 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 *StringData) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *StringData) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.TimestampMs != 0 {
		i = encodeVarintMimir(dAtA, i, uint64(m.TimestampMs))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Value) > 0 {
		i -= len(m.Value)
		copy(dAtA[i:], m.Value)
		i = encodeVarintMimir(dAtA, i, uint64(len(m.Value)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *VectorData) 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 = encodeVarintMimir(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.Samples) > 0 {
		for iNdEx := len(m.Samples) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Samples[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintMimir(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

func (m *VectorSample) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.TimestampMs != 0 {
		i = encodeVarintMimir(dAtA, i, uint64(m.TimestampMs))
		i--
		dAtA[i] = 0x18
	}
	if m.Value != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Value))))
		i--
		dAtA[i] = 0x11
	}
	if len(m.Metric) > 0 {
		for iNdEx := len(m.Metric) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Metric[iNdEx])
			copy(dAtA[i:], m.Metric[iNdEx])
			i = encodeVarintMimir(dAtA, i, uint64(len(m.Metric[iNdEx])))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

func (m *VectorHistogram) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.TimestampMs != 0 {
		i = encodeVarintMimir(dAtA, i, uint64(m.TimestampMs))
		i--
		dAtA[i] = 0x18
	}
	{
		size, err := m.Histogram.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintMimir(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if len(m.Metric) > 0 {
		for iNdEx := len(m.Metric) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Metric[iNdEx])
			copy(dAtA[i:], m.Metric[iNdEx])
			i = encodeVarintMimir(dAtA, i, uint64(len(m.Metric[iNdEx])))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

func (m *ScalarData) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.TimestampMs != 0 {
		i = encodeVarintMimir(dAtA, i, uint64(m.TimestampMs))
		i--
		dAtA[i] = 0x10
	}
	if m.Value != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Value))))
		i--
		dAtA[i] = 0x9
	}
	return len(dAtA) - i, nil
}

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

func (m *MatrixData) 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 = encodeVarintMimir(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

func (m *MatrixSeries) 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 = encodeVarintMimir(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.Samples) > 0 {
		for iNdEx := len(m.Samples) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Samples[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintMimir(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.Metric) > 0 {
		for iNdEx := len(m.Metric) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Metric[iNdEx])
			copy(dAtA[i:], m.Metric[iNdEx])
			i = encodeVarintMimir(dAtA, i, uint64(len(m.Metric[iNdEx])))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

func (m *WriteRequestRW2) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Timeseries) > 0 {
		for iNdEx := len(m.Timeseries) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Timeseries[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintMimir(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x2a
		}
	}
	if len(m.Symbols) > 0 {
		for iNdEx := len(m.Symbols) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Symbols[iNdEx])
			copy(dAtA[i:], m.Symbols[iNdEx])
			i = encodeVarintMimir(dAtA, i, uint64(len(m.Symbols[iNdEx])))
			i--
			dAtA[i] = 0x22
		}
	}
	return len(dAtA) - i, nil
}

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

func (m *TimeSeriesRW2) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.CreatedTimestamp != 0 {
		i = encodeVarintMimir(dAtA, i, uint64(m.CreatedTimestamp))
		i--
		dAtA[i] = 0x30
	}
	{
		size, err := m.Metadata.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintMimir(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x2a
	if len(m.Exemplars) > 0 {
		for iNdEx := len(m.Exemplars) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Exemplars[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintMimir(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x22
		}
	}
	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 = encodeVarintMimir(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.Samples) > 0 {
		for iNdEx := len(m.Samples) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Samples[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintMimir(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.LabelsRefs) > 0 {
		// Modified code.
		// Normally we move backward through the message, but varint encoding requires moving forward, due to the bit math/continuation bits.
		// The generator normally allocates a new buffer for the varint slice, moves foward through it, and copies it into dAtA at the end.
		// We avoid the buffer allocation by instead encoding the value in-place, but backward, and then reversing the bits at the end.
		var j21 int
		start := i
		for _, num := range m.LabelsRefs {
			for num >= 1<<7 {
				dAtA[i-1] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				i--
				j21++
			}
			dAtA[i-1] = uint8(num)
			i--
			j21++
		}
		slices.Reverse(dAtA[i:start])
		// End modified code.
		i = encodeVarintMimir(dAtA, i, uint64(j21))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *ExemplarRW2) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Timestamp != 0 {
		i = encodeVarintMimir(dAtA, i, uint64(m.Timestamp))
		i--
		dAtA[i] = 0x18
	}
	if m.Value != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Value))))
		i--
		dAtA[i] = 0x11
	}
	if len(m.LabelsRefs) > 0 {
		// Modified code.
		// Normally we move backward through the message, but varint encoding requires moving forward, due to the bit math/continuation bits.
		// The generator normally allocates a new buffer for the varint slice, moves foward through it, and copies it into dAtA at the end.
		// We avoid the buffer allocation by instead encoding the value in-place, but backward, and then reversing the bits at the end.
		var j23 int
		start := i
		for _, num := range m.LabelsRefs {
			for num >= 1<<7 {
				dAtA[i-1] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				i--
				j23++
			}
			dAtA[i-1] = uint8(num)
			i--
			j23++
		}
		slices.Reverse(dAtA[i:start])
		// End modified code.
		i = encodeVarintMimir(dAtA, i, uint64(j23))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *MetadataRW2) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.UnitRef != 0 {
		i = encodeVarintMimir(dAtA, i, uint64(m.UnitRef))
		i--
		dAtA[i] = 0x20
	}
	if m.HelpRef != 0 {
		i = encodeVarintMimir(dAtA, i, uint64(m.HelpRef))
		i--
		dAtA[i] = 0x18
	}
	if m.Type != 0 {
		i = encodeVarintMimir(dAtA, i, uint64(m.Type))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func encodeVarintMimir(dAtA []byte, offset int, v uint64) int {
	offset -= sovMimir(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *WriteRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Timeseries) > 0 {
		for _, e := range m.Timeseries {
			l = e.Size()
			n += 1 + l + sovMimir(uint64(l))
		}
	}
	if m.Source != 0 {
		n += 1 + sovMimir(uint64(m.Source))
	}
	if len(m.Metadata) > 0 {
		for _, e := range m.Metadata {
			l = e.Size()
			n += 1 + l + sovMimir(uint64(l))
		}
	}
	if len(m.SymbolsRW2) > 0 {
		for _, s := range m.SymbolsRW2 {
			l = len(s)
			n += 1 + l + sovMimir(uint64(l))
		}
	}
	if len(m.TimeseriesRW2) > 0 {
		for _, e := range m.TimeseriesRW2 {
			l = e.Size()
			n += 1 + l + sovMimir(uint64(l))
		}
	}
	if m.SkipLabelValidation {
		n += 3
	}
	if m.SkipLabelCountValidation {
		n += 3
	}
	return n
}

func (m *WriteResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *ErrorDetails) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Cause != 0 {
		n += 1 + sovMimir(uint64(m.Cause))
	}
	if m.Soft {
		n += 2
	}
	if m.RejectedSamples != 0 {
		n += 1 + sovMimir(uint64(m.RejectedSamples))
	}
	return n
}

func (m *TimeSeries) 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 + sovMimir(uint64(l))
		}
	}
	if len(m.Samples) > 0 {
		for _, e := range m.Samples {
			l = e.Size()
			n += 1 + l + sovMimir(uint64(l))
		}
	}
	if len(m.Exemplars) > 0 {
		for _, e := range m.Exemplars {
			l = e.Size()
			n += 1 + l + sovMimir(uint64(l))
		}
	}
	if len(m.Histograms) > 0 {
		for _, e := range m.Histograms {
			l = e.Size()
			n += 1 + l + sovMimir(uint64(l))
		}
	}
	if m.CreatedTimestamp != 0 {
		n += 1 + sovMimir(uint64(m.CreatedTimestamp))
	}
	return n
}

func (m *LabelPair) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovMimir(uint64(l))
	}
	l = len(m.Value)
	if l > 0 {
		n += 1 + l + sovMimir(uint64(l))
	}
	return n
}

func (m *Sample) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Value != 0 {
		n += 9
	}
	if m.TimestampMs != 0 {
		n += 1 + sovMimir(uint64(m.TimestampMs))
	}
	return n
}

func (m *MetricMetadata) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Type != 0 {
		n += 1 + sovMimir(uint64(m.Type))
	}
	l = len(m.MetricFamilyName)
	if l > 0 {
		n += 1 + l + sovMimir(uint64(l))
	}
	l = len(m.Help)
	if l > 0 {
		n += 1 + l + sovMimir(uint64(l))
	}
	l = len(m.Unit)
	if l > 0 {
		n += 1 + l + sovMimir(uint64(l))
	}
	return n
}

func (m *Metric) 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 + sovMimir(uint64(l))
		}
	}
	return n
}

func (m *Exemplar) 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 + sovMimir(uint64(l))
		}
	}
	if m.Value != 0 {
		n += 9
	}
	if m.TimestampMs != 0 {
		n += 1 + sovMimir(uint64(m.TimestampMs))
	}
	return n
}

func (m *Histogram) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Count != nil {
		n += m.Count.Size()
	}
	if m.Sum != 0 {
		n += 9
	}
	if m.Schema != 0 {
		n += 1 + sozMimir(uint64(m.Schema))
	}
	if m.ZeroThreshold != 0 {
		n += 9
	}
	if m.ZeroCount != nil {
		n += m.ZeroCount.Size()
	}
	if len(m.NegativeSpans) > 0 {
		for _, e := range m.NegativeSpans {
			l = e.Size()
			n += 1 + l + sovMimir(uint64(l))
		}
	}
	if len(m.NegativeDeltas) > 0 {
		l = 0
		for _, e := range m.NegativeDeltas {
			l += sozMimir(uint64(e))
		}
		n += 1 + sovMimir(uint64(l)) + l
	}
	if len(m.NegativeCounts) > 0 {
		n += 1 + sovMimir(uint64(len(m.NegativeCounts)*8)) + len(m.NegativeCounts)*8
	}
	if len(m.PositiveSpans) > 0 {
		for _, e := range m.PositiveSpans {
			l = e.Size()
			n += 1 + l + sovMimir(uint64(l))
		}
	}
	if len(m.PositiveDeltas) > 0 {
		l = 0
		for _, e := range m.PositiveDeltas {
			l += sozMimir(uint64(e))
		}
		n += 1 + sovMimir(uint64(l)) + l
	}
	if len(m.PositiveCounts) > 0 {
		n += 1 + sovMimir(uint64(len(m.PositiveCounts)*8)) + len(m.PositiveCounts)*8
	}
	if m.ResetHint != 0 {
		n += 1 + sovMimir(uint64(m.ResetHint))
	}
	if m.Timestamp != 0 {
		n += 1 + sovMimir(uint64(m.Timestamp))
	}
	if len(m.CustomValues) > 0 {
		n += 2 + sovMimir(uint64(len(m.CustomValues)*8)) + len(m.CustomValues)*8
	}
	return n
}

func (m *Histogram_CountInt) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 1 + sovMimir(uint64(m.CountInt))
	return n
}
func (m *Histogram_CountFloat) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 9
	return n
}
func (m *Histogram_ZeroCountInt) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 1 + sovMimir(uint64(m.ZeroCountInt))
	return n
}
func (m *Histogram_ZeroCountFloat) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 9
	return n
}
func (m *FloatHistogram) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Count != 0 {
		n += 9
	}
	if m.Sum != 0 {
		n += 9
	}
	if m.Schema != 0 {
		n += 1 + sozMimir(uint64(m.Schema))
	}
	if m.ZeroThreshold != 0 {
		n += 9
	}
	if m.ZeroCount != 0 {
		n += 9
	}
	if len(m.NegativeSpans) > 0 {
		for _, e := range m.NegativeSpans {
			l = e.Size()
			n += 1 + l + sovMimir(uint64(l))
		}
	}
	if len(m.NegativeBuckets) > 0 {
		n += 1 + sovMimir(uint64(len(m.NegativeBuckets)*8)) + len(m.NegativeBuckets)*8
	}
	if len(m.PositiveSpans) > 0 {
		for _, e := range m.PositiveSpans {
			l = e.Size()
			n += 1 + l + sovMimir(uint64(l))
		}
	}
	if len(m.PositiveBuckets) > 0 {
		n += 1 + sovMimir(uint64(len(m.PositiveBuckets)*8)) + len(m.PositiveBuckets)*8
	}
	if m.CounterResetHint != 0 {
		n += 1 + sovMimir(uint64(m.CounterResetHint))
	}
	if len(m.CustomValues) > 0 {
		n += 2 + sovMimir(uint64(len(m.CustomValues)*8)) + len(m.CustomValues)*8
	}
	return n
}

func (m *BucketSpan) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Offset != 0 {
		n += 1 + sozMimir(uint64(m.Offset))
	}
	if m.Length != 0 {
		n += 1 + sovMimir(uint64(m.Length))
	}
	return n
}

func (m *FloatHistogramPair) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Histogram != nil {
		l = m.Histogram.Size()
		n += 1 + l + sovMimir(uint64(l))
	}
	if m.TimestampMs != 0 {
		n += 1 + sovMimir(uint64(m.TimestampMs))
	}
	return n
}

func (m *SampleHistogram) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Count != 0 {
		n += 9
	}
	if m.Sum != 0 {
		n += 9
	}
	if len(m.Buckets) > 0 {
		for _, e := range m.Buckets {
			l = e.Size()
			n += 1 + l + sovMimir(uint64(l))
		}
	}
	return n
}

func (m *HistogramBucket) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Boundaries != 0 {
		n += 1 + sovMimir(uint64(m.Boundaries))
	}
	if m.Lower != 0 {
		n += 9
	}
	if m.Upper != 0 {
		n += 9
	}
	if m.Count != 0 {
		n += 9
	}
	return n
}

func (m *SampleHistogramPair) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Histogram != nil {
		l = m.Histogram.Size()
		n += 1 + l + sovMimir(uint64(l))
	}
	if m.Timestamp != 0 {
		n += 1 + sovMimir(uint64(m.Timestamp))
	}
	return n
}

func (m *QueryResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Status != 0 {
		n += 1 + sovMimir(uint64(m.Status))
	}
	if m.ErrorType != 0 {
		n += 1 + sovMimir(uint64(m.ErrorType))
	}
	l = len(m.Error)
	if l > 0 {
		n += 1 + l + sovMimir(uint64(l))
	}
	if m.Data != nil {
		n += m.Data.Size()
	}
	if len(m.Warnings) > 0 {
		for _, s := range m.Warnings {
			l = len(s)
			n += 1 + l + sovMimir(uint64(l))
		}
	}
	if len(m.Infos) > 0 {
		for _, s := range m.Infos {
			l = len(s)
			n += 1 + l + sovMimir(uint64(l))
		}
	}
	return n
}

func (m *QueryResponse_String_) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.String_ != nil {
		l = m.String_.Size()
		n += 1 + l + sovMimir(uint64(l))
	}
	return n
}
func (m *QueryResponse_Vector) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Vector != nil {
		l = m.Vector.Size()
		n += 1 + l + sovMimir(uint64(l))
	}
	return n
}
func (m *QueryResponse_Scalar) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Scalar != nil {
		l = m.Scalar.Size()
		n += 1 + l + sovMimir(uint64(l))
	}
	return n
}
func (m *QueryResponse_Matrix) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Matrix != nil {
		l = m.Matrix.Size()
		n += 1 + l + sovMimir(uint64(l))
	}
	return n
}
func (m *StringData) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Value)
	if l > 0 {
		n += 1 + l + sovMimir(uint64(l))
	}
	if m.TimestampMs != 0 {
		n += 1 + sovMimir(uint64(m.TimestampMs))
	}
	return n
}

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

func (m *VectorSample) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Metric) > 0 {
		for _, s := range m.Metric {
			l = len(s)
			n += 1 + l + sovMimir(uint64(l))
		}
	}
	if m.Value != 0 {
		n += 9
	}
	if m.TimestampMs != 0 {
		n += 1 + sovMimir(uint64(m.TimestampMs))
	}
	return n
}

func (m *VectorHistogram) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Metric) > 0 {
		for _, s := range m.Metric {
			l = len(s)
			n += 1 + l + sovMimir(uint64(l))
		}
	}
	l = m.Histogram.Size()
	n += 1 + l + sovMimir(uint64(l))
	if m.TimestampMs != 0 {
		n += 1 + sovMimir(uint64(m.TimestampMs))
	}
	return n
}

func (m *ScalarData) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Value != 0 {
		n += 9
	}
	if m.TimestampMs != 0 {
		n += 1 + sovMimir(uint64(m.TimestampMs))
	}
	return n
}

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

func (m *MatrixSeries) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Metric) > 0 {
		for _, s := range m.Metric {
			l = len(s)
			n += 1 + l + sovMimir(uint64(l))
		}
	}
	if len(m.Samples) > 0 {
		for _, e := range m.Samples {
			l = e.Size()
			n += 1 + l + sovMimir(uint64(l))
		}
	}
	if len(m.Histograms) > 0 {
		for _, e := range m.Histograms {
			l = e.Size()
			n += 1 + l + sovMimir(uint64(l))
		}
	}
	return n
}

func (m *WriteRequestRW2) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Symbols) > 0 {
		for _, s := range m.Symbols {
			l = len(s)
			n += 1 + l + sovMimir(uint64(l))
		}
	}
	if len(m.Timeseries) > 0 {
		for _, e := range m.Timeseries {
			l = e.Size()
			n += 1 + l + sovMimir(uint64(l))
		}
	}
	return n
}

func (m *TimeSeriesRW2) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.LabelsRefs) > 0 {
		l = 0
		for _, e := range m.LabelsRefs {
			l += sovMimir(uint64(e))
		}
		n += 1 + sovMimir(uint64(l)) + l
	}
	if len(m.Samples) > 0 {
		for _, e := range m.Samples {
			l = e.Size()
			n += 1 + l + sovMimir(uint64(l))
		}
	}
	if len(m.Histograms) > 0 {
		for _, e := range m.Histograms {
			l = e.Size()
			n += 1 + l + sovMimir(uint64(l))
		}
	}
	if len(m.Exemplars) > 0 {
		for _, e := range m.Exemplars {
			l = e.Size()
			n += 1 + l + sovMimir(uint64(l))
		}
	}
	l = m.Metadata.Size()
	n += 1 + l + sovMimir(uint64(l))
	if m.CreatedTimestamp != 0 {
		n += 1 + sovMimir(uint64(m.CreatedTimestamp))
	}
	return n
}

func (m *ExemplarRW2) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.LabelsRefs) > 0 {
		l = 0
		for _, e := range m.LabelsRefs {
			l += sovMimir(uint64(e))
		}
		n += 1 + sovMimir(uint64(l)) + l
	}
	if m.Value != 0 {
		n += 9
	}
	if m.Timestamp != 0 {
		n += 1 + sovMimir(uint64(m.Timestamp))
	}
	return n
}

func (m *MetadataRW2) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Type != 0 {
		n += 1 + sovMimir(uint64(m.Type))
	}
	if m.HelpRef != 0 {
		n += 1 + sovMimir(uint64(m.HelpRef))
	}
	if m.UnitRef != 0 {
		n += 1 + sovMimir(uint64(m.UnitRef))
	}
	return n
}

func sovMimir(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozMimir(x uint64) (n int) {
	return sovMimir(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (this *WriteRequest) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForMetadata := "[]*MetricMetadata{"
	for _, f := range this.Metadata {
		repeatedStringForMetadata += strings.Replace(f.String(), "MetricMetadata", "MetricMetadata", 1) + ","
	}
	repeatedStringForMetadata += "}"
	repeatedStringForTimeseriesRW2 := "[]TimeSeriesRW2{"
	for _, f := range this.TimeseriesRW2 {
		repeatedStringForTimeseriesRW2 += strings.Replace(strings.Replace(f.String(), "TimeSeriesRW2", "TimeSeriesRW2", 1), `&`, ``, 1) + ","
	}
	repeatedStringForTimeseriesRW2 += "}"
	s := strings.Join([]string{`&WriteRequest{`,
		`Timeseries:` + fmt.Sprintf("%v", this.Timeseries) + `,`,
		`Source:` + fmt.Sprintf("%v", this.Source) + `,`,
		`Metadata:` + repeatedStringForMetadata + `,`,
		`SymbolsRW2:` + fmt.Sprintf("%v", this.SymbolsRW2) + `,`,
		`TimeseriesRW2:` + repeatedStringForTimeseriesRW2 + `,`,
		`SkipLabelValidation:` + fmt.Sprintf("%v", this.SkipLabelValidation) + `,`,
		`SkipLabelCountValidation:` + fmt.Sprintf("%v", this.SkipLabelCountValidation) + `,`,
		`}`,
	}, "")
	return s
}
func (this *WriteResponse) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&WriteResponse{`,
		`}`,
	}, "")
	return s
}
func (this *ErrorDetails) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ErrorDetails{`,
		`Cause:` + fmt.Sprintf("%v", this.Cause) + `,`,
		`Soft:` + fmt.Sprintf("%v", this.Soft) + `,`,
		`RejectedSamples:` + fmt.Sprintf("%v", this.RejectedSamples) + `,`,
		`}`,
	}, "")
	return s
}
func (this *TimeSeries) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForSamples := "[]Sample{"
	for _, f := range this.Samples {
		repeatedStringForSamples += strings.Replace(strings.Replace(f.String(), "Sample", "Sample", 1), `&`, ``, 1) + ","
	}
	repeatedStringForSamples += "}"
	repeatedStringForExemplars := "[]Exemplar{"
	for _, f := range this.Exemplars {
		repeatedStringForExemplars += strings.Replace(strings.Replace(f.String(), "Exemplar", "Exemplar", 1), `&`, ``, 1) + ","
	}
	repeatedStringForExemplars += "}"
	repeatedStringForHistograms := "[]Histogram{"
	for _, f := range this.Histograms {
		repeatedStringForHistograms += strings.Replace(strings.Replace(f.String(), "Histogram", "Histogram", 1), `&`, ``, 1) + ","
	}
	repeatedStringForHistograms += "}"
	s := strings.Join([]string{`&TimeSeries{`,
		`Labels:` + fmt.Sprintf("%v", this.Labels) + `,`,
		`Samples:` + repeatedStringForSamples + `,`,
		`Exemplars:` + repeatedStringForExemplars + `,`,
		`Histograms:` + repeatedStringForHistograms + `,`,
		`CreatedTimestamp:` + fmt.Sprintf("%v", this.CreatedTimestamp) + `,`,
		`}`,
	}, "")
	return s
}
func (this *LabelPair) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&LabelPair{`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`Value:` + fmt.Sprintf("%v", this.Value) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Sample) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Sample{`,
		`Value:` + fmt.Sprintf("%v", this.Value) + `,`,
		`TimestampMs:` + fmt.Sprintf("%v", this.TimestampMs) + `,`,
		`}`,
	}, "")
	return s
}
func (this *MetricMetadata) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&MetricMetadata{`,
		`Type:` + fmt.Sprintf("%v", this.Type) + `,`,
		`MetricFamilyName:` + fmt.Sprintf("%v", this.MetricFamilyName) + `,`,
		`Help:` + fmt.Sprintf("%v", this.Help) + `,`,
		`Unit:` + fmt.Sprintf("%v", this.Unit) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Metric) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Metric{`,
		`Labels:` + fmt.Sprintf("%v", this.Labels) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Exemplar) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Exemplar{`,
		`Labels:` + fmt.Sprintf("%v", this.Labels) + `,`,
		`Value:` + fmt.Sprintf("%v", this.Value) + `,`,
		`TimestampMs:` + fmt.Sprintf("%v", this.TimestampMs) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Histogram) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForNegativeSpans := "[]BucketSpan{"
	for _, f := range this.NegativeSpans {
		repeatedStringForNegativeSpans += strings.Replace(strings.Replace(f.String(), "BucketSpan", "BucketSpan", 1), `&`, ``, 1) + ","
	}
	repeatedStringForNegativeSpans += "}"
	repeatedStringForPositiveSpans := "[]BucketSpan{"
	for _, f := range this.PositiveSpans {
		repeatedStringForPositiveSpans += strings.Replace(strings.Replace(f.String(), "BucketSpan", "BucketSpan", 1), `&`, ``, 1) + ","
	}
	repeatedStringForPositiveSpans += "}"
	s := strings.Join([]string{`&Histogram{`,
		`Count:` + fmt.Sprintf("%v", this.Count) + `,`,
		`Sum:` + fmt.Sprintf("%v", this.Sum) + `,`,
		`Schema:` + fmt.Sprintf("%v", this.Schema) + `,`,
		`ZeroThreshold:` + fmt.Sprintf("%v", this.ZeroThreshold) + `,`,
		`ZeroCount:` + fmt.Sprintf("%v", this.ZeroCount) + `,`,
		`NegativeSpans:` + repeatedStringForNegativeSpans + `,`,
		`NegativeDeltas:` + fmt.Sprintf("%v", this.NegativeDeltas) + `,`,
		`NegativeCounts:` + fmt.Sprintf("%v", this.NegativeCounts) + `,`,
		`PositiveSpans:` + repeatedStringForPositiveSpans + `,`,
		`PositiveDeltas:` + fmt.Sprintf("%v", this.PositiveDeltas) + `,`,
		`PositiveCounts:` + fmt.Sprintf("%v", this.PositiveCounts) + `,`,
		`ResetHint:` + fmt.Sprintf("%v", this.ResetHint) + `,`,
		`Timestamp:` + fmt.Sprintf("%v", this.Timestamp) + `,`,
		`CustomValues:` + fmt.Sprintf("%v", this.CustomValues) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Histogram_CountInt) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Histogram_CountInt{`,
		`CountInt:` + fmt.Sprintf("%v", this.CountInt) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Histogram_CountFloat) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Histogram_CountFloat{`,
		`CountFloat:` + fmt.Sprintf("%v", this.CountFloat) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Histogram_ZeroCountInt) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Histogram_ZeroCountInt{`,
		`ZeroCountInt:` + fmt.Sprintf("%v", this.ZeroCountInt) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Histogram_ZeroCountFloat) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Histogram_ZeroCountFloat{`,
		`ZeroCountFloat:` + fmt.Sprintf("%v", this.ZeroCountFloat) + `,`,
		`}`,
	}, "")
	return s
}
func (this *FloatHistogram) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForNegativeSpans := "[]BucketSpan{"
	for _, f := range this.NegativeSpans {
		repeatedStringForNegativeSpans += strings.Replace(strings.Replace(f.String(), "BucketSpan", "BucketSpan", 1), `&`, ``, 1) + ","
	}
	repeatedStringForNegativeSpans += "}"
	repeatedStringForPositiveSpans := "[]BucketSpan{"
	for _, f := range this.PositiveSpans {
		repeatedStringForPositiveSpans += strings.Replace(strings.Replace(f.String(), "BucketSpan", "BucketSpan", 1), `&`, ``, 1) + ","
	}
	repeatedStringForPositiveSpans += "}"
	s := strings.Join([]string{`&FloatHistogram{`,
		`Count:` + fmt.Sprintf("%v", this.Count) + `,`,
		`Sum:` + fmt.Sprintf("%v", this.Sum) + `,`,
		`Schema:` + fmt.Sprintf("%v", this.Schema) + `,`,
		`ZeroThreshold:` + fmt.Sprintf("%v", this.ZeroThreshold) + `,`,
		`ZeroCount:` + fmt.Sprintf("%v", this.ZeroCount) + `,`,
		`NegativeSpans:` + repeatedStringForNegativeSpans + `,`,
		`NegativeBuckets:` + fmt.Sprintf("%v", this.NegativeBuckets) + `,`,
		`PositiveSpans:` + repeatedStringForPositiveSpans + `,`,
		`PositiveBuckets:` + fmt.Sprintf("%v", this.PositiveBuckets) + `,`,
		`CounterResetHint:` + fmt.Sprintf("%v", this.CounterResetHint) + `,`,
		`CustomValues:` + fmt.Sprintf("%v", this.CustomValues) + `,`,
		`}`,
	}, "")
	return s
}
func (this *BucketSpan) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&BucketSpan{`,
		`Offset:` + fmt.Sprintf("%v", this.Offset) + `,`,
		`Length:` + fmt.Sprintf("%v", this.Length) + `,`,
		`}`,
	}, "")
	return s
}
func (this *FloatHistogramPair) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&FloatHistogramPair{`,
		`Histogram:` + strings.Replace(this.Histogram.String(), "FloatHistogram", "FloatHistogram", 1) + `,`,
		`TimestampMs:` + fmt.Sprintf("%v", this.TimestampMs) + `,`,
		`}`,
	}, "")
	return s
}
func (this *SampleHistogram) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForBuckets := "[]*HistogramBucket{"
	for _, f := range this.Buckets {
		repeatedStringForBuckets += strings.Replace(f.String(), "HistogramBucket", "HistogramBucket", 1) + ","
	}
	repeatedStringForBuckets += "}"
	s := strings.Join([]string{`&SampleHistogram{`,
		`Count:` + fmt.Sprintf("%v", this.Count) + `,`,
		`Sum:` + fmt.Sprintf("%v", this.Sum) + `,`,
		`Buckets:` + repeatedStringForBuckets + `,`,
		`}`,
	}, "")
	return s
}
func (this *HistogramBucket) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&HistogramBucket{`,
		`Boundaries:` + fmt.Sprintf("%v", this.Boundaries) + `,`,
		`Lower:` + fmt.Sprintf("%v", this.Lower) + `,`,
		`Upper:` + fmt.Sprintf("%v", this.Upper) + `,`,
		`Count:` + fmt.Sprintf("%v", this.Count) + `,`,
		`}`,
	}, "")
	return s
}
func (this *SampleHistogramPair) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&SampleHistogramPair{`,
		`Histogram:` + strings.Replace(this.Histogram.String(), "SampleHistogram", "SampleHistogram", 1) + `,`,
		`Timestamp:` + fmt.Sprintf("%v", this.Timestamp) + `,`,
		`}`,
	}, "")
	return s
}
func (this *QueryResponse) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&QueryResponse{`,
		`Status:` + fmt.Sprintf("%v", this.Status) + `,`,
		`ErrorType:` + fmt.Sprintf("%v", this.ErrorType) + `,`,
		`Error:` + fmt.Sprintf("%v", this.Error) + `,`,
		`Data:` + fmt.Sprintf("%v", this.Data) + `,`,
		`Warnings:` + fmt.Sprintf("%v", this.Warnings) + `,`,
		`Infos:` + fmt.Sprintf("%v", this.Infos) + `,`,
		`}`,
	}, "")
	return s
}
func (this *QueryResponse_String_) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&QueryResponse_String_{`,
		`String_:` + strings.Replace(fmt.Sprintf("%v", this.String_), "StringData", "StringData", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *QueryResponse_Vector) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&QueryResponse_Vector{`,
		`Vector:` + strings.Replace(fmt.Sprintf("%v", this.Vector), "VectorData", "VectorData", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *QueryResponse_Scalar) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&QueryResponse_Scalar{`,
		`Scalar:` + strings.Replace(fmt.Sprintf("%v", this.Scalar), "ScalarData", "ScalarData", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *QueryResponse_Matrix) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&QueryResponse_Matrix{`,
		`Matrix:` + strings.Replace(fmt.Sprintf("%v", this.Matrix), "MatrixData", "MatrixData", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *StringData) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&StringData{`,
		`Value:` + fmt.Sprintf("%v", this.Value) + `,`,
		`TimestampMs:` + fmt.Sprintf("%v", this.TimestampMs) + `,`,
		`}`,
	}, "")
	return s
}
func (this *VectorData) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForSamples := "[]VectorSample{"
	for _, f := range this.Samples {
		repeatedStringForSamples += strings.Replace(strings.Replace(f.String(), "VectorSample", "VectorSample", 1), `&`, ``, 1) + ","
	}
	repeatedStringForSamples += "}"
	repeatedStringForHistograms := "[]VectorHistogram{"
	for _, f := range this.Histograms {
		repeatedStringForHistograms += strings.Replace(strings.Replace(f.String(), "VectorHistogram", "VectorHistogram", 1), `&`, ``, 1) + ","
	}
	repeatedStringForHistograms += "}"
	s := strings.Join([]string{`&VectorData{`,
		`Samples:` + repeatedStringForSamples + `,`,
		`Histograms:` + repeatedStringForHistograms + `,`,
		`}`,
	}, "")
	return s
}
func (this *VectorSample) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&VectorSample{`,
		`Metric:` + fmt.Sprintf("%v", this.Metric) + `,`,
		`Value:` + fmt.Sprintf("%v", this.Value) + `,`,
		`TimestampMs:` + fmt.Sprintf("%v", this.TimestampMs) + `,`,
		`}`,
	}, "")
	return s
}
func (this *VectorHistogram) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&VectorHistogram{`,
		`Metric:` + fmt.Sprintf("%v", this.Metric) + `,`,
		`Histogram:` + strings.Replace(strings.Replace(this.Histogram.String(), "FloatHistogram", "FloatHistogram", 1), `&`, ``, 1) + `,`,
		`TimestampMs:` + fmt.Sprintf("%v", this.TimestampMs) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ScalarData) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ScalarData{`,
		`Value:` + fmt.Sprintf("%v", this.Value) + `,`,
		`TimestampMs:` + fmt.Sprintf("%v", this.TimestampMs) + `,`,
		`}`,
	}, "")
	return s
}
func (this *MatrixData) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForSeries := "[]MatrixSeries{"
	for _, f := range this.Series {
		repeatedStringForSeries += strings.Replace(strings.Replace(f.String(), "MatrixSeries", "MatrixSeries", 1), `&`, ``, 1) + ","
	}
	repeatedStringForSeries += "}"
	s := strings.Join([]string{`&MatrixData{`,
		`Series:` + repeatedStringForSeries + `,`,
		`}`,
	}, "")
	return s
}
func (this *MatrixSeries) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForSamples := "[]Sample{"
	for _, f := range this.Samples {
		repeatedStringForSamples += strings.Replace(strings.Replace(f.String(), "Sample", "Sample", 1), `&`, ``, 1) + ","
	}
	repeatedStringForSamples += "}"
	repeatedStringForHistograms := "[]FloatHistogramPair{"
	for _, f := range this.Histograms {
		repeatedStringForHistograms += strings.Replace(strings.Replace(f.String(), "FloatHistogramPair", "FloatHistogramPair", 1), `&`, ``, 1) + ","
	}
	repeatedStringForHistograms += "}"
	s := strings.Join([]string{`&MatrixSeries{`,
		`Metric:` + fmt.Sprintf("%v", this.Metric) + `,`,
		`Samples:` + repeatedStringForSamples + `,`,
		`Histograms:` + repeatedStringForHistograms + `,`,
		`}`,
	}, "")
	return s
}
func (this *WriteRequestRW2) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForTimeseries := "[]TimeSeriesRW2{"
	for _, f := range this.Timeseries {
		repeatedStringForTimeseries += strings.Replace(strings.Replace(f.String(), "TimeSeriesRW2", "TimeSeriesRW2", 1), `&`, ``, 1) + ","
	}
	repeatedStringForTimeseries += "}"
	s := strings.Join([]string{`&WriteRequestRW2{`,
		`Symbols:` + fmt.Sprintf("%v", this.Symbols) + `,`,
		`Timeseries:` + repeatedStringForTimeseries + `,`,
		`}`,
	}, "")
	return s
}
func (this *TimeSeriesRW2) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForSamples := "[]Sample{"
	for _, f := range this.Samples {
		repeatedStringForSamples += strings.Replace(strings.Replace(f.String(), "Sample", "Sample", 1), `&`, ``, 1) + ","
	}
	repeatedStringForSamples += "}"
	repeatedStringForHistograms := "[]Histogram{"
	for _, f := range this.Histograms {
		repeatedStringForHistograms += strings.Replace(strings.Replace(f.String(), "Histogram", "Histogram", 1), `&`, ``, 1) + ","
	}
	repeatedStringForHistograms += "}"
	repeatedStringForExemplars := "[]ExemplarRW2{"
	for _, f := range this.Exemplars {
		repeatedStringForExemplars += strings.Replace(strings.Replace(f.String(), "ExemplarRW2", "ExemplarRW2", 1), `&`, ``, 1) + ","
	}
	repeatedStringForExemplars += "}"
	s := strings.Join([]string{`&TimeSeriesRW2{`,
		`LabelsRefs:` + fmt.Sprintf("%v", this.LabelsRefs) + `,`,
		`Samples:` + repeatedStringForSamples + `,`,
		`Histograms:` + repeatedStringForHistograms + `,`,
		`Exemplars:` + repeatedStringForExemplars + `,`,
		`Metadata:` + strings.Replace(strings.Replace(this.Metadata.String(), "MetadataRW2", "MetadataRW2", 1), `&`, ``, 1) + `,`,
		`CreatedTimestamp:` + fmt.Sprintf("%v", this.CreatedTimestamp) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ExemplarRW2) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ExemplarRW2{`,
		`LabelsRefs:` + fmt.Sprintf("%v", this.LabelsRefs) + `,`,
		`Value:` + fmt.Sprintf("%v", this.Value) + `,`,
		`Timestamp:` + fmt.Sprintf("%v", this.Timestamp) + `,`,
		`}`,
	}, "")
	return s
}
func (this *MetadataRW2) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&MetadataRW2{`,
		`Type:` + fmt.Sprintf("%v", this.Type) + `,`,
		`HelpRef:` + fmt.Sprintf("%v", this.HelpRef) + `,`,
		`UnitRef:` + fmt.Sprintf("%v", this.UnitRef) + `,`,
		`}`,
	}, "")
	return s
}
func valueToStringMimir(v interface{}) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("*%v", pv)
}
func (m *WriteRequest) Unmarshal(dAtA []byte) error {
	var metadata metadataSet
	seenFirstSymbol := false

	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMimir
			}
			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: WriteRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: WriteRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if m.unmarshalFromRW2 {
				return errorUnexpectedRW1Timeseries
			}
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Timeseries", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMimir
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMimir
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMimir
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Timeseries = append(m.Timeseries, PreallocTimeseries{})
			m.Timeseries[len(m.Timeseries)-1].skipUnmarshalingExemplars = m.skipUnmarshalingExemplars
			if err := m.Timeseries[len(m.Timeseries)-1].Unmarshal(dAtA[iNdEx:postIndex], nil, nil, m.skipNormalizeMetadataMetricName); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Source", wireType)
			}
			m.Source = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMimir
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Source |= WriteRequest_SourceEnum(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if m.unmarshalFromRW2 {
				return errorUnexpectedRW1Metadata
			}
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMimir
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMimir
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMimir
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Metadata = append(m.Metadata, &MetricMetadata{})
			if err := m.Metadata[len(m.Metadata)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if !m.unmarshalFromRW2 {
				return errorUnexpectedRW2Symbols
			}
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SymbolsRW2", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMimir
				}
				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 ErrInvalidLengthMimir
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMimir
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if !seenFirstSymbol && intStringLen > 0 {
				return errorInvalidFirstSymbol
			}
			seenFirstSymbol = true
			m.rw2symbols.append(yoloString(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 5:
			if !m.unmarshalFromRW2 {
				return errorUnexpectedRW2Timeseries
			}
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TimeseriesRW2", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMimir
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMimir
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMimir
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Timeseries = append(m.Timeseries, PreallocTimeseries{})
			m.Timeseries[len(m.Timeseries)-1].skipUnmarshalingExemplars = m.skipUnmarshalingExemplars
			if metadata == nil {
				metadata = metadataSetFromSettings(m.skipDeduplicateMetadata)
			}
			if err := m.Timeseries[len(m.Timeseries)-1].Unmarshal(dAtA[iNdEx:postIndex], &m.rw2symbols, metadata, m.skipNormalizeMetadataMetricName); err != nil {
				return err
			}
			iNdEx = postIndex
		case 1000:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SkipLabelValidation", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMimir
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.SkipLabelValidation = bool(v != 0)
		case 1001:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SkipLabelCountValidation", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMimir
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.SkipLabelCountValidation = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipMimir(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMimir
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}

	if m.unmarshalFromRW2 {
		if metadata != nil {
			m.Metadata = metadata.slice()
		}
		m.rw2symbols.releasePages()
	}

	return nil
}
func (m *WriteResponse) 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 ErrIntOverflowMimir
			}
			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: WriteResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: WriteResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipMimir(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMimir
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ErrorDetails) 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 ErrIntOverflowMimir
			}
			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: ErrorDetails: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ErrorDetails: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Cause", wireType)
			}
			m.Cause = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMimir
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Cause |= ErrorCause(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Soft", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMimir
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Soft = bool(v != 0)
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RejectedSamples", wireType)
			}
			m.RejectedSamples = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMimir
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RejectedSamples |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMimir(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMimir
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TimeSeries) 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 ErrIntOverflowMimir
			}
			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: TimeSeries: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TimeSeries: 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 ErrIntOverflowMimir
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMimir
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMimir
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Labels = append(m.Labels, UnsafeMutableLabel{})
			if err := m.Labels[len(m.Labels)-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 Samples", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMimir
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMimir
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMimir
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Samples = append(m.Samples, Sample{})
			if err := m.Samples[len(m.Samples)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Exemplars", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMimir
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMimir
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMimir
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if !m.SkipUnmarshalingExemplars {
				m.Exemplars = append(m.Exemplars, Exemplar{})
				if err := m.Exemplars[len(m.Exemplars)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
					return err
				}
			}
			iNdEx = postIndex
		case 4:
			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 ErrIntOverflowMimir
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMimir
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMimir
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Histograms = append(m.Histograms, Histogram{})
			if err := m.Histograms[len(m.Histograms)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CreatedTimestamp", wireType)
			}
			m.CreatedTimestamp = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMimir
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CreatedTimestamp |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMimir(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMimir
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Sample) 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 ErrIntOverflowMimir
			}
			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: Sample: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Sample: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.Value = float64(math.Float64frombits(v))
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TimestampMs", wireType)
			}
			m.TimestampMs = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMimir
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TimestampMs |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMimir(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMimir
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MetricMetadata) 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 ErrIntOverflowMimir
			}
			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: MetricMetadata: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MetricMetadata: 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 ErrIntOverflowMimir
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= MetricMetadata_MetricType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MetricFamilyName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMimir
				}
				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 ErrInvalidLengthMimir
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMimir
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MetricFamilyName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Help", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMimir
				}
				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 ErrInvalidLengthMimir
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMimir
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Help = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Unit", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMimir
				}
				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 ErrInvalidLengthMimir
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMimir
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Unit = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMimir(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMimir
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Metric) 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 ErrIntOverflowMimir
			}
			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: Metric: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Metric: 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 ErrIntOverflowMimir
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMimir
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMimir
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Labels = append(m.Labels, UnsafeMutableLabel{})
			if err := m.Labels[len(m.Labels)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMimir(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMimir
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Exemplar) 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 ErrIntOverflowMimir
			}
			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: Exemplar: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Exemplar: 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 ErrIntOverflowMimir
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMimir
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMimir
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Labels = append(m.Labels, UnsafeMutableLabel{})
			if err := m.Labels[len(m.Labels)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.Value = float64(math.Float64frombits(v))
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TimestampMs", wireType)
			}
			m.TimestampMs = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMimir
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TimestampMs |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMimir(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMimir
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Histogram) 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 ErrIntOverflowMimir
			}
			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: Histogram: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Histogram: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CountInt", wireType)
			}
			var v uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMimir
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Count = &Histogram_CountInt{v}
		case 2:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field CountFloat", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.Count = &Histogram_CountFloat{float64(math.Float64frombits(v))}
		case 3:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sum", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.Sum = float64(math.Float64frombits(v))
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Schema", wireType)
			}
			var v int32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMimir
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31))
			m.Schema = v
		case 5:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field ZeroThreshold", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.ZeroThreshold = float64(math.Float64frombits(v))
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ZeroCountInt", wireType)
			}
			var v uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMimir
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.ZeroCount = &Histogram_ZeroCountInt{v}
		case 7:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field ZeroCountFloat", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.ZeroCount = &Histogram_ZeroCountFloat{float64(math.Float64frombits(v))}
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NegativeSpans", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMimir
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMimir
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMimir
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NegativeSpans = append(m.NegativeSpans, BucketSpan{})
			if err := m.NegativeSpans[len(m.NegativeSpans)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 9:
			if wireType == 0 {
				var v uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowMimir
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63)
				m.NegativeDeltas = append(m.NegativeDeltas, int64(v))
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowMimir
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthMimir
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthMimir
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.NegativeDeltas) == 0 {
					m.NegativeDeltas = make([]int64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowMimir
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63)
					m.NegativeDeltas = append(m.NegativeDeltas, int64(v))
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field NegativeDeltas", wireType)
			}
		case 10:
			if wireType == 1 {
				var v uint64
				if (iNdEx + 8) > l {
					return io.ErrUnexpectedEOF
				}
				v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
				iNdEx += 8
				v2 := float64(math.Float64frombits(v))
				m.NegativeCounts = append(m.NegativeCounts, v2)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowMimir
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthMimir
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthMimir
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				elementCount = packedLen / 8
				if elementCount != 0 && len(m.NegativeCounts) == 0 {
					m.NegativeCounts = make([]float64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint64
					if (iNdEx + 8) > l {
						return io.ErrUnexpectedEOF
					}
					v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
					iNdEx += 8
					v2 := float64(math.Float64frombits(v))
					m.NegativeCounts = append(m.NegativeCounts, v2)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field NegativeCounts", wireType)
			}
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PositiveSpans", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMimir
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMimir
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMimir
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PositiveSpans = append(m.PositiveSpans, BucketSpan{})
			if err := m.PositiveSpans[len(m.PositiveSpans)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 12:
			if wireType == 0 {
				var v uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowMimir
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63)
				m.PositiveDeltas = append(m.PositiveDeltas, int64(v))
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowMimir
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthMimir
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthMimir
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.PositiveDeltas) == 0 {
					m.PositiveDeltas = make([]int64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowMimir
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63)
					m.PositiveDeltas = append(m.PositiveDeltas, int64(v))
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field PositiveDeltas", wireType)
			}
		case 13:
			if wireType == 1 {
				var v uint64
				if (iNdEx + 8) > l {
					return io.ErrUnexpectedEOF
				}
				v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
				iNdEx += 8
				v2 := float64(math.Float64frombits(v))
				m.PositiveCounts = append(m.PositiveCounts, v2)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowMimir
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthMimir
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthMimir
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				elementCount = packedLen / 8
				if elementCount != 0 && len(m.PositiveCounts) == 0 {
					m.PositiveCounts = make([]float64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint64
					if (iNdEx + 8) > l {
						return io.ErrUnexpectedEOF
					}
					v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
					iNdEx += 8
					v2 := float64(math.Float64frombits(v))
					m.PositiveCounts = append(m.PositiveCounts, v2)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field PositiveCounts", wireType)
			}
		case 14:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ResetHint", wireType)
			}
			m.ResetHint = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMimir
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ResetHint |= Histogram_ResetHint(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 15:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType)
			}
			m.Timestamp = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMimir
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Timestamp |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 16:
			if wireType == 1 {
				var v uint64
				if (iNdEx + 8) > l {
					return io.ErrUnexpectedEOF
				}
				v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
				iNdEx += 8
				v2 := float64(math.Float64frombits(v))
				m.CustomValues = append(m.CustomValues, v2)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowMimir
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthMimir
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthMimir
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				elementCount = packedLen / 8
				if elementCount != 0 && len(m.CustomValues) == 0 {
					m.CustomValues = make([]float64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint64
					if (iNdEx + 8) > l {
						return io.ErrUnexpectedEOF
					}
					v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
					iNdEx += 8
					v2 := float64(math.Float64frombits(v))
					m.CustomValues = append(m.CustomValues, v2)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field CustomValues", wireType)
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMimir(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMimir
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *FloatHistogram) 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 ErrIntOverflowMimir
			}
			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: FloatHistogram: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: FloatHistogram: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 2:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field Count", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.Count = float64(math.Float64frombits(v))
		case 3:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sum", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.Sum = float64(math.Float64frombits(v))
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Schema", wireType)
			}
			var v int32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMimir
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31))
			m.Schema = v
		case 5:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field ZeroThreshold", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.ZeroThreshold = float64(math.Float64frombits(v))
		case 7:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field ZeroCount", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.ZeroCount = float64(math.Float64frombits(v))
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NegativeSpans", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMimir
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMimir
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMimir
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NegativeSpans = append(m.NegativeSpans, BucketSpan{})
			if err := m.NegativeSpans[len(m.NegativeSpans)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 10:
			if wireType == 1 {
				var v uint64
				if (iNdEx + 8) > l {
					return io.ErrUnexpectedEOF
				}
				v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
				iNdEx += 8
				v2 := float64(math.Float64frombits(v))
				m.NegativeBuckets = append(m.NegativeBuckets, v2)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowMimir
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthMimir
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthMimir
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				elementCount = packedLen / 8
				if elementCount != 0 && len(m.NegativeBuckets) == 0 {
					m.NegativeBuckets = make([]float64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint64
					if (iNdEx + 8) > l {
						return io.ErrUnexpectedEOF
					}
					v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
					iNdEx += 8
					v2 := float64(math.Float64frombits(v))
					m.NegativeBuckets = append(m.NegativeBuckets, v2)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field NegativeBuckets", wireType)
			}
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PositiveSpans", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMimir
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMimir
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMimir
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PositiveSpans = append(m.PositiveSpans, BucketSpan{})
			if err := m.PositiveSpans[len(m.PositiveSpans)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 13:
			if wireType == 1 {
				var v uint64
				if (iNdEx + 8) > l {
					return io.ErrUnexpectedEOF
				}
				v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
				iNdEx += 8
				v2 := float64(math.Float64frombits(v))
				m.PositiveBuckets = append(m.PositiveBuckets, v2)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowMimir
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthMimir
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthMimir
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				elementCount = packedLen / 8
				if elementCount != 0 && len(m.PositiveBuckets) == 0 {
					m.PositiveBuckets = make([]float64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint64
					if (iNdEx + 8) > l {
						return io.ErrUnexpectedEOF
					}
					v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
					iNdEx += 8
					v2 := float64(math.Float64frombits(v))
					m.PositiveBuckets = append(m.PositiveBuckets, v2)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field PositiveBuckets", wireType)
			}
		case 14:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CounterResetHint", wireType)
			}
			m.CounterResetHint = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMimir
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CounterResetHint |= github_com_prometheus_prometheus_model_histogram.CounterResetHint(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 16:
			if wireType == 1 {
				var v uint64
				if (iNdEx + 8) > l {
					return io.ErrUnexpectedEOF
				}
				v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
				iNdEx += 8
				v2 := float64(math.Float64frombits(v))
				m.CustomValues = append(m.CustomValues, v2)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowMimir
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthMimir
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthMimir
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				elementCount = packedLen / 8
				if elementCount != 0 && len(m.CustomValues) == 0 {
					m.CustomValues = make([]float64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint64
					if (iNdEx + 8) > l {
						return io.ErrUnexpectedEOF
					}
					v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
					iNdEx += 8
					v2 := float64(math.Float64frombits(v))
					m.CustomValues = append(m.CustomValues, v2)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field CustomValues", wireType)
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMimir(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMimir
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BucketSpan) 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 ErrIntOverflowMimir
			}
			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: BucketSpan: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BucketSpan: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Offset", wireType)
			}
			var v int32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMimir
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31))
			m.Offset = v
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Length", wireType)
			}
			m.Length = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMimir
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Length |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMimir(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMimir
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SampleHistogram) 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 ErrIntOverflowMimir
			}
			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: SampleHistogram: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SampleHistogram: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field Count", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.Count = float64(math.Float64frombits(v))
		case 2:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sum", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.Sum = float64(math.Float64frombits(v))
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Buckets", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMimir
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMimir
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMimir
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Buckets = append(m.Buckets, &HistogramBucket{})
			if err := m.Buckets[len(m.Buckets)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMimir(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMimir
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *HistogramBucket) 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 ErrIntOverflowMimir
			}
			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: HistogramBucket: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: HistogramBucket: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Boundaries", wireType)
			}
			m.Boundaries = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMimir
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Boundaries |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field Lower", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.Lower = float64(math.Float64frombits(v))
		case 3:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field Upper", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.Upper = float64(math.Float64frombits(v))
		case 4:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field Count", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.Count = float64(math.Float64frombits(v))
		default:
			iNdEx = preIndex
			skippy, err := skipMimir(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMimir
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueryResponse) 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 ErrIntOverflowMimir
			}
			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: QueryResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			m.Status = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMimir
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Status |= QueryStatus(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ErrorType", wireType)
			}
			m.ErrorType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMimir
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ErrorType |= QueryErrorType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMimir
				}
				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 ErrInvalidLengthMimir
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMimir
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Error = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field String_", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMimir
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMimir
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMimir
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &StringData{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Data = &QueryResponse_String_{v}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Vector", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMimir
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMimir
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMimir
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &VectorData{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Data = &QueryResponse_Vector{v}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Scalar", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMimir
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMimir
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMimir
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ScalarData{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Data = &QueryResponse_Scalar{v}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Matrix", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMimir
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMimir
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMimir
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &MatrixData{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Data = &QueryResponse_Matrix{v}
			iNdEx = postIndex
		case 8:
			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 ErrIntOverflowMimir
				}
				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 ErrInvalidLengthMimir
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMimir
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Warnings = append(m.Warnings, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 9:
			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 ErrIntOverflowMimir
				}
				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 ErrInvalidLengthMimir
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMimir
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Infos = append(m.Infos, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMimir(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMimir
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *VectorSample) 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 ErrIntOverflowMimir
			}
			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: VectorSample: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: VectorSample: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Metric", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMimir
				}
				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 ErrInvalidLengthMimir
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMimir
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Metric = append(m.Metric, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 2:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.Value = float64(math.Float64frombits(v))
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TimestampMs", wireType)
			}
			m.TimestampMs = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMimir
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TimestampMs |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMimir(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMimir
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ScalarData) 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 ErrIntOverflowMimir
			}
			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: ScalarData: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ScalarData: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.Value = float64(math.Float64frombits(v))
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TimestampMs", wireType)
			}
			m.TimestampMs = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMimir
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TimestampMs |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMimir(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMimir
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MatrixData) 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 ErrIntOverflowMimir
			}
			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: MatrixData: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MatrixData: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			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 ErrIntOverflowMimir
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMimir
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMimir
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Series = append(m.Series, MatrixSeries{})
			if err := m.Series[len(m.Series)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMimir(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMimir
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *WriteRequestRW2) 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 ErrIntOverflowMimir
			}
			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: WriteRequestRW2: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: WriteRequestRW2: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Symbols", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMimir
				}
				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 ErrInvalidLengthMimir
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMimir
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Symbols = append(m.Symbols, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Timeseries", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMimir
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMimir
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMimir
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Timeseries = append(m.Timeseries, TimeSeriesRW2{})
			if err := m.Timeseries[len(m.Timeseries)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMimir(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMimir
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TimeSeriesRW2) Unmarshal(dAtA []byte) error {
	return errorInternalRW2
}
func (m *TimeSeries) UnmarshalRW2(dAtA []byte, symbols *rw2PagedSymbols, metadata metadataSet, skipNormalizeMetricName bool) error {
	var metricName string
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMimir
			}
			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: TimeSeriesRW2: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TimeSeriesRW2: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType == 0 {
				return errorOddNumberOfLabelRefs
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowMimir
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthMimir
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthMimir
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount%2 != 0 {
					return errorOddNumberOfLabelRefs
				}
				if elementCount != 0 && len(m.Labels) == 0 {
					m.Labels = make([]LabelAdapter, 0, elementCount/2)
				}
				idx := 0
				metricNameLabel := false
				for iNdEx < postIndex {
					var v uint32
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowMimir
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= uint32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if idx%2 == 0 {
						labelName, err := symbols.get(v)
						if err != nil {
							return errorInvalidLabelRef
						}
						m.Labels = append(m.Labels, LabelAdapter{Name: labelName})
						if labelName == "__name__" {
							metricNameLabel = true
						}
					} else {
						labelValue, err := symbols.get(v)
						if err != nil {
							return errorInvalidLabelRef
						}
						m.Labels[len(m.Labels)-1].Value = labelValue
						if metricNameLabel {
							metricName = labelValue
							metricNameLabel = false
						}
					}
					idx++
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field LabelsRefs", wireType)
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Samples", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMimir
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMimir
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMimir
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Samples = append(m.Samples, Sample{})
			if err := m.Samples[len(m.Samples)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			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 ErrIntOverflowMimir
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMimir
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMimir
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Histograms = append(m.Histograms, Histogram{})
			if err := m.Histograms[len(m.Histograms)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Exemplars", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMimir
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMimir
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMimir
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if !m.SkipUnmarshalingExemplars {
				m.Exemplars = append(m.Exemplars, Exemplar{})
				if err := m.Exemplars[len(m.Exemplars)-1].UnmarshalRW2(dAtA[iNdEx:postIndex], symbols); err != nil {
					return err
				}
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMimir
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMimir
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMimir
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := MetricMetadataUnmarshalRW2(dAtA[iNdEx:postIndex], symbols, metadata, metricName, skipNormalizeMetricName); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CreatedTimestamp", wireType)
			}
			m.CreatedTimestamp = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMimir
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CreatedTimestamp |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMimir(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMimir
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ExemplarRW2) Unmarshal(dAtA []byte) error {
	return errorInternalRW2
}

func (m *Exemplar) UnmarshalRW2(dAtA []byte, symbols *rw2PagedSymbols) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMimir
			}
			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: ExemplarRW2: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ExemplarRW2: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType == 0 {
				return errorOddNumberOfExemplarLabelRefs
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowMimir
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthMimir
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthMimir
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount%2 != 0 {
					return errorOddNumberOfExemplarLabelRefs
				}
				if elementCount != 0 && len(m.Labels) == 0 {
					m.Labels = make([]LabelAdapter, 0, elementCount/2)
				}
				idx := 0
				for iNdEx < postIndex {
					var v uint32
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowMimir
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= uint32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if idx%2 == 0 {
						labelName, err := symbols.get(v)
						if err != nil {
							return errorInvalidExemplarLabelRef
						}
						m.Labels = append(m.Labels, LabelAdapter{Name: labelName})
					} else {
						labelValue, err := symbols.get(v)
						if err != nil {
							return errorInvalidExemplarLabelRef
						}
						m.Labels[len(m.Labels)-1].Value = labelValue
					}
					idx++
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field LabelsRefs", wireType)
			}
		case 2:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.Value = float64(math.Float64frombits(v))
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType)
			}
			m.TimestampMs = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMimir
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TimestampMs |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMimir(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMimir
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MetadataRW2) Unmarshal(dAtA []byte) error {
	return errorInternalRW2
}
func MetricMetadataUnmarshalRW2(dAtA []byte, symbols *rw2PagedSymbols, metadata metadataSet, metricName string, skipNormalizeMetricName bool) error {
	var (
		err error
		help string
		metricType MetadataRW2_MetricType
		normalizedMetricName string
		unit string
	)
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMimir
			}
			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: MetadataRW2: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MetadataRW2: 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)
			}
			metricType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMimir
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				metricType |= MetadataRW2_MetricType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field HelpRef", wireType)
			}
			helpRef := uint32(0)
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMimir
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				helpRef |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			help, err = symbols.get(helpRef)
			if err != nil {
				return errorInvalidHelpRef
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field UnitRef", wireType)
			}
			unitRef := uint32(0)
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMimir
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				unitRef |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			unit, err = symbols.get(unitRef)
			if err != nil {
				return errorInvalidUnitRef
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMimir(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMimir
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	if skipNormalizeMetricName {
		normalizedMetricName = metricName
	} else {
		normalizedMetricName, _ = normalizeMetricName(metricName, metricType)
	}
	if len(normalizedMetricName) == 0 {
		return nil
	}
	if len(unit) > 0 || len(help) > 0 || metricType != 0 {
		metadata.add(normalizedMetricName, MetricMetadata{
			MetricFamilyName: strings.Clone(normalizedMetricName),
			Help:             strings.Clone(help),
			Unit:             strings.Clone(unit),
			Type:             MetricMetadata_MetricType(metricType),
		})
	}

	return nil
}
func skipMimir(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, ErrIntOverflowMimir
			}
			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, ErrIntOverflowMimir
				}
				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, ErrIntOverflowMimir
				}
				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, ErrInvalidLengthMimir
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupMimir
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthMimir
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthMimir        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowMimir          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupMimir = fmt.Errorf("proto: unexpected end of group")
)
