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

package datatypes

import (
	encoding_binary "encoding/binary"
	fmt "fmt"
	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	types "github.com/gogo/protobuf/types"
	io "io"
	math "math"
	math_bits "math/bits"
)

// 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 ReadGroupRequest_Group int32

const (
	// GroupNone returns all series as a single group.
	// The single GroupFrame.TagKeys will be the union of all tag keys.
	GroupNone ReadGroupRequest_Group = 0
	// GroupBy returns a group for each unique value of the specified GroupKeys.
	GroupBy ReadGroupRequest_Group = 2
)

var ReadGroupRequest_Group_name = map[int32]string{
	0: "GROUP_NONE",
	2: "GROUP_BY",
}

var ReadGroupRequest_Group_value = map[string]int32{
	"GROUP_NONE": 0,
	"GROUP_BY":   2,
}

func (x ReadGroupRequest_Group) String() string {
	return proto.EnumName(ReadGroupRequest_Group_name, int32(x))
}

func (ReadGroupRequest_Group) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_715e4bf4cdf1f73d, []int{1, 0}
}

// TODO(jlapacik): This field is only used in unit tests.
// Specifically the two tests in group_resultset_test.go.
// This field should be removed and the tests that depend
// on it refactored.
type ReadGroupRequest_HintFlags int32

const (
	HintNone     ReadGroupRequest_HintFlags = 0
	HintNoPoints ReadGroupRequest_HintFlags = 1
	HintNoSeries ReadGroupRequest_HintFlags = 2
	// HintSchemaAllTime performs schema queries without using time ranges
	HintSchemaAllTime ReadGroupRequest_HintFlags = 4
)

var ReadGroupRequest_HintFlags_name = map[int32]string{
	0: "HINT_NONE",
	1: "HINT_NO_POINTS",
	2: "HINT_NO_SERIES",
	4: "HINT_SCHEMA_ALL_TIME",
}

var ReadGroupRequest_HintFlags_value = map[string]int32{
	"HINT_NONE":            0,
	"HINT_NO_POINTS":       1,
	"HINT_NO_SERIES":       2,
	"HINT_SCHEMA_ALL_TIME": 4,
}

func (x ReadGroupRequest_HintFlags) String() string {
	return proto.EnumName(ReadGroupRequest_HintFlags_name, int32(x))
}

func (ReadGroupRequest_HintFlags) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_715e4bf4cdf1f73d, []int{1, 1}
}

type Aggregate_AggregateType int32

const (
	AggregateTypeNone  Aggregate_AggregateType = 0
	AggregateTypeSum   Aggregate_AggregateType = 1
	AggregateTypeCount Aggregate_AggregateType = 2
	AggregateTypeMin   Aggregate_AggregateType = 3
	AggregateTypeMax   Aggregate_AggregateType = 4
)

var Aggregate_AggregateType_name = map[int32]string{
	0: "NONE",
	1: "SUM",
	2: "COUNT",
	3: "MIN",
	4: "MAX",
}

var Aggregate_AggregateType_value = map[string]int32{
	"NONE":  0,
	"SUM":   1,
	"COUNT": 2,
	"MIN":   3,
	"MAX":   4,
}

func (x Aggregate_AggregateType) String() string {
	return proto.EnumName(Aggregate_AggregateType_name, int32(x))
}

func (Aggregate_AggregateType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_715e4bf4cdf1f73d, []int{2, 0}
}

type ReadResponse_FrameType int32

const (
	FrameTypeSeries ReadResponse_FrameType = 0
	FrameTypePoints ReadResponse_FrameType = 1
)

var ReadResponse_FrameType_name = map[int32]string{
	0: "SERIES",
	1: "POINTS",
}

var ReadResponse_FrameType_value = map[string]int32{
	"SERIES": 0,
	"POINTS": 1,
}

func (x ReadResponse_FrameType) String() string {
	return proto.EnumName(ReadResponse_FrameType_name, int32(x))
}

func (ReadResponse_FrameType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_715e4bf4cdf1f73d, []int{4, 0}
}

type ReadResponse_DataType int32

const (
	DataTypeFloat    ReadResponse_DataType = 0
	DataTypeInteger  ReadResponse_DataType = 1
	DataTypeUnsigned ReadResponse_DataType = 2
	DataTypeBoolean  ReadResponse_DataType = 3
	DataTypeString   ReadResponse_DataType = 4
)

var ReadResponse_DataType_name = map[int32]string{
	0: "FLOAT",
	1: "INTEGER",
	2: "UNSIGNED",
	3: "BOOLEAN",
	4: "STRING",
}

var ReadResponse_DataType_value = map[string]int32{
	"FLOAT":    0,
	"INTEGER":  1,
	"UNSIGNED": 2,
	"BOOLEAN":  3,
	"STRING":   4,
}

func (x ReadResponse_DataType) String() string {
	return proto.EnumName(ReadResponse_DataType_name, int32(x))
}

func (ReadResponse_DataType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_715e4bf4cdf1f73d, []int{4, 1}
}

type MeasurementFieldsResponse_FieldType int32

const (
	FieldTypeFloat     MeasurementFieldsResponse_FieldType = 0
	FieldTypeInteger   MeasurementFieldsResponse_FieldType = 1
	FieldTypeUnsigned  MeasurementFieldsResponse_FieldType = 2
	FieldTypeString    MeasurementFieldsResponse_FieldType = 3
	FieldTypeBoolean   MeasurementFieldsResponse_FieldType = 4
	FieldTypeUndefined MeasurementFieldsResponse_FieldType = 5
)

var MeasurementFieldsResponse_FieldType_name = map[int32]string{
	0: "FLOAT",
	1: "INTEGER",
	2: "UNSIGNED",
	3: "STRING",
	4: "BOOLEAN",
	5: "UNDEFINED",
}

var MeasurementFieldsResponse_FieldType_value = map[string]int32{
	"FLOAT":     0,
	"INTEGER":   1,
	"UNSIGNED":  2,
	"STRING":    3,
	"BOOLEAN":   4,
	"UNDEFINED": 5,
}

func (x MeasurementFieldsResponse_FieldType) String() string {
	return proto.EnumName(MeasurementFieldsResponse_FieldType_name, int32(x))
}

func (MeasurementFieldsResponse_FieldType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_715e4bf4cdf1f73d, []int{15, 0}
}

type ReadFilterRequest struct {
	ReadSource *types.Any     `protobuf:"bytes,1,opt,name=read_source,json=readSource,proto3" json:"read_source,omitempty"`
	Range      TimestampRange `protobuf:"bytes,2,opt,name=range,proto3" json:"range"`
	Predicate  *Predicate     `protobuf:"bytes,3,opt,name=predicate,proto3" json:"predicate,omitempty"`
}

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

var xxx_messageInfo_ReadFilterRequest proto.InternalMessageInfo

type ReadGroupRequest struct {
	ReadSource *types.Any     `protobuf:"bytes,1,opt,name=read_source,json=readSource,proto3" json:"read_source,omitempty"`
	Range      TimestampRange `protobuf:"bytes,2,opt,name=range,proto3" json:"range"`
	Predicate  *Predicate     `protobuf:"bytes,3,opt,name=predicate,proto3" json:"predicate,omitempty"`
	// GroupKeys specifies a list of tag keys used to order the data.
	// It is dependent on the Group property to determine its behavior.
	GroupKeys []string               `protobuf:"bytes,4,rep,name=group_keys,json=groupKeys,proto3" json:"group_keys,omitempty"`
	Group     ReadGroupRequest_Group `protobuf:"varint,5,opt,name=group,proto3,enum=influxdata.platform.storage.ReadGroupRequest_Group" json:"group,omitempty"`
	Aggregate *Aggregate             `protobuf:"bytes,6,opt,name=aggregate,proto3" json:"aggregate,omitempty"`
	Hints     HintFlags              `protobuf:"fixed32,7,opt,name=hints,proto3,casttype=HintFlags" json:"hints,omitempty"`
}

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

var xxx_messageInfo_ReadGroupRequest proto.InternalMessageInfo

type Aggregate struct {
	Type Aggregate_AggregateType `protobuf:"varint,1,opt,name=type,proto3,enum=influxdata.platform.storage.Aggregate_AggregateType" json:"type,omitempty"`
}

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

var xxx_messageInfo_Aggregate proto.InternalMessageInfo

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

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

var xxx_messageInfo_Tag proto.InternalMessageInfo

// Response message for ReadFilter and ReadGroup
type ReadResponse struct {
	Frames []ReadResponse_Frame `protobuf:"bytes,1,rep,name=frames,proto3" json:"frames"`
}

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

var xxx_messageInfo_ReadResponse proto.InternalMessageInfo

type ReadResponse_Frame struct {
	// Types that are valid to be assigned to Data:
	//	*ReadResponse_Frame_Group
	//	*ReadResponse_Frame_Series
	//	*ReadResponse_Frame_FloatPoints
	//	*ReadResponse_Frame_IntegerPoints
	//	*ReadResponse_Frame_UnsignedPoints
	//	*ReadResponse_Frame_BooleanPoints
	//	*ReadResponse_Frame_StringPoints
	Data isReadResponse_Frame_Data `protobuf_oneof:"data"`
}

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

var xxx_messageInfo_ReadResponse_Frame proto.InternalMessageInfo

type isReadResponse_Frame_Data interface {
	isReadResponse_Frame_Data()
	MarshalTo([]byte) (int, error)
	Size() int
}

type ReadResponse_Frame_Group struct {
	Group *ReadResponse_GroupFrame `protobuf:"bytes,7,opt,name=group,proto3,oneof" json:"group,omitempty"`
}
type ReadResponse_Frame_Series struct {
	Series *ReadResponse_SeriesFrame `protobuf:"bytes,1,opt,name=series,proto3,oneof" json:"series,omitempty"`
}
type ReadResponse_Frame_FloatPoints struct {
	FloatPoints *ReadResponse_FloatPointsFrame `protobuf:"bytes,2,opt,name=float_points,json=floatPoints,proto3,oneof" json:"float_points,omitempty"`
}
type ReadResponse_Frame_IntegerPoints struct {
	IntegerPoints *ReadResponse_IntegerPointsFrame `protobuf:"bytes,3,opt,name=integer_points,json=integerPoints,proto3,oneof" json:"integer_points,omitempty"`
}
type ReadResponse_Frame_UnsignedPoints struct {
	UnsignedPoints *ReadResponse_UnsignedPointsFrame `protobuf:"bytes,4,opt,name=unsigned_points,json=unsignedPoints,proto3,oneof" json:"unsigned_points,omitempty"`
}
type ReadResponse_Frame_BooleanPoints struct {
	BooleanPoints *ReadResponse_BooleanPointsFrame `protobuf:"bytes,5,opt,name=boolean_points,json=booleanPoints,proto3,oneof" json:"boolean_points,omitempty"`
}
type ReadResponse_Frame_StringPoints struct {
	StringPoints *ReadResponse_StringPointsFrame `protobuf:"bytes,6,opt,name=string_points,json=stringPoints,proto3,oneof" json:"string_points,omitempty"`
}

func (*ReadResponse_Frame_Group) isReadResponse_Frame_Data()          {}
func (*ReadResponse_Frame_Series) isReadResponse_Frame_Data()         {}
func (*ReadResponse_Frame_FloatPoints) isReadResponse_Frame_Data()    {}
func (*ReadResponse_Frame_IntegerPoints) isReadResponse_Frame_Data()  {}
func (*ReadResponse_Frame_UnsignedPoints) isReadResponse_Frame_Data() {}
func (*ReadResponse_Frame_BooleanPoints) isReadResponse_Frame_Data()  {}
func (*ReadResponse_Frame_StringPoints) isReadResponse_Frame_Data()   {}

func (m *ReadResponse_Frame) GetData() isReadResponse_Frame_Data {
	if m != nil {
		return m.Data
	}
	return nil
}

func (m *ReadResponse_Frame) GetGroup() *ReadResponse_GroupFrame {
	if x, ok := m.GetData().(*ReadResponse_Frame_Group); ok {
		return x.Group
	}
	return nil
}

func (m *ReadResponse_Frame) GetSeries() *ReadResponse_SeriesFrame {
	if x, ok := m.GetData().(*ReadResponse_Frame_Series); ok {
		return x.Series
	}
	return nil
}

func (m *ReadResponse_Frame) GetFloatPoints() *ReadResponse_FloatPointsFrame {
	if x, ok := m.GetData().(*ReadResponse_Frame_FloatPoints); ok {
		return x.FloatPoints
	}
	return nil
}

func (m *ReadResponse_Frame) GetIntegerPoints() *ReadResponse_IntegerPointsFrame {
	if x, ok := m.GetData().(*ReadResponse_Frame_IntegerPoints); ok {
		return x.IntegerPoints
	}
	return nil
}

func (m *ReadResponse_Frame) GetUnsignedPoints() *ReadResponse_UnsignedPointsFrame {
	if x, ok := m.GetData().(*ReadResponse_Frame_UnsignedPoints); ok {
		return x.UnsignedPoints
	}
	return nil
}

func (m *ReadResponse_Frame) GetBooleanPoints() *ReadResponse_BooleanPointsFrame {
	if x, ok := m.GetData().(*ReadResponse_Frame_BooleanPoints); ok {
		return x.BooleanPoints
	}
	return nil
}

func (m *ReadResponse_Frame) GetStringPoints() *ReadResponse_StringPointsFrame {
	if x, ok := m.GetData().(*ReadResponse_Frame_StringPoints); ok {
		return x.StringPoints
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*ReadResponse_Frame) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*ReadResponse_Frame_Group)(nil),
		(*ReadResponse_Frame_Series)(nil),
		(*ReadResponse_Frame_FloatPoints)(nil),
		(*ReadResponse_Frame_IntegerPoints)(nil),
		(*ReadResponse_Frame_UnsignedPoints)(nil),
		(*ReadResponse_Frame_BooleanPoints)(nil),
		(*ReadResponse_Frame_StringPoints)(nil),
	}
}

type ReadResponse_GroupFrame struct {
	// TagKeys
	TagKeys [][]byte `protobuf:"bytes,1,rep,name=tag_keys,json=tagKeys,proto3" json:"tag_keys,omitempty"`
	// PartitionKeyVals is the values of the partition key for this group, order matching ReadGroupRequest.GroupKeys
	PartitionKeyVals [][]byte `protobuf:"bytes,2,rep,name=partition_key_vals,json=partitionKeyVals,proto3" json:"partition_key_vals,omitempty"`
}

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

var xxx_messageInfo_ReadResponse_GroupFrame proto.InternalMessageInfo

type ReadResponse_SeriesFrame struct {
	Tags     []Tag                 `protobuf:"bytes,1,rep,name=tags,proto3" json:"tags"`
	DataType ReadResponse_DataType `protobuf:"varint,2,opt,name=data_type,json=dataType,proto3,enum=influxdata.platform.storage.ReadResponse_DataType" json:"data_type,omitempty"`
}

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

var xxx_messageInfo_ReadResponse_SeriesFrame proto.InternalMessageInfo

type ReadResponse_FloatPointsFrame struct {
	Timestamps []int64   `protobuf:"fixed64,1,rep,packed,name=timestamps,proto3" json:"timestamps,omitempty"`
	Values     []float64 `protobuf:"fixed64,2,rep,packed,name=values,proto3" json:"values,omitempty"`
}

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

var xxx_messageInfo_ReadResponse_FloatPointsFrame proto.InternalMessageInfo

type ReadResponse_IntegerPointsFrame struct {
	Timestamps []int64 `protobuf:"fixed64,1,rep,packed,name=timestamps,proto3" json:"timestamps,omitempty"`
	Values     []int64 `protobuf:"varint,2,rep,packed,name=values,proto3" json:"values,omitempty"`
}

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

var xxx_messageInfo_ReadResponse_IntegerPointsFrame proto.InternalMessageInfo

type ReadResponse_UnsignedPointsFrame struct {
	Timestamps []int64  `protobuf:"fixed64,1,rep,packed,name=timestamps,proto3" json:"timestamps,omitempty"`
	Values     []uint64 `protobuf:"varint,2,rep,packed,name=values,proto3" json:"values,omitempty"`
}

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

var xxx_messageInfo_ReadResponse_UnsignedPointsFrame proto.InternalMessageInfo

type ReadResponse_BooleanPointsFrame struct {
	Timestamps []int64 `protobuf:"fixed64,1,rep,packed,name=timestamps,proto3" json:"timestamps,omitempty"`
	Values     []bool  `protobuf:"varint,2,rep,packed,name=values,proto3" json:"values,omitempty"`
}

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

var xxx_messageInfo_ReadResponse_BooleanPointsFrame proto.InternalMessageInfo

type ReadResponse_StringPointsFrame struct {
	Timestamps []int64  `protobuf:"fixed64,1,rep,packed,name=timestamps,proto3" json:"timestamps,omitempty"`
	Values     []string `protobuf:"bytes,2,rep,name=values,proto3" json:"values,omitempty"`
}

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

var xxx_messageInfo_ReadResponse_StringPointsFrame proto.InternalMessageInfo

type Capability struct {
	// Features contains the specific features supported
	// by this capability.
	Features []string `protobuf:"bytes,1,rep,name=features,proto3" json:"features,omitempty"`
}

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

var xxx_messageInfo_Capability proto.InternalMessageInfo

type CapabilitiesResponse struct {
	// Capabilities contains the set of capabilities supported
	// by the storage engine. It is a map of method names to
	// the detailed capability information for the method.
	Caps map[string]*Capability `protobuf:"bytes,1,rep,name=caps,proto3" json:"caps,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}

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

var xxx_messageInfo_CapabilitiesResponse proto.InternalMessageInfo

// Specifies a continuous range of nanosecond timestamps.
type TimestampRange struct {
	// Start defines the inclusive lower bound.
	Start int64 `protobuf:"varint,1,opt,name=start,proto3" json:"start,omitempty"`
	// End defines the exclusive upper bound.
	End int64 `protobuf:"varint,2,opt,name=end,proto3" json:"end,omitempty"`
}

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

var xxx_messageInfo_TimestampRange proto.InternalMessageInfo

// TagKeysRequest is the request message for Storage.TagKeys.
type TagKeysRequest struct {
	TagsSource *types.Any     `protobuf:"bytes,1,opt,name=tags_source,json=tagsSource,proto3" json:"tags_source,omitempty"`
	Range      TimestampRange `protobuf:"bytes,2,opt,name=range,proto3" json:"range"`
	Predicate  *Predicate     `protobuf:"bytes,3,opt,name=predicate,proto3" json:"predicate,omitempty"`
}

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

var xxx_messageInfo_TagKeysRequest proto.InternalMessageInfo

// TagValuesRequest is the request message for Storage.TagValues.
type TagValuesRequest struct {
	TagsSource *types.Any     `protobuf:"bytes,1,opt,name=tags_source,json=tagsSource,proto3" json:"tags_source,omitempty"`
	Range      TimestampRange `protobuf:"bytes,2,opt,name=range,proto3" json:"range"`
	Predicate  *Predicate     `protobuf:"bytes,3,opt,name=predicate,proto3" json:"predicate,omitempty"`
	TagKey     string         `protobuf:"bytes,4,opt,name=tag_key,json=tagKey,proto3" json:"tag_key,omitempty"`
}

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

var xxx_messageInfo_TagValuesRequest proto.InternalMessageInfo

// Response message for Storage.TagKeys, Storage.TagValues Storage.MeasurementNames,
// Storage.MeasurementTagKeys and Storage.MeasurementTagValues.
type StringValuesResponse struct {
	Values [][]byte `protobuf:"bytes,1,rep,name=values,proto3" json:"values,omitempty"`
}

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

var xxx_messageInfo_StringValuesResponse proto.InternalMessageInfo

// MeasurementNamesRequest is the request message for Storage.MeasurementNames.
type MeasurementNamesRequest struct {
	Source *types.Any     `protobuf:"bytes,1,opt,name=source,proto3" json:"source,omitempty"`
	Range  TimestampRange `protobuf:"bytes,2,opt,name=range,proto3" json:"range"`
}

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

var xxx_messageInfo_MeasurementNamesRequest proto.InternalMessageInfo

// MeasurementTagKeysRequest is the request message for Storage.MeasurementTagKeys.
type MeasurementTagKeysRequest struct {
	Source      *types.Any     `protobuf:"bytes,1,opt,name=source,proto3" json:"source,omitempty"`
	Measurement string         `protobuf:"bytes,2,opt,name=measurement,proto3" json:"measurement,omitempty"`
	Range       TimestampRange `protobuf:"bytes,3,opt,name=range,proto3" json:"range"`
	Predicate   *Predicate     `protobuf:"bytes,4,opt,name=predicate,proto3" json:"predicate,omitempty"`
}

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

var xxx_messageInfo_MeasurementTagKeysRequest proto.InternalMessageInfo

// MeasurementTagValuesRequest is the request message for Storage.MeasurementTagValues.
type MeasurementTagValuesRequest struct {
	Source      *types.Any     `protobuf:"bytes,1,opt,name=source,proto3" json:"source,omitempty"`
	Measurement string         `protobuf:"bytes,2,opt,name=measurement,proto3" json:"measurement,omitempty"`
	TagKey      string         `protobuf:"bytes,3,opt,name=tag_key,json=tagKey,proto3" json:"tag_key,omitempty"`
	Range       TimestampRange `protobuf:"bytes,4,opt,name=range,proto3" json:"range"`
	Predicate   *Predicate     `protobuf:"bytes,5,opt,name=predicate,proto3" json:"predicate,omitempty"`
}

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

var xxx_messageInfo_MeasurementTagValuesRequest proto.InternalMessageInfo

// MeasurementFieldsRequest is the request message for Storage.MeasurementFields.
type MeasurementFieldsRequest struct {
	Source      *types.Any     `protobuf:"bytes,1,opt,name=source,proto3" json:"source,omitempty"`
	Measurement string         `protobuf:"bytes,2,opt,name=measurement,proto3" json:"measurement,omitempty"`
	Range       TimestampRange `protobuf:"bytes,3,opt,name=range,proto3" json:"range"`
	Predicate   *Predicate     `protobuf:"bytes,4,opt,name=predicate,proto3" json:"predicate,omitempty"`
}

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

var xxx_messageInfo_MeasurementFieldsRequest proto.InternalMessageInfo

// MeasurementFieldsResponse is the response message for Storage.MeasurementFields.
type MeasurementFieldsResponse struct {
	Fields []MeasurementFieldsResponse_MessageField `protobuf:"bytes,1,rep,name=fields,proto3" json:"fields"`
}

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

var xxx_messageInfo_MeasurementFieldsResponse proto.InternalMessageInfo

type MeasurementFieldsResponse_MessageField struct {
	Key       string                              `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	Type      MeasurementFieldsResponse_FieldType `protobuf:"varint,2,opt,name=type,proto3,enum=influxdata.platform.storage.MeasurementFieldsResponse_FieldType" json:"type,omitempty"`
	Timestamp int64                               `protobuf:"fixed64,3,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
}

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

var xxx_messageInfo_MeasurementFieldsResponse_MessageField proto.InternalMessageInfo

type ReadWindowAggregateRequest struct {
	ReadSource  *types.Any     `protobuf:"bytes,1,opt,name=read_source,json=readSource,proto3" json:"read_source,omitempty"`
	Range       TimestampRange `protobuf:"bytes,2,opt,name=range,proto3" json:"range"`
	Predicate   *Predicate     `protobuf:"bytes,3,opt,name=predicate,proto3" json:"predicate,omitempty"`
	WindowEvery int64          `protobuf:"varint,4,opt,name=WindowEvery,proto3" json:"WindowEvery,omitempty"`
	Aggregate   []*Aggregate   `protobuf:"bytes,5,rep,name=aggregate,proto3" json:"aggregate,omitempty"`
}

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

var xxx_messageInfo_ReadWindowAggregateRequest proto.InternalMessageInfo

func init() {
	proto.RegisterEnum("influxdata.platform.storage.ReadGroupRequest_Group", ReadGroupRequest_Group_name, ReadGroupRequest_Group_value)
	proto.RegisterEnum("influxdata.platform.storage.ReadGroupRequest_HintFlags", ReadGroupRequest_HintFlags_name, ReadGroupRequest_HintFlags_value)
	proto.RegisterEnum("influxdata.platform.storage.Aggregate_AggregateType", Aggregate_AggregateType_name, Aggregate_AggregateType_value)
	proto.RegisterEnum("influxdata.platform.storage.ReadResponse_FrameType", ReadResponse_FrameType_name, ReadResponse_FrameType_value)
	proto.RegisterEnum("influxdata.platform.storage.ReadResponse_DataType", ReadResponse_DataType_name, ReadResponse_DataType_value)
	proto.RegisterEnum("influxdata.platform.storage.MeasurementFieldsResponse_FieldType", MeasurementFieldsResponse_FieldType_name, MeasurementFieldsResponse_FieldType_value)
	proto.RegisterType((*ReadFilterRequest)(nil), "influxdata.platform.storage.ReadFilterRequest")
	proto.RegisterType((*ReadGroupRequest)(nil), "influxdata.platform.storage.ReadGroupRequest")
	proto.RegisterType((*Aggregate)(nil), "influxdata.platform.storage.Aggregate")
	proto.RegisterType((*Tag)(nil), "influxdata.platform.storage.Tag")
	proto.RegisterType((*ReadResponse)(nil), "influxdata.platform.storage.ReadResponse")
	proto.RegisterType((*ReadResponse_Frame)(nil), "influxdata.platform.storage.ReadResponse.Frame")
	proto.RegisterType((*ReadResponse_GroupFrame)(nil), "influxdata.platform.storage.ReadResponse.GroupFrame")
	proto.RegisterType((*ReadResponse_SeriesFrame)(nil), "influxdata.platform.storage.ReadResponse.SeriesFrame")
	proto.RegisterType((*ReadResponse_FloatPointsFrame)(nil), "influxdata.platform.storage.ReadResponse.FloatPointsFrame")
	proto.RegisterType((*ReadResponse_IntegerPointsFrame)(nil), "influxdata.platform.storage.ReadResponse.IntegerPointsFrame")
	proto.RegisterType((*ReadResponse_UnsignedPointsFrame)(nil), "influxdata.platform.storage.ReadResponse.UnsignedPointsFrame")
	proto.RegisterType((*ReadResponse_BooleanPointsFrame)(nil), "influxdata.platform.storage.ReadResponse.BooleanPointsFrame")
	proto.RegisterType((*ReadResponse_StringPointsFrame)(nil), "influxdata.platform.storage.ReadResponse.StringPointsFrame")
	proto.RegisterType((*Capability)(nil), "influxdata.platform.storage.Capability")
	proto.RegisterType((*CapabilitiesResponse)(nil), "influxdata.platform.storage.CapabilitiesResponse")
	proto.RegisterMapType((map[string]*Capability)(nil), "influxdata.platform.storage.CapabilitiesResponse.CapsEntry")
	proto.RegisterType((*TimestampRange)(nil), "influxdata.platform.storage.TimestampRange")
	proto.RegisterType((*TagKeysRequest)(nil), "influxdata.platform.storage.TagKeysRequest")
	proto.RegisterType((*TagValuesRequest)(nil), "influxdata.platform.storage.TagValuesRequest")
	proto.RegisterType((*StringValuesResponse)(nil), "influxdata.platform.storage.StringValuesResponse")
	proto.RegisterType((*MeasurementNamesRequest)(nil), "influxdata.platform.storage.MeasurementNamesRequest")
	proto.RegisterType((*MeasurementTagKeysRequest)(nil), "influxdata.platform.storage.MeasurementTagKeysRequest")
	proto.RegisterType((*MeasurementTagValuesRequest)(nil), "influxdata.platform.storage.MeasurementTagValuesRequest")
	proto.RegisterType((*MeasurementFieldsRequest)(nil), "influxdata.platform.storage.MeasurementFieldsRequest")
	proto.RegisterType((*MeasurementFieldsResponse)(nil), "influxdata.platform.storage.MeasurementFieldsResponse")
	proto.RegisterType((*MeasurementFieldsResponse_MessageField)(nil), "influxdata.platform.storage.MeasurementFieldsResponse.MessageField")
	proto.RegisterType((*ReadWindowAggregateRequest)(nil), "influxdata.platform.storage.ReadWindowAggregateRequest")
}

func init() { proto.RegisterFile("storage_common.proto", fileDescriptor_715e4bf4cdf1f73d) }

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

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

func (m *ReadFilterRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Predicate != nil {
		{
			size, err := m.Predicate.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintStorageCommon(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	{
		size, err := m.Range.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintStorageCommon(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if m.ReadSource != nil {
		{
			size, err := m.ReadSource.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintStorageCommon(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *ReadGroupRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Hints != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(m.Hints))
		i--
		dAtA[i] = 0x3d
	}
	if m.Aggregate != nil {
		{
			size, err := m.Aggregate.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintStorageCommon(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	if m.Group != 0 {
		i = encodeVarintStorageCommon(dAtA, i, uint64(m.Group))
		i--
		dAtA[i] = 0x28
	}
	if len(m.GroupKeys) > 0 {
		for iNdEx := len(m.GroupKeys) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.GroupKeys[iNdEx])
			copy(dAtA[i:], m.GroupKeys[iNdEx])
			i = encodeVarintStorageCommon(dAtA, i, uint64(len(m.GroupKeys[iNdEx])))
			i--
			dAtA[i] = 0x22
		}
	}
	if m.Predicate != nil {
		{
			size, err := m.Predicate.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintStorageCommon(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	{
		size, err := m.Range.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintStorageCommon(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if m.ReadSource != nil {
		{
			size, err := m.ReadSource.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintStorageCommon(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func (m *ReadResponse_FloatPointsFrame) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Values) > 0 {
		for iNdEx := len(m.Values) - 1; iNdEx >= 0; iNdEx-- {
			f15 := math.Float64bits(float64(m.Values[iNdEx]))
			i -= 8
			encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(f15))
		}
		i = encodeVarintStorageCommon(dAtA, i, uint64(len(m.Values)*8))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Timestamps) > 0 {
		for iNdEx := len(m.Timestamps) - 1; iNdEx >= 0; iNdEx-- {
			i -= 8
			encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(m.Timestamps[iNdEx]))
		}
		i = encodeVarintStorageCommon(dAtA, i, uint64(len(m.Timestamps)*8))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *ReadResponse_IntegerPointsFrame) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Values) > 0 {
		dAtA17 := make([]byte, len(m.Values)*10)
		var j16 int
		for _, num1 := range m.Values {
			num := uint64(num1)
			for num >= 1<<7 {
				dAtA17[j16] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j16++
			}
			dAtA17[j16] = uint8(num)
			j16++
		}
		i -= j16
		copy(dAtA[i:], dAtA17[:j16])
		i = encodeVarintStorageCommon(dAtA, i, uint64(j16))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Timestamps) > 0 {
		for iNdEx := len(m.Timestamps) - 1; iNdEx >= 0; iNdEx-- {
			i -= 8
			encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(m.Timestamps[iNdEx]))
		}
		i = encodeVarintStorageCommon(dAtA, i, uint64(len(m.Timestamps)*8))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *ReadResponse_UnsignedPointsFrame) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Values) > 0 {
		dAtA19 := make([]byte, len(m.Values)*10)
		var j18 int
		for _, num := range m.Values {
			for num >= 1<<7 {
				dAtA19[j18] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j18++
			}
			dAtA19[j18] = uint8(num)
			j18++
		}
		i -= j18
		copy(dAtA[i:], dAtA19[:j18])
		i = encodeVarintStorageCommon(dAtA, i, uint64(j18))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Timestamps) > 0 {
		for iNdEx := len(m.Timestamps) - 1; iNdEx >= 0; iNdEx-- {
			i -= 8
			encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(m.Timestamps[iNdEx]))
		}
		i = encodeVarintStorageCommon(dAtA, i, uint64(len(m.Timestamps)*8))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *ReadResponse_BooleanPointsFrame) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Values) > 0 {
		for iNdEx := len(m.Values) - 1; iNdEx >= 0; iNdEx-- {
			i--
			if m.Values[iNdEx] {
				dAtA[i] = 1
			} else {
				dAtA[i] = 0
			}
		}
		i = encodeVarintStorageCommon(dAtA, i, uint64(len(m.Values)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Timestamps) > 0 {
		for iNdEx := len(m.Timestamps) - 1; iNdEx >= 0; iNdEx-- {
			i -= 8
			encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(m.Timestamps[iNdEx]))
		}
		i = encodeVarintStorageCommon(dAtA, i, uint64(len(m.Timestamps)*8))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *ReadResponse_StringPointsFrame) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Values) > 0 {
		for iNdEx := len(m.Values) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Values[iNdEx])
			copy(dAtA[i:], m.Values[iNdEx])
			i = encodeVarintStorageCommon(dAtA, i, uint64(len(m.Values[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.Timestamps) > 0 {
		for iNdEx := len(m.Timestamps) - 1; iNdEx >= 0; iNdEx-- {
			i -= 8
			encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(m.Timestamps[iNdEx]))
		}
		i = encodeVarintStorageCommon(dAtA, i, uint64(len(m.Timestamps)*8))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *CapabilitiesResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Caps) > 0 {
		for k := range m.Caps {
			v := m.Caps[k]
			baseI := i
			if v != nil {
				{
					size, err := v.MarshalToSizedBuffer(dAtA[:i])
					if err != nil {
						return 0, err
					}
					i -= size
					i = encodeVarintStorageCommon(dAtA, i, uint64(size))
				}
				i--
				dAtA[i] = 0x12
			}
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintStorageCommon(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintStorageCommon(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *TagKeysRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Predicate != nil {
		{
			size, err := m.Predicate.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintStorageCommon(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	{
		size, err := m.Range.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintStorageCommon(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if m.TagsSource != nil {
		{
			size, err := m.TagsSource.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintStorageCommon(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *TagValuesRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.TagKey) > 0 {
		i -= len(m.TagKey)
		copy(dAtA[i:], m.TagKey)
		i = encodeVarintStorageCommon(dAtA, i, uint64(len(m.TagKey)))
		i--
		dAtA[i] = 0x22
	}
	if m.Predicate != nil {
		{
			size, err := m.Predicate.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintStorageCommon(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	{
		size, err := m.Range.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintStorageCommon(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if m.TagsSource != nil {
		{
			size, err := m.TagsSource.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintStorageCommon(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

func (m *MeasurementTagKeysRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Predicate != nil {
		{
			size, err := m.Predicate.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintStorageCommon(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	{
		size, err := m.Range.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintStorageCommon(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	if len(m.Measurement) > 0 {
		i -= len(m.Measurement)
		copy(dAtA[i:], m.Measurement)
		i = encodeVarintStorageCommon(dAtA, i, uint64(len(m.Measurement)))
		i--
		dAtA[i] = 0x12
	}
	if m.Source != nil {
		{
			size, err := m.Source.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintStorageCommon(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *MeasurementTagValuesRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Predicate != nil {
		{
			size, err := m.Predicate.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintStorageCommon(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	{
		size, err := m.Range.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintStorageCommon(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x22
	if len(m.TagKey) > 0 {
		i -= len(m.TagKey)
		copy(dAtA[i:], m.TagKey)
		i = encodeVarintStorageCommon(dAtA, i, uint64(len(m.TagKey)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Measurement) > 0 {
		i -= len(m.Measurement)
		copy(dAtA[i:], m.Measurement)
		i = encodeVarintStorageCommon(dAtA, i, uint64(len(m.Measurement)))
		i--
		dAtA[i] = 0x12
	}
	if m.Source != nil {
		{
			size, err := m.Source.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintStorageCommon(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *MeasurementFieldsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Predicate != nil {
		{
			size, err := m.Predicate.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintStorageCommon(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	{
		size, err := m.Range.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintStorageCommon(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	if len(m.Measurement) > 0 {
		i -= len(m.Measurement)
		copy(dAtA[i:], m.Measurement)
		i = encodeVarintStorageCommon(dAtA, i, uint64(len(m.Measurement)))
		i--
		dAtA[i] = 0x12
	}
	if m.Source != nil {
		{
			size, err := m.Source.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintStorageCommon(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *MeasurementFieldsResponse_MessageField) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Timestamp != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(m.Timestamp))
		i--
		dAtA[i] = 0x19
	}
	if m.Type != 0 {
		i = encodeVarintStorageCommon(dAtA, i, uint64(m.Type))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Key) > 0 {
		i -= len(m.Key)
		copy(dAtA[i:], m.Key)
		i = encodeVarintStorageCommon(dAtA, i, uint64(len(m.Key)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *ReadWindowAggregateRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Aggregate) > 0 {
		for iNdEx := len(m.Aggregate) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Aggregate[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintStorageCommon(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x2a
		}
	}
	if m.WindowEvery != 0 {
		i = encodeVarintStorageCommon(dAtA, i, uint64(m.WindowEvery))
		i--
		dAtA[i] = 0x20
	}
	if m.Predicate != nil {
		{
			size, err := m.Predicate.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintStorageCommon(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	{
		size, err := m.Range.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintStorageCommon(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if m.ReadSource != nil {
		{
			size, err := m.ReadSource.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintStorageCommon(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func encodeVarintStorageCommon(dAtA []byte, offset int, v uint64) int {
	offset -= sovStorageCommon(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *ReadFilterRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ReadSource != nil {
		l = m.ReadSource.Size()
		n += 1 + l + sovStorageCommon(uint64(l))
	}
	l = m.Range.Size()
	n += 1 + l + sovStorageCommon(uint64(l))
	if m.Predicate != nil {
		l = m.Predicate.Size()
		n += 1 + l + sovStorageCommon(uint64(l))
	}
	return n
}

func (m *ReadGroupRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ReadSource != nil {
		l = m.ReadSource.Size()
		n += 1 + l + sovStorageCommon(uint64(l))
	}
	l = m.Range.Size()
	n += 1 + l + sovStorageCommon(uint64(l))
	if m.Predicate != nil {
		l = m.Predicate.Size()
		n += 1 + l + sovStorageCommon(uint64(l))
	}
	if len(m.GroupKeys) > 0 {
		for _, s := range m.GroupKeys {
			l = len(s)
			n += 1 + l + sovStorageCommon(uint64(l))
		}
	}
	if m.Group != 0 {
		n += 1 + sovStorageCommon(uint64(m.Group))
	}
	if m.Aggregate != nil {
		l = m.Aggregate.Size()
		n += 1 + l + sovStorageCommon(uint64(l))
	}
	if m.Hints != 0 {
		n += 5
	}
	return n
}

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

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

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

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

func (m *ReadResponse_Frame_Series) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Series != nil {
		l = m.Series.Size()
		n += 1 + l + sovStorageCommon(uint64(l))
	}
	return n
}
func (m *ReadResponse_Frame_FloatPoints) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.FloatPoints != nil {
		l = m.FloatPoints.Size()
		n += 1 + l + sovStorageCommon(uint64(l))
	}
	return n
}
func (m *ReadResponse_Frame_IntegerPoints) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.IntegerPoints != nil {
		l = m.IntegerPoints.Size()
		n += 1 + l + sovStorageCommon(uint64(l))
	}
	return n
}
func (m *ReadResponse_Frame_UnsignedPoints) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.UnsignedPoints != nil {
		l = m.UnsignedPoints.Size()
		n += 1 + l + sovStorageCommon(uint64(l))
	}
	return n
}
func (m *ReadResponse_Frame_BooleanPoints) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.BooleanPoints != nil {
		l = m.BooleanPoints.Size()
		n += 1 + l + sovStorageCommon(uint64(l))
	}
	return n
}
func (m *ReadResponse_Frame_StringPoints) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.StringPoints != nil {
		l = m.StringPoints.Size()
		n += 1 + l + sovStorageCommon(uint64(l))
	}
	return n
}
func (m *ReadResponse_Frame_Group) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Group != nil {
		l = m.Group.Size()
		n += 1 + l + sovStorageCommon(uint64(l))
	}
	return n
}
func (m *ReadResponse_GroupFrame) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.TagKeys) > 0 {
		for _, b := range m.TagKeys {
			l = len(b)
			n += 1 + l + sovStorageCommon(uint64(l))
		}
	}
	if len(m.PartitionKeyVals) > 0 {
		for _, b := range m.PartitionKeyVals {
			l = len(b)
			n += 1 + l + sovStorageCommon(uint64(l))
		}
	}
	return n
}

func (m *ReadResponse_SeriesFrame) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Tags) > 0 {
		for _, e := range m.Tags {
			l = e.Size()
			n += 1 + l + sovStorageCommon(uint64(l))
		}
	}
	if m.DataType != 0 {
		n += 1 + sovStorageCommon(uint64(m.DataType))
	}
	return n
}

func (m *ReadResponse_FloatPointsFrame) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Timestamps) > 0 {
		n += 1 + sovStorageCommon(uint64(len(m.Timestamps)*8)) + len(m.Timestamps)*8
	}
	if len(m.Values) > 0 {
		n += 1 + sovStorageCommon(uint64(len(m.Values)*8)) + len(m.Values)*8
	}
	return n
}

func (m *ReadResponse_IntegerPointsFrame) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Timestamps) > 0 {
		n += 1 + sovStorageCommon(uint64(len(m.Timestamps)*8)) + len(m.Timestamps)*8
	}
	if len(m.Values) > 0 {
		l = 0
		for _, e := range m.Values {
			l += sovStorageCommon(uint64(e))
		}
		n += 1 + sovStorageCommon(uint64(l)) + l
	}
	return n
}

func (m *ReadResponse_UnsignedPointsFrame) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Timestamps) > 0 {
		n += 1 + sovStorageCommon(uint64(len(m.Timestamps)*8)) + len(m.Timestamps)*8
	}
	if len(m.Values) > 0 {
		l = 0
		for _, e := range m.Values {
			l += sovStorageCommon(uint64(e))
		}
		n += 1 + sovStorageCommon(uint64(l)) + l
	}
	return n
}

func (m *ReadResponse_BooleanPointsFrame) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Timestamps) > 0 {
		n += 1 + sovStorageCommon(uint64(len(m.Timestamps)*8)) + len(m.Timestamps)*8
	}
	if len(m.Values) > 0 {
		n += 1 + sovStorageCommon(uint64(len(m.Values))) + len(m.Values)*1
	}
	return n
}

func (m *ReadResponse_StringPointsFrame) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Timestamps) > 0 {
		n += 1 + sovStorageCommon(uint64(len(m.Timestamps)*8)) + len(m.Timestamps)*8
	}
	if len(m.Values) > 0 {
		for _, s := range m.Values {
			l = len(s)
			n += 1 + l + sovStorageCommon(uint64(l))
		}
	}
	return n
}

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

func (m *CapabilitiesResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Caps) > 0 {
		for k, v := range m.Caps {
			_ = k
			_ = v
			l = 0
			if v != nil {
				l = v.Size()
				l += 1 + sovStorageCommon(uint64(l))
			}
			mapEntrySize := 1 + len(k) + sovStorageCommon(uint64(len(k))) + l
			n += mapEntrySize + 1 + sovStorageCommon(uint64(mapEntrySize))
		}
	}
	return n
}

func (m *TimestampRange) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Start != 0 {
		n += 1 + sovStorageCommon(uint64(m.Start))
	}
	if m.End != 0 {
		n += 1 + sovStorageCommon(uint64(m.End))
	}
	return n
}

func (m *TagKeysRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TagsSource != nil {
		l = m.TagsSource.Size()
		n += 1 + l + sovStorageCommon(uint64(l))
	}
	l = m.Range.Size()
	n += 1 + l + sovStorageCommon(uint64(l))
	if m.Predicate != nil {
		l = m.Predicate.Size()
		n += 1 + l + sovStorageCommon(uint64(l))
	}
	return n
}

func (m *TagValuesRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TagsSource != nil {
		l = m.TagsSource.Size()
		n += 1 + l + sovStorageCommon(uint64(l))
	}
	l = m.Range.Size()
	n += 1 + l + sovStorageCommon(uint64(l))
	if m.Predicate != nil {
		l = m.Predicate.Size()
		n += 1 + l + sovStorageCommon(uint64(l))
	}
	l = len(m.TagKey)
	if l > 0 {
		n += 1 + l + sovStorageCommon(uint64(l))
	}
	return n
}

func (m *StringValuesResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Values) > 0 {
		for _, b := range m.Values {
			l = len(b)
			n += 1 + l + sovStorageCommon(uint64(l))
		}
	}
	return n
}

func (m *MeasurementNamesRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Source != nil {
		l = m.Source.Size()
		n += 1 + l + sovStorageCommon(uint64(l))
	}
	l = m.Range.Size()
	n += 1 + l + sovStorageCommon(uint64(l))
	return n
}

func (m *MeasurementTagKeysRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Source != nil {
		l = m.Source.Size()
		n += 1 + l + sovStorageCommon(uint64(l))
	}
	l = len(m.Measurement)
	if l > 0 {
		n += 1 + l + sovStorageCommon(uint64(l))
	}
	l = m.Range.Size()
	n += 1 + l + sovStorageCommon(uint64(l))
	if m.Predicate != nil {
		l = m.Predicate.Size()
		n += 1 + l + sovStorageCommon(uint64(l))
	}
	return n
}

func (m *MeasurementTagValuesRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Source != nil {
		l = m.Source.Size()
		n += 1 + l + sovStorageCommon(uint64(l))
	}
	l = len(m.Measurement)
	if l > 0 {
		n += 1 + l + sovStorageCommon(uint64(l))
	}
	l = len(m.TagKey)
	if l > 0 {
		n += 1 + l + sovStorageCommon(uint64(l))
	}
	l = m.Range.Size()
	n += 1 + l + sovStorageCommon(uint64(l))
	if m.Predicate != nil {
		l = m.Predicate.Size()
		n += 1 + l + sovStorageCommon(uint64(l))
	}
	return n
}

func (m *MeasurementFieldsRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Source != nil {
		l = m.Source.Size()
		n += 1 + l + sovStorageCommon(uint64(l))
	}
	l = len(m.Measurement)
	if l > 0 {
		n += 1 + l + sovStorageCommon(uint64(l))
	}
	l = m.Range.Size()
	n += 1 + l + sovStorageCommon(uint64(l))
	if m.Predicate != nil {
		l = m.Predicate.Size()
		n += 1 + l + sovStorageCommon(uint64(l))
	}
	return n
}

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

func (m *MeasurementFieldsResponse_MessageField) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Key)
	if l > 0 {
		n += 1 + l + sovStorageCommon(uint64(l))
	}
	if m.Type != 0 {
		n += 1 + sovStorageCommon(uint64(m.Type))
	}
	if m.Timestamp != 0 {
		n += 9
	}
	return n
}

func (m *ReadWindowAggregateRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ReadSource != nil {
		l = m.ReadSource.Size()
		n += 1 + l + sovStorageCommon(uint64(l))
	}
	l = m.Range.Size()
	n += 1 + l + sovStorageCommon(uint64(l))
	if m.Predicate != nil {
		l = m.Predicate.Size()
		n += 1 + l + sovStorageCommon(uint64(l))
	}
	if m.WindowEvery != 0 {
		n += 1 + sovStorageCommon(uint64(m.WindowEvery))
	}
	if len(m.Aggregate) > 0 {
		for _, e := range m.Aggregate {
			l = e.Size()
			n += 1 + l + sovStorageCommon(uint64(l))
		}
	}
	return n
}

func sovStorageCommon(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozStorageCommon(x uint64) (n int) {
	return sovStorageCommon(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *ReadFilterRequest) 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 ErrIntOverflowStorageCommon
			}
			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: ReadFilterRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ReadFilterRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReadSource", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStorageCommon
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStorageCommon
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthStorageCommon
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ReadSource == nil {
				m.ReadSource = &types.Any{}
			}
			if err := m.ReadSource.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Range", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStorageCommon
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStorageCommon
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthStorageCommon
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Range.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Predicate", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStorageCommon
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStorageCommon
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthStorageCommon
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Predicate == nil {
				m.Predicate = &Predicate{}
			}
			if err := m.Predicate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipStorageCommon(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthStorageCommon
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthStorageCommon
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ReadGroupRequest) 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 ErrIntOverflowStorageCommon
			}
			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: ReadGroupRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ReadGroupRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReadSource", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStorageCommon
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStorageCommon
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthStorageCommon
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ReadSource == nil {
				m.ReadSource = &types.Any{}
			}
			if err := m.ReadSource.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Range", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStorageCommon
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStorageCommon
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthStorageCommon
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Range.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Predicate", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStorageCommon
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStorageCommon
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthStorageCommon
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Predicate == nil {
				m.Predicate = &Predicate{}
			}
			if err := m.Predicate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GroupKeys", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStorageCommon
				}
				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 ErrInvalidLengthStorageCommon
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthStorageCommon
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.GroupKeys = append(m.GroupKeys, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Group", wireType)
			}
			m.Group = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStorageCommon
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Group |= ReadGroupRequest_Group(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Aggregate", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStorageCommon
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStorageCommon
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthStorageCommon
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Aggregate == nil {
				m.Aggregate = &Aggregate{}
			}
			if err := m.Aggregate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Hints", wireType)
			}
			m.Hints = 0
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			m.Hints = HintFlags(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
		default:
			iNdEx = preIndex
			skippy, err := skipStorageCommon(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthStorageCommon
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthStorageCommon
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Aggregate) 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 ErrIntOverflowStorageCommon
			}
			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: Aggregate: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Aggregate: 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 ErrIntOverflowStorageCommon
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= Aggregate_AggregateType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipStorageCommon(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthStorageCommon
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthStorageCommon
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ReadResponse_Frame) 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 ErrIntOverflowStorageCommon
			}
			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: Frame: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Frame: 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 ErrIntOverflowStorageCommon
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStorageCommon
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthStorageCommon
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ReadResponse_SeriesFrame{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Data = &ReadResponse_Frame_Series{v}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FloatPoints", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStorageCommon
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStorageCommon
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthStorageCommon
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ReadResponse_FloatPointsFrame{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Data = &ReadResponse_Frame_FloatPoints{v}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IntegerPoints", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStorageCommon
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStorageCommon
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthStorageCommon
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ReadResponse_IntegerPointsFrame{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Data = &ReadResponse_Frame_IntegerPoints{v}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UnsignedPoints", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStorageCommon
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStorageCommon
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthStorageCommon
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ReadResponse_UnsignedPointsFrame{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Data = &ReadResponse_Frame_UnsignedPoints{v}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BooleanPoints", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStorageCommon
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStorageCommon
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthStorageCommon
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ReadResponse_BooleanPointsFrame{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Data = &ReadResponse_Frame_BooleanPoints{v}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StringPoints", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStorageCommon
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStorageCommon
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthStorageCommon
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ReadResponse_StringPointsFrame{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Data = &ReadResponse_Frame_StringPoints{v}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Group", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStorageCommon
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStorageCommon
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthStorageCommon
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ReadResponse_GroupFrame{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Data = &ReadResponse_Frame_Group{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipStorageCommon(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthStorageCommon
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthStorageCommon
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ReadResponse_FloatPointsFrame) 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 ErrIntOverflowStorageCommon
			}
			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: FloatPointsFrame: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: FloatPointsFrame: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType == 1 {
				var v int64
				if (iNdEx + 8) > l {
					return io.ErrUnexpectedEOF
				}
				v = int64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
				iNdEx += 8
				m.Timestamps = append(m.Timestamps, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowStorageCommon
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthStorageCommon
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthStorageCommon
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				elementCount = packedLen / 8
				if elementCount != 0 && len(m.Timestamps) == 0 {
					m.Timestamps = make([]int64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int64
					if (iNdEx + 8) > l {
						return io.ErrUnexpectedEOF
					}
					v = int64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
					iNdEx += 8
					m.Timestamps = append(m.Timestamps, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field Timestamps", wireType)
			}
		case 2:
			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.Values = append(m.Values, v2)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowStorageCommon
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthStorageCommon
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthStorageCommon
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				elementCount = packedLen / 8
				if elementCount != 0 && len(m.Values) == 0 {
					m.Values = 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.Values = append(m.Values, v2)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field Values", wireType)
			}
		default:
			iNdEx = preIndex
			skippy, err := skipStorageCommon(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthStorageCommon
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthStorageCommon
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ReadResponse_IntegerPointsFrame) 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 ErrIntOverflowStorageCommon
			}
			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: IntegerPointsFrame: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: IntegerPointsFrame: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType == 1 {
				var v int64
				if (iNdEx + 8) > l {
					return io.ErrUnexpectedEOF
				}
				v = int64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
				iNdEx += 8
				m.Timestamps = append(m.Timestamps, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowStorageCommon
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthStorageCommon
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthStorageCommon
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				elementCount = packedLen / 8
				if elementCount != 0 && len(m.Timestamps) == 0 {
					m.Timestamps = make([]int64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int64
					if (iNdEx + 8) > l {
						return io.ErrUnexpectedEOF
					}
					v = int64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
					iNdEx += 8
					m.Timestamps = append(m.Timestamps, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field Timestamps", wireType)
			}
		case 2:
			if wireType == 0 {
				var v int64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowStorageCommon
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= int64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.Values = append(m.Values, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowStorageCommon
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthStorageCommon
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthStorageCommon
				}
				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.Values) == 0 {
					m.Values = make([]int64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowStorageCommon
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= int64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.Values = append(m.Values, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field Values", wireType)
			}
		default:
			iNdEx = preIndex
			skippy, err := skipStorageCommon(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthStorageCommon
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthStorageCommon
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ReadResponse_UnsignedPointsFrame) 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 ErrIntOverflowStorageCommon
			}
			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: UnsignedPointsFrame: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UnsignedPointsFrame: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType == 1 {
				var v int64
				if (iNdEx + 8) > l {
					return io.ErrUnexpectedEOF
				}
				v = int64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
				iNdEx += 8
				m.Timestamps = append(m.Timestamps, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowStorageCommon
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthStorageCommon
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthStorageCommon
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				elementCount = packedLen / 8
				if elementCount != 0 && len(m.Timestamps) == 0 {
					m.Timestamps = make([]int64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int64
					if (iNdEx + 8) > l {
						return io.ErrUnexpectedEOF
					}
					v = int64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
					iNdEx += 8
					m.Timestamps = append(m.Timestamps, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field Timestamps", wireType)
			}
		case 2:
			if wireType == 0 {
				var v uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowStorageCommon
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.Values = append(m.Values, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowStorageCommon
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthStorageCommon
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthStorageCommon
				}
				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.Values) == 0 {
					m.Values = make([]uint64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowStorageCommon
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.Values = append(m.Values, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field Values", wireType)
			}
		default:
			iNdEx = preIndex
			skippy, err := skipStorageCommon(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthStorageCommon
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthStorageCommon
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ReadResponse_BooleanPointsFrame) 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 ErrIntOverflowStorageCommon
			}
			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: BooleanPointsFrame: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BooleanPointsFrame: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType == 1 {
				var v int64
				if (iNdEx + 8) > l {
					return io.ErrUnexpectedEOF
				}
				v = int64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
				iNdEx += 8
				m.Timestamps = append(m.Timestamps, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowStorageCommon
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthStorageCommon
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthStorageCommon
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				elementCount = packedLen / 8
				if elementCount != 0 && len(m.Timestamps) == 0 {
					m.Timestamps = make([]int64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int64
					if (iNdEx + 8) > l {
						return io.ErrUnexpectedEOF
					}
					v = int64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
					iNdEx += 8
					m.Timestamps = append(m.Timestamps, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field Timestamps", wireType)
			}
		case 2:
			if wireType == 0 {
				var v int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowStorageCommon
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.Values = append(m.Values, bool(v != 0))
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowStorageCommon
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthStorageCommon
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthStorageCommon
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				elementCount = packedLen
				if elementCount != 0 && len(m.Values) == 0 {
					m.Values = make([]bool, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowStorageCommon
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.Values = append(m.Values, bool(v != 0))
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field Values", wireType)
			}
		default:
			iNdEx = preIndex
			skippy, err := skipStorageCommon(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthStorageCommon
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthStorageCommon
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ReadResponse_StringPointsFrame) 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 ErrIntOverflowStorageCommon
			}
			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: StringPointsFrame: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: StringPointsFrame: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType == 1 {
				var v int64
				if (iNdEx + 8) > l {
					return io.ErrUnexpectedEOF
				}
				v = int64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
				iNdEx += 8
				m.Timestamps = append(m.Timestamps, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowStorageCommon
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthStorageCommon
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthStorageCommon
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				elementCount = packedLen / 8
				if elementCount != 0 && len(m.Timestamps) == 0 {
					m.Timestamps = make([]int64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int64
					if (iNdEx + 8) > l {
						return io.ErrUnexpectedEOF
					}
					v = int64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
					iNdEx += 8
					m.Timestamps = append(m.Timestamps, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field Timestamps", wireType)
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Values", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStorageCommon
				}
				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 ErrInvalidLengthStorageCommon
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthStorageCommon
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Values = append(m.Values, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipStorageCommon(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthStorageCommon
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthStorageCommon
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CapabilitiesResponse) 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 ErrIntOverflowStorageCommon
			}
			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: CapabilitiesResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CapabilitiesResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Caps", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStorageCommon
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStorageCommon
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthStorageCommon
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Caps == nil {
				m.Caps = make(map[string]*Capability)
			}
			var mapkey string
			var mapvalue *Capability
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowStorageCommon
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowStorageCommon
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthStorageCommon
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthStorageCommon
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowStorageCommon
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthStorageCommon
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthStorageCommon
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &Capability{}
					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
						return err
					}
					iNdEx = postmsgIndex
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipStorageCommon(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if skippy < 0 {
						return ErrInvalidLengthStorageCommon
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Caps[mapkey] = mapvalue
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipStorageCommon(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthStorageCommon
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthStorageCommon
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TagValuesRequest) 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 ErrIntOverflowStorageCommon
			}
			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: TagValuesRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TagValuesRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TagsSource", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStorageCommon
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStorageCommon
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthStorageCommon
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.TagsSource == nil {
				m.TagsSource = &types.Any{}
			}
			if err := m.TagsSource.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Range", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStorageCommon
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStorageCommon
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthStorageCommon
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Range.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Predicate", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStorageCommon
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStorageCommon
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthStorageCommon
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Predicate == nil {
				m.Predicate = &Predicate{}
			}
			if err := m.Predicate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TagKey", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStorageCommon
				}
				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 ErrInvalidLengthStorageCommon
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthStorageCommon
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TagKey = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipStorageCommon(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthStorageCommon
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthStorageCommon
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MeasurementTagKeysRequest) 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 ErrIntOverflowStorageCommon
			}
			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: MeasurementTagKeysRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MeasurementTagKeysRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Source", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStorageCommon
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStorageCommon
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthStorageCommon
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Source == nil {
				m.Source = &types.Any{}
			}
			if err := m.Source.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Measurement", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStorageCommon
				}
				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 ErrInvalidLengthStorageCommon
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthStorageCommon
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Measurement = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Range", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStorageCommon
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStorageCommon
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthStorageCommon
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Range.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Predicate", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStorageCommon
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStorageCommon
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthStorageCommon
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Predicate == nil {
				m.Predicate = &Predicate{}
			}
			if err := m.Predicate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipStorageCommon(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthStorageCommon
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthStorageCommon
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MeasurementTagValuesRequest) 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 ErrIntOverflowStorageCommon
			}
			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: MeasurementTagValuesRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MeasurementTagValuesRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Source", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStorageCommon
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStorageCommon
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthStorageCommon
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Source == nil {
				m.Source = &types.Any{}
			}
			if err := m.Source.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Measurement", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStorageCommon
				}
				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 ErrInvalidLengthStorageCommon
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthStorageCommon
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Measurement = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TagKey", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStorageCommon
				}
				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 ErrInvalidLengthStorageCommon
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthStorageCommon
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TagKey = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Range", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStorageCommon
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStorageCommon
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthStorageCommon
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Range.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Predicate", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStorageCommon
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStorageCommon
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthStorageCommon
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Predicate == nil {
				m.Predicate = &Predicate{}
			}
			if err := m.Predicate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipStorageCommon(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthStorageCommon
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthStorageCommon
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MeasurementFieldsRequest) 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 ErrIntOverflowStorageCommon
			}
			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: MeasurementFieldsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MeasurementFieldsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Source", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStorageCommon
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStorageCommon
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthStorageCommon
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Source == nil {
				m.Source = &types.Any{}
			}
			if err := m.Source.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Measurement", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStorageCommon
				}
				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 ErrInvalidLengthStorageCommon
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthStorageCommon
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Measurement = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Range", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStorageCommon
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStorageCommon
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthStorageCommon
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Range.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Predicate", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStorageCommon
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStorageCommon
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthStorageCommon
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Predicate == nil {
				m.Predicate = &Predicate{}
			}
			if err := m.Predicate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipStorageCommon(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthStorageCommon
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthStorageCommon
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MeasurementFieldsResponse_MessageField) 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 ErrIntOverflowStorageCommon
			}
			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: MessageField: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MessageField: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStorageCommon
				}
				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 ErrInvalidLengthStorageCommon
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthStorageCommon
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Key = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			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 ErrIntOverflowStorageCommon
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= MeasurementFieldsResponse_FieldType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType)
			}
			m.Timestamp = 0
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			m.Timestamp = int64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
		default:
			iNdEx = preIndex
			skippy, err := skipStorageCommon(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthStorageCommon
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthStorageCommon
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ReadWindowAggregateRequest) 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 ErrIntOverflowStorageCommon
			}
			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: ReadWindowAggregateRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ReadWindowAggregateRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReadSource", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStorageCommon
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStorageCommon
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthStorageCommon
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ReadSource == nil {
				m.ReadSource = &types.Any{}
			}
			if err := m.ReadSource.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Range", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStorageCommon
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStorageCommon
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthStorageCommon
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Range.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Predicate", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStorageCommon
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStorageCommon
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthStorageCommon
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Predicate == nil {
				m.Predicate = &Predicate{}
			}
			if err := m.Predicate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field WindowEvery", wireType)
			}
			m.WindowEvery = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStorageCommon
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.WindowEvery |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Aggregate", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStorageCommon
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStorageCommon
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthStorageCommon
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Aggregate = append(m.Aggregate, &Aggregate{})
			if err := m.Aggregate[len(m.Aggregate)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipStorageCommon(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthStorageCommon
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthStorageCommon
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

var (
	ErrInvalidLengthStorageCommon        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowStorageCommon          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupStorageCommon = fmt.Errorf("proto: unexpected end of group")
)
