time_serie.pb.filterbuilder.go

// Code generated by protoc-gen-goten-resource
// Resource: TimeSerie
// DO NOT EDIT!!!

package time_serie

import (
	gotenresource "github.com/cloudwan/goten-sdk/runtime/resource"
	gotenfilter "github.com/cloudwan/goten-sdk/runtime/resource/filter"
)

// proto imports
import (
	api "github.com/cloudwan/edgelq-sdk/common/api"
	common "github.com/cloudwan/edgelq-sdk/monitoring/resources/v4/common"
	metric_descriptor "github.com/cloudwan/edgelq-sdk/monitoring/resources/v4/metric_descriptor"
	monitored_resource_descriptor "github.com/cloudwan/edgelq-sdk/monitoring/resources/v4/monitored_resource_descriptor"
	project "github.com/cloudwan/edgelq-sdk/monitoring/resources/v4/project"
	meta_service "github.com/cloudwan/goten-sdk/meta-service/resources/v1/service"
	meta "github.com/cloudwan/goten-sdk/types/meta"
	multi_region_policy "github.com/cloudwan/goten-sdk/types/multi_region_policy"
	durationpb "google.golang.org/protobuf/types/known/durationpb"
	timestamppb "google.golang.org/protobuf/types/known/timestamppb"
)

// ensure the imports are used
var (
	_ = gotenresource.ConditionContainsTypeAll
	_ = gotenfilter.AND
)

// make sure we're using proto imports
var (
	_ = api.LaunchStage(0)
	_ = &common.LabelDescriptor{}
	_ = &metric_descriptor.MetricDescriptor{}
	_ = &monitored_resource_descriptor.MonitoredResourceDescriptor{}
	_ = &project.Project{}
	_ = &durationpb.Duration{}
	_ = &timestamppb.Timestamp{}
	_ = &meta_service.Service{}
	_ = &meta.Meta{}
	_ = &multi_region_policy.MultiRegionPolicy{}
)

type FilterBuilderOrCondition interface {
	_IsTimeSerieFilterBuilderOrCondition()
}

type FilterBuilder struct {
	conds  []FilterCondition
	useNot bool
	op     gotenfilter.CompositeOperator
}

func NewFilterBuilder() *FilterBuilder {
	return NewAndFilterBuilder()
}

func NewAndFilterBuilder() *FilterBuilder {
	return &FilterBuilder{
		op: gotenfilter.AND,
	}
}

func NewOrFilterBuilder() *FilterBuilder {
	return &FilterBuilder{
		op: gotenfilter.OR,
	}
}

func (b *FilterBuilder) _IsTimeSerieFilterBuilderOrCondition() {}

func (b *FilterBuilder) With(condOrBuilder FilterBuilderOrCondition, opts ...gotenfilter.FilterConditionOption) *FilterBuilder {
	var cond FilterCondition
	switch typedObj := condOrBuilder.(type) {
	case *Filter:
		cond = typedObj.GetCondition()
	case *FilterBuilder:
		cond = &FilterConditionComposite{Operator: typedObj.op, Conditions: typedObj.conds}
	case FilterCondition:
		cond = typedObj
	default:
		panic("Unknown condition or builder type")
	}
	cfg := gotenfilter.MakeFilterCondOptions(opts)
	if cfg.IsNot() {
		cond = &FilterConditionNot{cond}
	}
	b.conds = append(b.conds, cond)
	return b
}

func (b *FilterBuilder) Where(opts ...gotenfilter.FilterConditionOption) *filterCndBuilder {
	cfg := gotenfilter.MakeFilterCondOptions(opts)
	b.useNot = cfg.IsNot()
	return &filterCndBuilder{builder: b}
}

func (b *FilterBuilder) WherePath(fp TimeSerie_FieldPath, opts ...gotenfilter.FilterConditionOption) *filterCndBuilderAnyPath {
	cfg := gotenfilter.MakeFilterCondOptions(opts)
	b.useNot = cfg.IsNot()
	return &filterCndBuilderAnyPath{builder: b, fp: fp}
}

func (b *FilterBuilder) Filter() *Filter {
	return &Filter{
		FilterCondition: &FilterConditionComposite{Operator: b.op, Conditions: b.conds},
	}
}

func (b *FilterBuilder) addCond(cond FilterCondition) *FilterBuilder {
	if b.useNot {
		cond = &FilterConditionNot{cond}
		b.useNot = false
	}
	b.conds = append(b.conds, cond)
	return b
}

type filterCndBuilderAnyPath struct {
	builder *FilterBuilder
	fp      TimeSerie_FieldPath
}

func (b *filterCndBuilderAnyPath) Eq(value interface{}) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderAnyPath) Neq(value interface{}) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderAnyPath) Gt(value interface{}) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderAnyPath) Gte(value interface{}) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderAnyPath) Lt(value interface{}) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderAnyPath) Lte(value interface{}) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderAnyPath) In(values interface{}) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		TimeSerie_FieldPathArrayOfValues: b.fp.WithIArrayOfValues(values),
	})
}

func (b *filterCndBuilderAnyPath) NotIn(values interface{}) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		TimeSerie_FieldPathArrayOfValues: b.fp.WithIArrayOfValues(values),
	})
}

func (b *filterCndBuilderAnyPath) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: b.fp,
	})
}

func (b *filterCndBuilderAnyPath) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: b.fp,
	})
}

func (b *filterCndBuilderAnyPath) compare(op gotenfilter.CompareOperator, value interface{}) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                 op,
		TimeSerie_FieldPathValue: b.fp.WithIValue(value),
	})
}

type filterCndBuilder struct {
	builder *FilterBuilder
}

func (b *filterCndBuilder) Key() *filterCndBuilderKey {
	return &filterCndBuilderKey{builder: b.builder}
}

func (b *filterCndBuilder) Project() *filterCndBuilderProject {
	return &filterCndBuilderProject{builder: b.builder}
}

func (b *filterCndBuilder) Region() *filterCndBuilderRegion {
	return &filterCndBuilderRegion{builder: b.builder}
}

func (b *filterCndBuilder) Metric() *filterCndBuilderMetric {
	return &filterCndBuilderMetric{builder: b.builder}
}

func (b *filterCndBuilder) Resource() *filterCndBuilderResource {
	return &filterCndBuilderResource{builder: b.builder}
}

func (b *filterCndBuilder) MetricKind() *filterCndBuilderMetricKind {
	return &filterCndBuilderMetricKind{builder: b.builder}
}

func (b *filterCndBuilder) ValueType() *filterCndBuilderValueType {
	return &filterCndBuilderValueType{builder: b.builder}
}

func (b *filterCndBuilder) Points() *filterCndBuilderPoints {
	return &filterCndBuilderPoints{builder: b.builder}
}

type filterCndBuilderKey struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderKey) Eq(value []byte) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderKey) Neq(value []byte) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderKey) Gt(value []byte) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderKey) Gte(value []byte) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderKey) Lt(value []byte) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderKey) Lte(value []byte) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderKey) In(values [][]byte) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Key().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderKey) NotIn(values [][]byte) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Key().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderKey) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewTimeSerieFieldPathBuilder().Key().FieldPath(),
	})
}

func (b *filterCndBuilderKey) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewTimeSerieFieldPathBuilder().Key().FieldPath(),
	})
}

func (b *filterCndBuilderKey) compare(op gotenfilter.CompareOperator, value []byte) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                 op,
		TimeSerie_FieldPathValue: NewTimeSerieFieldPathBuilder().Key().WithValue(value),
	})
}

type filterCndBuilderProject struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderProject) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderProject) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderProject) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderProject) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderProject) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderProject) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderProject) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Project().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderProject) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Project().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderProject) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewTimeSerieFieldPathBuilder().Project().FieldPath(),
	})
}

func (b *filterCndBuilderProject) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewTimeSerieFieldPathBuilder().Project().FieldPath(),
	})
}

func (b *filterCndBuilderProject) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                 op,
		TimeSerie_FieldPathValue: NewTimeSerieFieldPathBuilder().Project().WithValue(value),
	})
}

type filterCndBuilderRegion struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderRegion) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderRegion) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderRegion) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderRegion) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderRegion) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderRegion) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderRegion) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Region().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderRegion) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Region().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderRegion) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewTimeSerieFieldPathBuilder().Region().FieldPath(),
	})
}

func (b *filterCndBuilderRegion) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewTimeSerieFieldPathBuilder().Region().FieldPath(),
	})
}

func (b *filterCndBuilderRegion) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                 op,
		TimeSerie_FieldPathValue: NewTimeSerieFieldPathBuilder().Region().WithValue(value),
	})
}

type filterCndBuilderMetric struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderMetric) Eq(value *common.Metric) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderMetric) Neq(value *common.Metric) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderMetric) Gt(value *common.Metric) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderMetric) Gte(value *common.Metric) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderMetric) Lt(value *common.Metric) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderMetric) Lte(value *common.Metric) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderMetric) In(values []*common.Metric) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Metric().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderMetric) NotIn(values []*common.Metric) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Metric().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderMetric) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewTimeSerieFieldPathBuilder().Metric().FieldPath(),
	})
}

func (b *filterCndBuilderMetric) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewTimeSerieFieldPathBuilder().Metric().FieldPath(),
	})
}

func (b *filterCndBuilderMetric) compare(op gotenfilter.CompareOperator, value *common.Metric) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                 op,
		TimeSerie_FieldPathValue: NewTimeSerieFieldPathBuilder().Metric().WithValue(value),
	})
}

func (b *filterCndBuilderMetric) Type() *filterCndBuilderMetricType {
	return &filterCndBuilderMetricType{builder: b.builder}
}

func (b *filterCndBuilderMetric) Labels() *filterCndBuilderMetricLabels {
	return &filterCndBuilderMetricLabels{builder: b.builder}
}

func (b *filterCndBuilderMetric) ReducedLabels() *filterCndBuilderMetricReducedLabels {
	return &filterCndBuilderMetricReducedLabels{builder: b.builder}
}

type filterCndBuilderMetricType struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderMetricType) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderMetricType) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderMetricType) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderMetricType) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderMetricType) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderMetricType) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderMetricType) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Metric().Type().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderMetricType) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Metric().Type().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderMetricType) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewTimeSerieFieldPathBuilder().Metric().Type().FieldPath(),
	})
}

func (b *filterCndBuilderMetricType) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewTimeSerieFieldPathBuilder().Metric().Type().FieldPath(),
	})
}

func (b *filterCndBuilderMetricType) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                 op,
		TimeSerie_FieldPathValue: NewTimeSerieFieldPathBuilder().Metric().Type().WithValue(value),
	})
}

type filterCndBuilderMetricLabels struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderMetricLabels) Eq(value map[string]string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderMetricLabels) Neq(value map[string]string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderMetricLabels) Gt(value map[string]string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderMetricLabels) Gte(value map[string]string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderMetricLabels) Lt(value map[string]string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderMetricLabels) Lte(value map[string]string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderMetricLabels) In(values []map[string]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Metric().Labels().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderMetricLabels) NotIn(values []map[string]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Metric().Labels().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderMetricLabels) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewTimeSerieFieldPathBuilder().Metric().Labels().FieldPath(),
	})
}

func (b *filterCndBuilderMetricLabels) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewTimeSerieFieldPathBuilder().Metric().Labels().FieldPath(),
	})
}

func (b *filterCndBuilderMetricLabels) compare(op gotenfilter.CompareOperator, value map[string]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                 op,
		TimeSerie_FieldPathValue: NewTimeSerieFieldPathBuilder().Metric().Labels().WithValue(value),
	})
}

func (b *filterCndBuilderMetricLabels) WithKey(key string) *mapFilterCndBuilderMetricLabels {
	return &mapFilterCndBuilderMetricLabels{builder: b.builder, key: key}
}

type mapFilterCndBuilderMetricLabels struct {
	builder *FilterBuilder
	key     string
}

func (b *mapFilterCndBuilderMetricLabels) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *mapFilterCndBuilderMetricLabels) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *mapFilterCndBuilderMetricLabels) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *mapFilterCndBuilderMetricLabels) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *mapFilterCndBuilderMetricLabels) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *mapFilterCndBuilderMetricLabels) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *mapFilterCndBuilderMetricLabels) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Metric().Labels().WithKey(b.key).WithArrayOfValues(values),
	})
}

func (b *mapFilterCndBuilderMetricLabels) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Metric().Labels().WithKey(b.key).WithArrayOfValues(values),
	})
}

func (b *mapFilterCndBuilderMetricLabels) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewTimeSerieFieldPathBuilder().Metric().Labels().WithKey(b.key).FieldPath(),
	})
}

func (b *mapFilterCndBuilderMetricLabels) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewTimeSerieFieldPathBuilder().Metric().Labels().WithKey(b.key).FieldPath(),
	})
}

func (b *mapFilterCndBuilderMetricLabels) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                 op,
		TimeSerie_FieldPathValue: NewTimeSerieFieldPathBuilder().Metric().Labels().WithKey(b.key).WithValue(value),
	})
}

type filterCndBuilderMetricReducedLabels struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderMetricReducedLabels) Eq(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderMetricReducedLabels) Neq(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderMetricReducedLabels) Gt(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderMetricReducedLabels) Gte(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderMetricReducedLabels) Lt(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderMetricReducedLabels) Lte(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderMetricReducedLabels) In(values [][]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Metric().ReducedLabels().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderMetricReducedLabels) NotIn(values [][]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Metric().ReducedLabels().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderMetricReducedLabels) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewTimeSerieFieldPathBuilder().Metric().ReducedLabels().FieldPath(),
	})
}

func (b *filterCndBuilderMetricReducedLabels) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewTimeSerieFieldPathBuilder().Metric().ReducedLabels().FieldPath(),
	})
}

func (b *filterCndBuilderMetricReducedLabels) Contains(value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewTimeSerieFieldPathBuilder().Metric().ReducedLabels().FieldPath(),
		Value:     NewTimeSerieFieldPathBuilder().Metric().ReducedLabels().WithItemValue(value),
	})
}

func (b *filterCndBuilderMetricReducedLabels) ContainsAnyOf(values []string) *FilterBuilder {
	pathSelector := NewTimeSerieFieldPathBuilder().Metric().ReducedLabels()
	itemValues := make([]TimeSerie_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewTimeSerieFieldPathBuilder().Metric().ReducedLabels().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderMetricReducedLabels) ContainsAll(values []string) *FilterBuilder {
	pathSelector := NewTimeSerieFieldPathBuilder().Metric().ReducedLabels()
	itemValues := make([]TimeSerie_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewTimeSerieFieldPathBuilder().Metric().ReducedLabels().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderMetricReducedLabels) compare(op gotenfilter.CompareOperator, value []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                 op,
		TimeSerie_FieldPathValue: NewTimeSerieFieldPathBuilder().Metric().ReducedLabels().WithValue(value),
	})
}

type filterCndBuilderResource struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderResource) Eq(value *common.MonitoredResource) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderResource) Neq(value *common.MonitoredResource) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderResource) Gt(value *common.MonitoredResource) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderResource) Gte(value *common.MonitoredResource) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderResource) Lt(value *common.MonitoredResource) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderResource) Lte(value *common.MonitoredResource) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderResource) In(values []*common.MonitoredResource) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Resource().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderResource) NotIn(values []*common.MonitoredResource) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Resource().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderResource) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewTimeSerieFieldPathBuilder().Resource().FieldPath(),
	})
}

func (b *filterCndBuilderResource) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewTimeSerieFieldPathBuilder().Resource().FieldPath(),
	})
}

func (b *filterCndBuilderResource) compare(op gotenfilter.CompareOperator, value *common.MonitoredResource) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                 op,
		TimeSerie_FieldPathValue: NewTimeSerieFieldPathBuilder().Resource().WithValue(value),
	})
}

func (b *filterCndBuilderResource) Type() *filterCndBuilderResourceType {
	return &filterCndBuilderResourceType{builder: b.builder}
}

func (b *filterCndBuilderResource) Labels() *filterCndBuilderResourceLabels {
	return &filterCndBuilderResourceLabels{builder: b.builder}
}

func (b *filterCndBuilderResource) ReducedLabels() *filterCndBuilderResourceReducedLabels {
	return &filterCndBuilderResourceReducedLabels{builder: b.builder}
}

type filterCndBuilderResourceType struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderResourceType) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderResourceType) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderResourceType) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderResourceType) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderResourceType) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderResourceType) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderResourceType) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Resource().Type().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderResourceType) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Resource().Type().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderResourceType) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewTimeSerieFieldPathBuilder().Resource().Type().FieldPath(),
	})
}

func (b *filterCndBuilderResourceType) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewTimeSerieFieldPathBuilder().Resource().Type().FieldPath(),
	})
}

func (b *filterCndBuilderResourceType) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                 op,
		TimeSerie_FieldPathValue: NewTimeSerieFieldPathBuilder().Resource().Type().WithValue(value),
	})
}

type filterCndBuilderResourceLabels struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderResourceLabels) Eq(value map[string]string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderResourceLabels) Neq(value map[string]string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderResourceLabels) Gt(value map[string]string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderResourceLabels) Gte(value map[string]string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderResourceLabels) Lt(value map[string]string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderResourceLabels) Lte(value map[string]string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderResourceLabels) In(values []map[string]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Resource().Labels().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderResourceLabels) NotIn(values []map[string]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Resource().Labels().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderResourceLabels) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewTimeSerieFieldPathBuilder().Resource().Labels().FieldPath(),
	})
}

func (b *filterCndBuilderResourceLabels) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewTimeSerieFieldPathBuilder().Resource().Labels().FieldPath(),
	})
}

func (b *filterCndBuilderResourceLabels) compare(op gotenfilter.CompareOperator, value map[string]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                 op,
		TimeSerie_FieldPathValue: NewTimeSerieFieldPathBuilder().Resource().Labels().WithValue(value),
	})
}

func (b *filterCndBuilderResourceLabels) WithKey(key string) *mapFilterCndBuilderResourceLabels {
	return &mapFilterCndBuilderResourceLabels{builder: b.builder, key: key}
}

type mapFilterCndBuilderResourceLabels struct {
	builder *FilterBuilder
	key     string
}

func (b *mapFilterCndBuilderResourceLabels) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *mapFilterCndBuilderResourceLabels) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *mapFilterCndBuilderResourceLabels) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *mapFilterCndBuilderResourceLabels) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *mapFilterCndBuilderResourceLabels) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *mapFilterCndBuilderResourceLabels) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *mapFilterCndBuilderResourceLabels) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Resource().Labels().WithKey(b.key).WithArrayOfValues(values),
	})
}

func (b *mapFilterCndBuilderResourceLabels) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Resource().Labels().WithKey(b.key).WithArrayOfValues(values),
	})
}

func (b *mapFilterCndBuilderResourceLabels) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewTimeSerieFieldPathBuilder().Resource().Labels().WithKey(b.key).FieldPath(),
	})
}

func (b *mapFilterCndBuilderResourceLabels) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewTimeSerieFieldPathBuilder().Resource().Labels().WithKey(b.key).FieldPath(),
	})
}

func (b *mapFilterCndBuilderResourceLabels) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                 op,
		TimeSerie_FieldPathValue: NewTimeSerieFieldPathBuilder().Resource().Labels().WithKey(b.key).WithValue(value),
	})
}

type filterCndBuilderResourceReducedLabels struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderResourceReducedLabels) Eq(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderResourceReducedLabels) Neq(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderResourceReducedLabels) Gt(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderResourceReducedLabels) Gte(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderResourceReducedLabels) Lt(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderResourceReducedLabels) Lte(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderResourceReducedLabels) In(values [][]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Resource().ReducedLabels().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderResourceReducedLabels) NotIn(values [][]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Resource().ReducedLabels().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderResourceReducedLabels) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewTimeSerieFieldPathBuilder().Resource().ReducedLabels().FieldPath(),
	})
}

func (b *filterCndBuilderResourceReducedLabels) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewTimeSerieFieldPathBuilder().Resource().ReducedLabels().FieldPath(),
	})
}

func (b *filterCndBuilderResourceReducedLabels) Contains(value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewTimeSerieFieldPathBuilder().Resource().ReducedLabels().FieldPath(),
		Value:     NewTimeSerieFieldPathBuilder().Resource().ReducedLabels().WithItemValue(value),
	})
}

func (b *filterCndBuilderResourceReducedLabels) ContainsAnyOf(values []string) *FilterBuilder {
	pathSelector := NewTimeSerieFieldPathBuilder().Resource().ReducedLabels()
	itemValues := make([]TimeSerie_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewTimeSerieFieldPathBuilder().Resource().ReducedLabels().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderResourceReducedLabels) ContainsAll(values []string) *FilterBuilder {
	pathSelector := NewTimeSerieFieldPathBuilder().Resource().ReducedLabels()
	itemValues := make([]TimeSerie_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewTimeSerieFieldPathBuilder().Resource().ReducedLabels().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderResourceReducedLabels) compare(op gotenfilter.CompareOperator, value []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                 op,
		TimeSerie_FieldPathValue: NewTimeSerieFieldPathBuilder().Resource().ReducedLabels().WithValue(value),
	})
}

type filterCndBuilderMetricKind struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderMetricKind) Eq(value metric_descriptor.MetricDescriptor_MetricKind) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderMetricKind) Neq(value metric_descriptor.MetricDescriptor_MetricKind) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderMetricKind) Gt(value metric_descriptor.MetricDescriptor_MetricKind) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderMetricKind) Gte(value metric_descriptor.MetricDescriptor_MetricKind) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderMetricKind) Lt(value metric_descriptor.MetricDescriptor_MetricKind) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderMetricKind) Lte(value metric_descriptor.MetricDescriptor_MetricKind) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderMetricKind) In(values []metric_descriptor.MetricDescriptor_MetricKind) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().MetricKind().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderMetricKind) NotIn(values []metric_descriptor.MetricDescriptor_MetricKind) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().MetricKind().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderMetricKind) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewTimeSerieFieldPathBuilder().MetricKind().FieldPath(),
	})
}

func (b *filterCndBuilderMetricKind) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewTimeSerieFieldPathBuilder().MetricKind().FieldPath(),
	})
}

func (b *filterCndBuilderMetricKind) compare(op gotenfilter.CompareOperator, value metric_descriptor.MetricDescriptor_MetricKind) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                 op,
		TimeSerie_FieldPathValue: NewTimeSerieFieldPathBuilder().MetricKind().WithValue(value),
	})
}

type filterCndBuilderValueType struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderValueType) Eq(value metric_descriptor.MetricDescriptor_ValueType) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderValueType) Neq(value metric_descriptor.MetricDescriptor_ValueType) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderValueType) Gt(value metric_descriptor.MetricDescriptor_ValueType) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderValueType) Gte(value metric_descriptor.MetricDescriptor_ValueType) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderValueType) Lt(value metric_descriptor.MetricDescriptor_ValueType) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderValueType) Lte(value metric_descriptor.MetricDescriptor_ValueType) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderValueType) In(values []metric_descriptor.MetricDescriptor_ValueType) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().ValueType().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderValueType) NotIn(values []metric_descriptor.MetricDescriptor_ValueType) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().ValueType().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderValueType) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewTimeSerieFieldPathBuilder().ValueType().FieldPath(),
	})
}

func (b *filterCndBuilderValueType) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewTimeSerieFieldPathBuilder().ValueType().FieldPath(),
	})
}

func (b *filterCndBuilderValueType) compare(op gotenfilter.CompareOperator, value metric_descriptor.MetricDescriptor_ValueType) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                 op,
		TimeSerie_FieldPathValue: NewTimeSerieFieldPathBuilder().ValueType().WithValue(value),
	})
}

type filterCndBuilderPoints struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderPoints) Eq(value []*Point) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderPoints) Neq(value []*Point) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderPoints) Gt(value []*Point) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderPoints) Gte(value []*Point) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderPoints) Lt(value []*Point) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderPoints) Lte(value []*Point) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderPoints) In(values [][]*Point) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Points().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderPoints) NotIn(values [][]*Point) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Points().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderPoints) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewTimeSerieFieldPathBuilder().Points().FieldPath(),
	})
}

func (b *filterCndBuilderPoints) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewTimeSerieFieldPathBuilder().Points().FieldPath(),
	})
}

func (b *filterCndBuilderPoints) Contains(value *Point) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewTimeSerieFieldPathBuilder().Points().FieldPath(),
		Value:     NewTimeSerieFieldPathBuilder().Points().WithItemValue(value),
	})
}

func (b *filterCndBuilderPoints) ContainsAnyOf(values []*Point) *FilterBuilder {
	pathSelector := NewTimeSerieFieldPathBuilder().Points()
	itemValues := make([]TimeSerie_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewTimeSerieFieldPathBuilder().Points().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderPoints) ContainsAll(values []*Point) *FilterBuilder {
	pathSelector := NewTimeSerieFieldPathBuilder().Points()
	itemValues := make([]TimeSerie_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewTimeSerieFieldPathBuilder().Points().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderPoints) compare(op gotenfilter.CompareOperator, value []*Point) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                 op,
		TimeSerie_FieldPathValue: NewTimeSerieFieldPathBuilder().Points().WithValue(value),
	})
}

func (b *filterCndBuilderPoints) Interval() *filterCndBuilderPointsInterval {
	return &filterCndBuilderPointsInterval{builder: b.builder}
}

func (b *filterCndBuilderPoints) Value() *filterCndBuilderPointsValue {
	return &filterCndBuilderPointsValue{builder: b.builder}
}

func (b *filterCndBuilderPoints) Aggregation() *filterCndBuilderPointsAggregation {
	return &filterCndBuilderPointsAggregation{builder: b.builder}
}

type filterCndBuilderPointsInterval struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderPointsInterval) Eq(value *common.TimeInterval) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderPointsInterval) Neq(value *common.TimeInterval) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderPointsInterval) Gt(value *common.TimeInterval) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderPointsInterval) Gte(value *common.TimeInterval) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderPointsInterval) Lt(value *common.TimeInterval) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderPointsInterval) Lte(value *common.TimeInterval) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderPointsInterval) In(values []*common.TimeInterval) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Points().Interval().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderPointsInterval) NotIn(values []*common.TimeInterval) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Points().Interval().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderPointsInterval) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewTimeSerieFieldPathBuilder().Points().Interval().FieldPath(),
	})
}

func (b *filterCndBuilderPointsInterval) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewTimeSerieFieldPathBuilder().Points().Interval().FieldPath(),
	})
}

func (b *filterCndBuilderPointsInterval) compare(op gotenfilter.CompareOperator, value *common.TimeInterval) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                 op,
		TimeSerie_FieldPathValue: NewTimeSerieFieldPathBuilder().Points().Interval().WithValue(value),
	})
}

func (b *filterCndBuilderPointsInterval) EndTime() *filterCndBuilderPointsIntervalEndTime {
	return &filterCndBuilderPointsIntervalEndTime{builder: b.builder}
}

func (b *filterCndBuilderPointsInterval) StartTime() *filterCndBuilderPointsIntervalStartTime {
	return &filterCndBuilderPointsIntervalStartTime{builder: b.builder}
}

type filterCndBuilderPointsIntervalEndTime struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderPointsIntervalEndTime) Eq(value *timestamppb.Timestamp) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderPointsIntervalEndTime) Neq(value *timestamppb.Timestamp) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderPointsIntervalEndTime) Gt(value *timestamppb.Timestamp) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderPointsIntervalEndTime) Gte(value *timestamppb.Timestamp) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderPointsIntervalEndTime) Lt(value *timestamppb.Timestamp) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderPointsIntervalEndTime) Lte(value *timestamppb.Timestamp) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderPointsIntervalEndTime) In(values []*timestamppb.Timestamp) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Points().Interval().EndTime().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderPointsIntervalEndTime) NotIn(values []*timestamppb.Timestamp) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Points().Interval().EndTime().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderPointsIntervalEndTime) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewTimeSerieFieldPathBuilder().Points().Interval().EndTime().FieldPath(),
	})
}

func (b *filterCndBuilderPointsIntervalEndTime) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewTimeSerieFieldPathBuilder().Points().Interval().EndTime().FieldPath(),
	})
}

func (b *filterCndBuilderPointsIntervalEndTime) compare(op gotenfilter.CompareOperator, value *timestamppb.Timestamp) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                 op,
		TimeSerie_FieldPathValue: NewTimeSerieFieldPathBuilder().Points().Interval().EndTime().WithValue(value),
	})
}

type filterCndBuilderPointsIntervalStartTime struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderPointsIntervalStartTime) Eq(value *timestamppb.Timestamp) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderPointsIntervalStartTime) Neq(value *timestamppb.Timestamp) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderPointsIntervalStartTime) Gt(value *timestamppb.Timestamp) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderPointsIntervalStartTime) Gte(value *timestamppb.Timestamp) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderPointsIntervalStartTime) Lt(value *timestamppb.Timestamp) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderPointsIntervalStartTime) Lte(value *timestamppb.Timestamp) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderPointsIntervalStartTime) In(values []*timestamppb.Timestamp) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Points().Interval().StartTime().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderPointsIntervalStartTime) NotIn(values []*timestamppb.Timestamp) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Points().Interval().StartTime().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderPointsIntervalStartTime) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewTimeSerieFieldPathBuilder().Points().Interval().StartTime().FieldPath(),
	})
}

func (b *filterCndBuilderPointsIntervalStartTime) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewTimeSerieFieldPathBuilder().Points().Interval().StartTime().FieldPath(),
	})
}

func (b *filterCndBuilderPointsIntervalStartTime) compare(op gotenfilter.CompareOperator, value *timestamppb.Timestamp) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                 op,
		TimeSerie_FieldPathValue: NewTimeSerieFieldPathBuilder().Points().Interval().StartTime().WithValue(value),
	})
}

type filterCndBuilderPointsValue struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderPointsValue) Eq(value *common.TypedValue) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderPointsValue) Neq(value *common.TypedValue) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderPointsValue) Gt(value *common.TypedValue) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderPointsValue) Gte(value *common.TypedValue) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderPointsValue) Lt(value *common.TypedValue) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderPointsValue) Lte(value *common.TypedValue) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderPointsValue) In(values []*common.TypedValue) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Points().Value().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderPointsValue) NotIn(values []*common.TypedValue) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Points().Value().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderPointsValue) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewTimeSerieFieldPathBuilder().Points().Value().FieldPath(),
	})
}

func (b *filterCndBuilderPointsValue) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewTimeSerieFieldPathBuilder().Points().Value().FieldPath(),
	})
}

func (b *filterCndBuilderPointsValue) compare(op gotenfilter.CompareOperator, value *common.TypedValue) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                 op,
		TimeSerie_FieldPathValue: NewTimeSerieFieldPathBuilder().Points().Value().WithValue(value),
	})
}

func (b *filterCndBuilderPointsValue) BoolValue() *filterCndBuilderPointsValueBoolValue {
	return &filterCndBuilderPointsValueBoolValue{builder: b.builder}
}

func (b *filterCndBuilderPointsValue) Int64Value() *filterCndBuilderPointsValueInt64Value {
	return &filterCndBuilderPointsValueInt64Value{builder: b.builder}
}

func (b *filterCndBuilderPointsValue) DoubleValue() *filterCndBuilderPointsValueDoubleValue {
	return &filterCndBuilderPointsValueDoubleValue{builder: b.builder}
}

func (b *filterCndBuilderPointsValue) StringValue() *filterCndBuilderPointsValueStringValue {
	return &filterCndBuilderPointsValueStringValue{builder: b.builder}
}

func (b *filterCndBuilderPointsValue) DistributionValue() *filterCndBuilderPointsValueDistributionValue {
	return &filterCndBuilderPointsValueDistributionValue{builder: b.builder}
}

type filterCndBuilderPointsValueBoolValue struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderPointsValueBoolValue) Eq(value bool) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderPointsValueBoolValue) Neq(value bool) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderPointsValueBoolValue) Gt(value bool) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderPointsValueBoolValue) Gte(value bool) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderPointsValueBoolValue) Lt(value bool) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderPointsValueBoolValue) Lte(value bool) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderPointsValueBoolValue) In(values []bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Points().Value().BoolValue().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderPointsValueBoolValue) NotIn(values []bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Points().Value().BoolValue().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderPointsValueBoolValue) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewTimeSerieFieldPathBuilder().Points().Value().BoolValue().FieldPath(),
	})
}

func (b *filterCndBuilderPointsValueBoolValue) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewTimeSerieFieldPathBuilder().Points().Value().BoolValue().FieldPath(),
	})
}

func (b *filterCndBuilderPointsValueBoolValue) compare(op gotenfilter.CompareOperator, value bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                 op,
		TimeSerie_FieldPathValue: NewTimeSerieFieldPathBuilder().Points().Value().BoolValue().WithValue(value),
	})
}

type filterCndBuilderPointsValueInt64Value struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderPointsValueInt64Value) Eq(value int64) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderPointsValueInt64Value) Neq(value int64) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderPointsValueInt64Value) Gt(value int64) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderPointsValueInt64Value) Gte(value int64) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderPointsValueInt64Value) Lt(value int64) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderPointsValueInt64Value) Lte(value int64) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderPointsValueInt64Value) In(values []int64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Points().Value().Int64Value().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderPointsValueInt64Value) NotIn(values []int64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Points().Value().Int64Value().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderPointsValueInt64Value) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewTimeSerieFieldPathBuilder().Points().Value().Int64Value().FieldPath(),
	})
}

func (b *filterCndBuilderPointsValueInt64Value) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewTimeSerieFieldPathBuilder().Points().Value().Int64Value().FieldPath(),
	})
}

func (b *filterCndBuilderPointsValueInt64Value) compare(op gotenfilter.CompareOperator, value int64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                 op,
		TimeSerie_FieldPathValue: NewTimeSerieFieldPathBuilder().Points().Value().Int64Value().WithValue(value),
	})
}

type filterCndBuilderPointsValueDoubleValue struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderPointsValueDoubleValue) Eq(value float64) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderPointsValueDoubleValue) Neq(value float64) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderPointsValueDoubleValue) Gt(value float64) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderPointsValueDoubleValue) Gte(value float64) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderPointsValueDoubleValue) Lt(value float64) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderPointsValueDoubleValue) Lte(value float64) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderPointsValueDoubleValue) In(values []float64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Points().Value().DoubleValue().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderPointsValueDoubleValue) NotIn(values []float64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Points().Value().DoubleValue().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderPointsValueDoubleValue) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewTimeSerieFieldPathBuilder().Points().Value().DoubleValue().FieldPath(),
	})
}

func (b *filterCndBuilderPointsValueDoubleValue) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewTimeSerieFieldPathBuilder().Points().Value().DoubleValue().FieldPath(),
	})
}

func (b *filterCndBuilderPointsValueDoubleValue) compare(op gotenfilter.CompareOperator, value float64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                 op,
		TimeSerie_FieldPathValue: NewTimeSerieFieldPathBuilder().Points().Value().DoubleValue().WithValue(value),
	})
}

type filterCndBuilderPointsValueStringValue struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderPointsValueStringValue) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderPointsValueStringValue) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderPointsValueStringValue) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderPointsValueStringValue) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderPointsValueStringValue) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderPointsValueStringValue) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderPointsValueStringValue) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Points().Value().StringValue().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderPointsValueStringValue) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Points().Value().StringValue().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderPointsValueStringValue) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewTimeSerieFieldPathBuilder().Points().Value().StringValue().FieldPath(),
	})
}

func (b *filterCndBuilderPointsValueStringValue) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewTimeSerieFieldPathBuilder().Points().Value().StringValue().FieldPath(),
	})
}

func (b *filterCndBuilderPointsValueStringValue) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                 op,
		TimeSerie_FieldPathValue: NewTimeSerieFieldPathBuilder().Points().Value().StringValue().WithValue(value),
	})
}

type filterCndBuilderPointsValueDistributionValue struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderPointsValueDistributionValue) Eq(value *common.Distribution) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderPointsValueDistributionValue) Neq(value *common.Distribution) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderPointsValueDistributionValue) Gt(value *common.Distribution) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderPointsValueDistributionValue) Gte(value *common.Distribution) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderPointsValueDistributionValue) Lt(value *common.Distribution) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderPointsValueDistributionValue) Lte(value *common.Distribution) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderPointsValueDistributionValue) In(values []*common.Distribution) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderPointsValueDistributionValue) NotIn(values []*common.Distribution) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderPointsValueDistributionValue) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().FieldPath(),
	})
}

func (b *filterCndBuilderPointsValueDistributionValue) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().FieldPath(),
	})
}

func (b *filterCndBuilderPointsValueDistributionValue) compare(op gotenfilter.CompareOperator, value *common.Distribution) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                 op,
		TimeSerie_FieldPathValue: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().WithValue(value),
	})
}

func (b *filterCndBuilderPointsValueDistributionValue) Count() *filterCndBuilderPointsValueDistributionValueCount {
	return &filterCndBuilderPointsValueDistributionValueCount{builder: b.builder}
}

func (b *filterCndBuilderPointsValueDistributionValue) Mean() *filterCndBuilderPointsValueDistributionValueMean {
	return &filterCndBuilderPointsValueDistributionValueMean{builder: b.builder}
}

func (b *filterCndBuilderPointsValueDistributionValue) SumOfSquaredDeviation() *filterCndBuilderPointsValueDistributionValueSumOfSquaredDeviation {
	return &filterCndBuilderPointsValueDistributionValueSumOfSquaredDeviation{builder: b.builder}
}

func (b *filterCndBuilderPointsValueDistributionValue) Range() *filterCndBuilderPointsValueDistributionValueRange {
	return &filterCndBuilderPointsValueDistributionValueRange{builder: b.builder}
}

func (b *filterCndBuilderPointsValueDistributionValue) BucketOptions() *filterCndBuilderPointsValueDistributionValueBucketOptions {
	return &filterCndBuilderPointsValueDistributionValueBucketOptions{builder: b.builder}
}

func (b *filterCndBuilderPointsValueDistributionValue) BucketCounts() *filterCndBuilderPointsValueDistributionValueBucketCounts {
	return &filterCndBuilderPointsValueDistributionValueBucketCounts{builder: b.builder}
}

type filterCndBuilderPointsValueDistributionValueCount struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderPointsValueDistributionValueCount) Eq(value int64) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderPointsValueDistributionValueCount) Neq(value int64) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderPointsValueDistributionValueCount) Gt(value int64) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderPointsValueDistributionValueCount) Gte(value int64) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderPointsValueDistributionValueCount) Lt(value int64) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderPointsValueDistributionValueCount) Lte(value int64) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderPointsValueDistributionValueCount) In(values []int64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().Count().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderPointsValueDistributionValueCount) NotIn(values []int64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().Count().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderPointsValueDistributionValueCount) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().Count().FieldPath(),
	})
}

func (b *filterCndBuilderPointsValueDistributionValueCount) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().Count().FieldPath(),
	})
}

func (b *filterCndBuilderPointsValueDistributionValueCount) compare(op gotenfilter.CompareOperator, value int64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                 op,
		TimeSerie_FieldPathValue: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().Count().WithValue(value),
	})
}

type filterCndBuilderPointsValueDistributionValueMean struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderPointsValueDistributionValueMean) Eq(value float64) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderPointsValueDistributionValueMean) Neq(value float64) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderPointsValueDistributionValueMean) Gt(value float64) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderPointsValueDistributionValueMean) Gte(value float64) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderPointsValueDistributionValueMean) Lt(value float64) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderPointsValueDistributionValueMean) Lte(value float64) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderPointsValueDistributionValueMean) In(values []float64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().Mean().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderPointsValueDistributionValueMean) NotIn(values []float64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().Mean().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderPointsValueDistributionValueMean) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().Mean().FieldPath(),
	})
}

func (b *filterCndBuilderPointsValueDistributionValueMean) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().Mean().FieldPath(),
	})
}

func (b *filterCndBuilderPointsValueDistributionValueMean) compare(op gotenfilter.CompareOperator, value float64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                 op,
		TimeSerie_FieldPathValue: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().Mean().WithValue(value),
	})
}

type filterCndBuilderPointsValueDistributionValueSumOfSquaredDeviation struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderPointsValueDistributionValueSumOfSquaredDeviation) Eq(value float64) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderPointsValueDistributionValueSumOfSquaredDeviation) Neq(value float64) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderPointsValueDistributionValueSumOfSquaredDeviation) Gt(value float64) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderPointsValueDistributionValueSumOfSquaredDeviation) Gte(value float64) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderPointsValueDistributionValueSumOfSquaredDeviation) Lt(value float64) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderPointsValueDistributionValueSumOfSquaredDeviation) Lte(value float64) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderPointsValueDistributionValueSumOfSquaredDeviation) In(values []float64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().SumOfSquaredDeviation().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderPointsValueDistributionValueSumOfSquaredDeviation) NotIn(values []float64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().SumOfSquaredDeviation().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderPointsValueDistributionValueSumOfSquaredDeviation) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().SumOfSquaredDeviation().FieldPath(),
	})
}

func (b *filterCndBuilderPointsValueDistributionValueSumOfSquaredDeviation) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().SumOfSquaredDeviation().FieldPath(),
	})
}

func (b *filterCndBuilderPointsValueDistributionValueSumOfSquaredDeviation) compare(op gotenfilter.CompareOperator, value float64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                 op,
		TimeSerie_FieldPathValue: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().SumOfSquaredDeviation().WithValue(value),
	})
}

type filterCndBuilderPointsValueDistributionValueRange struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderPointsValueDistributionValueRange) Eq(value *common.Distribution_Range) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderPointsValueDistributionValueRange) Neq(value *common.Distribution_Range) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderPointsValueDistributionValueRange) Gt(value *common.Distribution_Range) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderPointsValueDistributionValueRange) Gte(value *common.Distribution_Range) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderPointsValueDistributionValueRange) Lt(value *common.Distribution_Range) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderPointsValueDistributionValueRange) Lte(value *common.Distribution_Range) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderPointsValueDistributionValueRange) In(values []*common.Distribution_Range) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().Range().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderPointsValueDistributionValueRange) NotIn(values []*common.Distribution_Range) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().Range().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderPointsValueDistributionValueRange) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().Range().FieldPath(),
	})
}

func (b *filterCndBuilderPointsValueDistributionValueRange) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().Range().FieldPath(),
	})
}

func (b *filterCndBuilderPointsValueDistributionValueRange) compare(op gotenfilter.CompareOperator, value *common.Distribution_Range) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                 op,
		TimeSerie_FieldPathValue: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().Range().WithValue(value),
	})
}

func (b *filterCndBuilderPointsValueDistributionValueRange) Min() *filterCndBuilderPointsValueDistributionValueRangeMin {
	return &filterCndBuilderPointsValueDistributionValueRangeMin{builder: b.builder}
}

func (b *filterCndBuilderPointsValueDistributionValueRange) Max() *filterCndBuilderPointsValueDistributionValueRangeMax {
	return &filterCndBuilderPointsValueDistributionValueRangeMax{builder: b.builder}
}

type filterCndBuilderPointsValueDistributionValueRangeMin struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderPointsValueDistributionValueRangeMin) Eq(value float64) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderPointsValueDistributionValueRangeMin) Neq(value float64) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderPointsValueDistributionValueRangeMin) Gt(value float64) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderPointsValueDistributionValueRangeMin) Gte(value float64) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderPointsValueDistributionValueRangeMin) Lt(value float64) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderPointsValueDistributionValueRangeMin) Lte(value float64) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderPointsValueDistributionValueRangeMin) In(values []float64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().Range().Min().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderPointsValueDistributionValueRangeMin) NotIn(values []float64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().Range().Min().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderPointsValueDistributionValueRangeMin) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().Range().Min().FieldPath(),
	})
}

func (b *filterCndBuilderPointsValueDistributionValueRangeMin) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().Range().Min().FieldPath(),
	})
}

func (b *filterCndBuilderPointsValueDistributionValueRangeMin) compare(op gotenfilter.CompareOperator, value float64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                 op,
		TimeSerie_FieldPathValue: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().Range().Min().WithValue(value),
	})
}

type filterCndBuilderPointsValueDistributionValueRangeMax struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderPointsValueDistributionValueRangeMax) Eq(value float64) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderPointsValueDistributionValueRangeMax) Neq(value float64) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderPointsValueDistributionValueRangeMax) Gt(value float64) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderPointsValueDistributionValueRangeMax) Gte(value float64) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderPointsValueDistributionValueRangeMax) Lt(value float64) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderPointsValueDistributionValueRangeMax) Lte(value float64) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderPointsValueDistributionValueRangeMax) In(values []float64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().Range().Max().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderPointsValueDistributionValueRangeMax) NotIn(values []float64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().Range().Max().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderPointsValueDistributionValueRangeMax) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().Range().Max().FieldPath(),
	})
}

func (b *filterCndBuilderPointsValueDistributionValueRangeMax) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().Range().Max().FieldPath(),
	})
}

func (b *filterCndBuilderPointsValueDistributionValueRangeMax) compare(op gotenfilter.CompareOperator, value float64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                 op,
		TimeSerie_FieldPathValue: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().Range().Max().WithValue(value),
	})
}

type filterCndBuilderPointsValueDistributionValueBucketOptions struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptions) Eq(value *common.Distribution_BucketOptions) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptions) Neq(value *common.Distribution_BucketOptions) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptions) Gt(value *common.Distribution_BucketOptions) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptions) Gte(value *common.Distribution_BucketOptions) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptions) Lt(value *common.Distribution_BucketOptions) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptions) Lte(value *common.Distribution_BucketOptions) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptions) In(values []*common.Distribution_BucketOptions) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().BucketOptions().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptions) NotIn(values []*common.Distribution_BucketOptions) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().BucketOptions().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptions) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().BucketOptions().FieldPath(),
	})
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptions) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().BucketOptions().FieldPath(),
	})
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptions) compare(op gotenfilter.CompareOperator, value *common.Distribution_BucketOptions) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                 op,
		TimeSerie_FieldPathValue: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().BucketOptions().WithValue(value),
	})
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptions) LinearBuckets() *filterCndBuilderPointsValueDistributionValueBucketOptionsLinearBuckets {
	return &filterCndBuilderPointsValueDistributionValueBucketOptionsLinearBuckets{builder: b.builder}
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptions) ExponentialBuckets() *filterCndBuilderPointsValueDistributionValueBucketOptionsExponentialBuckets {
	return &filterCndBuilderPointsValueDistributionValueBucketOptionsExponentialBuckets{builder: b.builder}
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptions) ExplicitBuckets() *filterCndBuilderPointsValueDistributionValueBucketOptionsExplicitBuckets {
	return &filterCndBuilderPointsValueDistributionValueBucketOptionsExplicitBuckets{builder: b.builder}
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptions) DynamicBuckets() *filterCndBuilderPointsValueDistributionValueBucketOptionsDynamicBuckets {
	return &filterCndBuilderPointsValueDistributionValueBucketOptionsDynamicBuckets{builder: b.builder}
}

type filterCndBuilderPointsValueDistributionValueBucketOptionsLinearBuckets struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsLinearBuckets) Eq(value *common.Distribution_BucketOptions_Linear) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsLinearBuckets) Neq(value *common.Distribution_BucketOptions_Linear) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsLinearBuckets) Gt(value *common.Distribution_BucketOptions_Linear) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsLinearBuckets) Gte(value *common.Distribution_BucketOptions_Linear) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsLinearBuckets) Lt(value *common.Distribution_BucketOptions_Linear) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsLinearBuckets) Lte(value *common.Distribution_BucketOptions_Linear) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsLinearBuckets) In(values []*common.Distribution_BucketOptions_Linear) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().BucketOptions().LinearBuckets().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsLinearBuckets) NotIn(values []*common.Distribution_BucketOptions_Linear) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().BucketOptions().LinearBuckets().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsLinearBuckets) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().BucketOptions().LinearBuckets().FieldPath(),
	})
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsLinearBuckets) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().BucketOptions().LinearBuckets().FieldPath(),
	})
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsLinearBuckets) compare(op gotenfilter.CompareOperator, value *common.Distribution_BucketOptions_Linear) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                 op,
		TimeSerie_FieldPathValue: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().BucketOptions().LinearBuckets().WithValue(value),
	})
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsLinearBuckets) NumFiniteBuckets() *filterCndBuilderPointsValueDistributionValueBucketOptionsLinearBucketsNumFiniteBuckets {
	return &filterCndBuilderPointsValueDistributionValueBucketOptionsLinearBucketsNumFiniteBuckets{builder: b.builder}
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsLinearBuckets) Width() *filterCndBuilderPointsValueDistributionValueBucketOptionsLinearBucketsWidth {
	return &filterCndBuilderPointsValueDistributionValueBucketOptionsLinearBucketsWidth{builder: b.builder}
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsLinearBuckets) Offset() *filterCndBuilderPointsValueDistributionValueBucketOptionsLinearBucketsOffset {
	return &filterCndBuilderPointsValueDistributionValueBucketOptionsLinearBucketsOffset{builder: b.builder}
}

type filterCndBuilderPointsValueDistributionValueBucketOptionsLinearBucketsNumFiniteBuckets struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsLinearBucketsNumFiniteBuckets) Eq(value int32) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsLinearBucketsNumFiniteBuckets) Neq(value int32) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsLinearBucketsNumFiniteBuckets) Gt(value int32) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsLinearBucketsNumFiniteBuckets) Gte(value int32) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsLinearBucketsNumFiniteBuckets) Lt(value int32) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsLinearBucketsNumFiniteBuckets) Lte(value int32) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsLinearBucketsNumFiniteBuckets) In(values []int32) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().BucketOptions().LinearBuckets().NumFiniteBuckets().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsLinearBucketsNumFiniteBuckets) NotIn(values []int32) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().BucketOptions().LinearBuckets().NumFiniteBuckets().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsLinearBucketsNumFiniteBuckets) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().BucketOptions().LinearBuckets().NumFiniteBuckets().FieldPath(),
	})
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsLinearBucketsNumFiniteBuckets) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().BucketOptions().LinearBuckets().NumFiniteBuckets().FieldPath(),
	})
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsLinearBucketsNumFiniteBuckets) compare(op gotenfilter.CompareOperator, value int32) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                 op,
		TimeSerie_FieldPathValue: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().BucketOptions().LinearBuckets().NumFiniteBuckets().WithValue(value),
	})
}

type filterCndBuilderPointsValueDistributionValueBucketOptionsLinearBucketsWidth struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsLinearBucketsWidth) Eq(value float64) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsLinearBucketsWidth) Neq(value float64) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsLinearBucketsWidth) Gt(value float64) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsLinearBucketsWidth) Gte(value float64) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsLinearBucketsWidth) Lt(value float64) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsLinearBucketsWidth) Lte(value float64) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsLinearBucketsWidth) In(values []float64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().BucketOptions().LinearBuckets().Width().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsLinearBucketsWidth) NotIn(values []float64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().BucketOptions().LinearBuckets().Width().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsLinearBucketsWidth) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().BucketOptions().LinearBuckets().Width().FieldPath(),
	})
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsLinearBucketsWidth) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().BucketOptions().LinearBuckets().Width().FieldPath(),
	})
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsLinearBucketsWidth) compare(op gotenfilter.CompareOperator, value float64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                 op,
		TimeSerie_FieldPathValue: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().BucketOptions().LinearBuckets().Width().WithValue(value),
	})
}

type filterCndBuilderPointsValueDistributionValueBucketOptionsLinearBucketsOffset struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsLinearBucketsOffset) Eq(value float64) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsLinearBucketsOffset) Neq(value float64) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsLinearBucketsOffset) Gt(value float64) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsLinearBucketsOffset) Gte(value float64) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsLinearBucketsOffset) Lt(value float64) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsLinearBucketsOffset) Lte(value float64) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsLinearBucketsOffset) In(values []float64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().BucketOptions().LinearBuckets().Offset().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsLinearBucketsOffset) NotIn(values []float64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().BucketOptions().LinearBuckets().Offset().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsLinearBucketsOffset) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().BucketOptions().LinearBuckets().Offset().FieldPath(),
	})
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsLinearBucketsOffset) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().BucketOptions().LinearBuckets().Offset().FieldPath(),
	})
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsLinearBucketsOffset) compare(op gotenfilter.CompareOperator, value float64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                 op,
		TimeSerie_FieldPathValue: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().BucketOptions().LinearBuckets().Offset().WithValue(value),
	})
}

type filterCndBuilderPointsValueDistributionValueBucketOptionsExponentialBuckets struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsExponentialBuckets) Eq(value *common.Distribution_BucketOptions_Exponential) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsExponentialBuckets) Neq(value *common.Distribution_BucketOptions_Exponential) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsExponentialBuckets) Gt(value *common.Distribution_BucketOptions_Exponential) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsExponentialBuckets) Gte(value *common.Distribution_BucketOptions_Exponential) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsExponentialBuckets) Lt(value *common.Distribution_BucketOptions_Exponential) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsExponentialBuckets) Lte(value *common.Distribution_BucketOptions_Exponential) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsExponentialBuckets) In(values []*common.Distribution_BucketOptions_Exponential) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().BucketOptions().ExponentialBuckets().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsExponentialBuckets) NotIn(values []*common.Distribution_BucketOptions_Exponential) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().BucketOptions().ExponentialBuckets().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsExponentialBuckets) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().BucketOptions().ExponentialBuckets().FieldPath(),
	})
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsExponentialBuckets) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().BucketOptions().ExponentialBuckets().FieldPath(),
	})
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsExponentialBuckets) compare(op gotenfilter.CompareOperator, value *common.Distribution_BucketOptions_Exponential) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                 op,
		TimeSerie_FieldPathValue: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().BucketOptions().ExponentialBuckets().WithValue(value),
	})
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsExponentialBuckets) NumFiniteBuckets() *filterCndBuilderPointsValueDistributionValueBucketOptionsExponentialBucketsNumFiniteBuckets {
	return &filterCndBuilderPointsValueDistributionValueBucketOptionsExponentialBucketsNumFiniteBuckets{builder: b.builder}
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsExponentialBuckets) GrowthFactor() *filterCndBuilderPointsValueDistributionValueBucketOptionsExponentialBucketsGrowthFactor {
	return &filterCndBuilderPointsValueDistributionValueBucketOptionsExponentialBucketsGrowthFactor{builder: b.builder}
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsExponentialBuckets) Scale() *filterCndBuilderPointsValueDistributionValueBucketOptionsExponentialBucketsScale {
	return &filterCndBuilderPointsValueDistributionValueBucketOptionsExponentialBucketsScale{builder: b.builder}
}

type filterCndBuilderPointsValueDistributionValueBucketOptionsExponentialBucketsNumFiniteBuckets struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsExponentialBucketsNumFiniteBuckets) Eq(value int32) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsExponentialBucketsNumFiniteBuckets) Neq(value int32) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsExponentialBucketsNumFiniteBuckets) Gt(value int32) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsExponentialBucketsNumFiniteBuckets) Gte(value int32) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsExponentialBucketsNumFiniteBuckets) Lt(value int32) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsExponentialBucketsNumFiniteBuckets) Lte(value int32) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsExponentialBucketsNumFiniteBuckets) In(values []int32) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().BucketOptions().ExponentialBuckets().NumFiniteBuckets().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsExponentialBucketsNumFiniteBuckets) NotIn(values []int32) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().BucketOptions().ExponentialBuckets().NumFiniteBuckets().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsExponentialBucketsNumFiniteBuckets) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().BucketOptions().ExponentialBuckets().NumFiniteBuckets().FieldPath(),
	})
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsExponentialBucketsNumFiniteBuckets) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().BucketOptions().ExponentialBuckets().NumFiniteBuckets().FieldPath(),
	})
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsExponentialBucketsNumFiniteBuckets) compare(op gotenfilter.CompareOperator, value int32) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                 op,
		TimeSerie_FieldPathValue: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().BucketOptions().ExponentialBuckets().NumFiniteBuckets().WithValue(value),
	})
}

type filterCndBuilderPointsValueDistributionValueBucketOptionsExponentialBucketsGrowthFactor struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsExponentialBucketsGrowthFactor) Eq(value float64) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsExponentialBucketsGrowthFactor) Neq(value float64) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsExponentialBucketsGrowthFactor) Gt(value float64) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsExponentialBucketsGrowthFactor) Gte(value float64) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsExponentialBucketsGrowthFactor) Lt(value float64) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsExponentialBucketsGrowthFactor) Lte(value float64) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsExponentialBucketsGrowthFactor) In(values []float64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().BucketOptions().ExponentialBuckets().GrowthFactor().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsExponentialBucketsGrowthFactor) NotIn(values []float64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().BucketOptions().ExponentialBuckets().GrowthFactor().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsExponentialBucketsGrowthFactor) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().BucketOptions().ExponentialBuckets().GrowthFactor().FieldPath(),
	})
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsExponentialBucketsGrowthFactor) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().BucketOptions().ExponentialBuckets().GrowthFactor().FieldPath(),
	})
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsExponentialBucketsGrowthFactor) compare(op gotenfilter.CompareOperator, value float64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                 op,
		TimeSerie_FieldPathValue: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().BucketOptions().ExponentialBuckets().GrowthFactor().WithValue(value),
	})
}

type filterCndBuilderPointsValueDistributionValueBucketOptionsExponentialBucketsScale struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsExponentialBucketsScale) Eq(value float64) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsExponentialBucketsScale) Neq(value float64) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsExponentialBucketsScale) Gt(value float64) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsExponentialBucketsScale) Gte(value float64) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsExponentialBucketsScale) Lt(value float64) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsExponentialBucketsScale) Lte(value float64) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsExponentialBucketsScale) In(values []float64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().BucketOptions().ExponentialBuckets().Scale().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsExponentialBucketsScale) NotIn(values []float64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().BucketOptions().ExponentialBuckets().Scale().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsExponentialBucketsScale) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().BucketOptions().ExponentialBuckets().Scale().FieldPath(),
	})
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsExponentialBucketsScale) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().BucketOptions().ExponentialBuckets().Scale().FieldPath(),
	})
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsExponentialBucketsScale) compare(op gotenfilter.CompareOperator, value float64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                 op,
		TimeSerie_FieldPathValue: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().BucketOptions().ExponentialBuckets().Scale().WithValue(value),
	})
}

type filterCndBuilderPointsValueDistributionValueBucketOptionsExplicitBuckets struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsExplicitBuckets) Eq(value *common.Distribution_BucketOptions_Explicit) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsExplicitBuckets) Neq(value *common.Distribution_BucketOptions_Explicit) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsExplicitBuckets) Gt(value *common.Distribution_BucketOptions_Explicit) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsExplicitBuckets) Gte(value *common.Distribution_BucketOptions_Explicit) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsExplicitBuckets) Lt(value *common.Distribution_BucketOptions_Explicit) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsExplicitBuckets) Lte(value *common.Distribution_BucketOptions_Explicit) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsExplicitBuckets) In(values []*common.Distribution_BucketOptions_Explicit) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().BucketOptions().ExplicitBuckets().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsExplicitBuckets) NotIn(values []*common.Distribution_BucketOptions_Explicit) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().BucketOptions().ExplicitBuckets().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsExplicitBuckets) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().BucketOptions().ExplicitBuckets().FieldPath(),
	})
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsExplicitBuckets) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().BucketOptions().ExplicitBuckets().FieldPath(),
	})
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsExplicitBuckets) compare(op gotenfilter.CompareOperator, value *common.Distribution_BucketOptions_Explicit) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                 op,
		TimeSerie_FieldPathValue: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().BucketOptions().ExplicitBuckets().WithValue(value),
	})
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsExplicitBuckets) Bounds() *filterCndBuilderPointsValueDistributionValueBucketOptionsExplicitBucketsBounds {
	return &filterCndBuilderPointsValueDistributionValueBucketOptionsExplicitBucketsBounds{builder: b.builder}
}

type filterCndBuilderPointsValueDistributionValueBucketOptionsExplicitBucketsBounds struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsExplicitBucketsBounds) Eq(value []float64) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsExplicitBucketsBounds) Neq(value []float64) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsExplicitBucketsBounds) Gt(value []float64) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsExplicitBucketsBounds) Gte(value []float64) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsExplicitBucketsBounds) Lt(value []float64) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsExplicitBucketsBounds) Lte(value []float64) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsExplicitBucketsBounds) In(values [][]float64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().BucketOptions().ExplicitBuckets().Bounds().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsExplicitBucketsBounds) NotIn(values [][]float64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().BucketOptions().ExplicitBuckets().Bounds().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsExplicitBucketsBounds) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().BucketOptions().ExplicitBuckets().Bounds().FieldPath(),
	})
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsExplicitBucketsBounds) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().BucketOptions().ExplicitBuckets().Bounds().FieldPath(),
	})
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsExplicitBucketsBounds) Contains(value float64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().BucketOptions().ExplicitBuckets().Bounds().FieldPath(),
		Value:     NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().BucketOptions().ExplicitBuckets().Bounds().WithItemValue(value),
	})
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsExplicitBucketsBounds) ContainsAnyOf(values []float64) *FilterBuilder {
	pathSelector := NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().BucketOptions().ExplicitBuckets().Bounds()
	itemValues := make([]TimeSerie_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().BucketOptions().ExplicitBuckets().Bounds().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsExplicitBucketsBounds) ContainsAll(values []float64) *FilterBuilder {
	pathSelector := NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().BucketOptions().ExplicitBuckets().Bounds()
	itemValues := make([]TimeSerie_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().BucketOptions().ExplicitBuckets().Bounds().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsExplicitBucketsBounds) compare(op gotenfilter.CompareOperator, value []float64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                 op,
		TimeSerie_FieldPathValue: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().BucketOptions().ExplicitBuckets().Bounds().WithValue(value),
	})
}

type filterCndBuilderPointsValueDistributionValueBucketOptionsDynamicBuckets struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsDynamicBuckets) Eq(value *common.Distribution_BucketOptions_Dynamic) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsDynamicBuckets) Neq(value *common.Distribution_BucketOptions_Dynamic) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsDynamicBuckets) Gt(value *common.Distribution_BucketOptions_Dynamic) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsDynamicBuckets) Gte(value *common.Distribution_BucketOptions_Dynamic) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsDynamicBuckets) Lt(value *common.Distribution_BucketOptions_Dynamic) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsDynamicBuckets) Lte(value *common.Distribution_BucketOptions_Dynamic) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsDynamicBuckets) In(values []*common.Distribution_BucketOptions_Dynamic) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().BucketOptions().DynamicBuckets().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsDynamicBuckets) NotIn(values []*common.Distribution_BucketOptions_Dynamic) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().BucketOptions().DynamicBuckets().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsDynamicBuckets) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().BucketOptions().DynamicBuckets().FieldPath(),
	})
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsDynamicBuckets) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().BucketOptions().DynamicBuckets().FieldPath(),
	})
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsDynamicBuckets) compare(op gotenfilter.CompareOperator, value *common.Distribution_BucketOptions_Dynamic) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                 op,
		TimeSerie_FieldPathValue: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().BucketOptions().DynamicBuckets().WithValue(value),
	})
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsDynamicBuckets) Compression() *filterCndBuilderPointsValueDistributionValueBucketOptionsDynamicBucketsCompression {
	return &filterCndBuilderPointsValueDistributionValueBucketOptionsDynamicBucketsCompression{builder: b.builder}
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsDynamicBuckets) Means() *filterCndBuilderPointsValueDistributionValueBucketOptionsDynamicBucketsMeans {
	return &filterCndBuilderPointsValueDistributionValueBucketOptionsDynamicBucketsMeans{builder: b.builder}
}

type filterCndBuilderPointsValueDistributionValueBucketOptionsDynamicBucketsCompression struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsDynamicBucketsCompression) Eq(value float64) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsDynamicBucketsCompression) Neq(value float64) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsDynamicBucketsCompression) Gt(value float64) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsDynamicBucketsCompression) Gte(value float64) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsDynamicBucketsCompression) Lt(value float64) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsDynamicBucketsCompression) Lte(value float64) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsDynamicBucketsCompression) In(values []float64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().BucketOptions().DynamicBuckets().Compression().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsDynamicBucketsCompression) NotIn(values []float64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().BucketOptions().DynamicBuckets().Compression().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsDynamicBucketsCompression) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().BucketOptions().DynamicBuckets().Compression().FieldPath(),
	})
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsDynamicBucketsCompression) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().BucketOptions().DynamicBuckets().Compression().FieldPath(),
	})
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsDynamicBucketsCompression) compare(op gotenfilter.CompareOperator, value float64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                 op,
		TimeSerie_FieldPathValue: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().BucketOptions().DynamicBuckets().Compression().WithValue(value),
	})
}

type filterCndBuilderPointsValueDistributionValueBucketOptionsDynamicBucketsMeans struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsDynamicBucketsMeans) Eq(value []float64) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsDynamicBucketsMeans) Neq(value []float64) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsDynamicBucketsMeans) Gt(value []float64) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsDynamicBucketsMeans) Gte(value []float64) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsDynamicBucketsMeans) Lt(value []float64) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsDynamicBucketsMeans) Lte(value []float64) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsDynamicBucketsMeans) In(values [][]float64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().BucketOptions().DynamicBuckets().Means().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsDynamicBucketsMeans) NotIn(values [][]float64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().BucketOptions().DynamicBuckets().Means().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsDynamicBucketsMeans) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().BucketOptions().DynamicBuckets().Means().FieldPath(),
	})
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsDynamicBucketsMeans) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().BucketOptions().DynamicBuckets().Means().FieldPath(),
	})
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsDynamicBucketsMeans) Contains(value float64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().BucketOptions().DynamicBuckets().Means().FieldPath(),
		Value:     NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().BucketOptions().DynamicBuckets().Means().WithItemValue(value),
	})
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsDynamicBucketsMeans) ContainsAnyOf(values []float64) *FilterBuilder {
	pathSelector := NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().BucketOptions().DynamicBuckets().Means()
	itemValues := make([]TimeSerie_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().BucketOptions().DynamicBuckets().Means().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsDynamicBucketsMeans) ContainsAll(values []float64) *FilterBuilder {
	pathSelector := NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().BucketOptions().DynamicBuckets().Means()
	itemValues := make([]TimeSerie_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().BucketOptions().DynamicBuckets().Means().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderPointsValueDistributionValueBucketOptionsDynamicBucketsMeans) compare(op gotenfilter.CompareOperator, value []float64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                 op,
		TimeSerie_FieldPathValue: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().BucketOptions().DynamicBuckets().Means().WithValue(value),
	})
}

type filterCndBuilderPointsValueDistributionValueBucketCounts struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderPointsValueDistributionValueBucketCounts) Eq(value []int64) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderPointsValueDistributionValueBucketCounts) Neq(value []int64) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderPointsValueDistributionValueBucketCounts) Gt(value []int64) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderPointsValueDistributionValueBucketCounts) Gte(value []int64) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderPointsValueDistributionValueBucketCounts) Lt(value []int64) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderPointsValueDistributionValueBucketCounts) Lte(value []int64) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderPointsValueDistributionValueBucketCounts) In(values [][]int64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().BucketCounts().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderPointsValueDistributionValueBucketCounts) NotIn(values [][]int64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().BucketCounts().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderPointsValueDistributionValueBucketCounts) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().BucketCounts().FieldPath(),
	})
}

func (b *filterCndBuilderPointsValueDistributionValueBucketCounts) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().BucketCounts().FieldPath(),
	})
}

func (b *filterCndBuilderPointsValueDistributionValueBucketCounts) Contains(value int64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().BucketCounts().FieldPath(),
		Value:     NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().BucketCounts().WithItemValue(value),
	})
}

func (b *filterCndBuilderPointsValueDistributionValueBucketCounts) ContainsAnyOf(values []int64) *FilterBuilder {
	pathSelector := NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().BucketCounts()
	itemValues := make([]TimeSerie_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().BucketCounts().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderPointsValueDistributionValueBucketCounts) ContainsAll(values []int64) *FilterBuilder {
	pathSelector := NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().BucketCounts()
	itemValues := make([]TimeSerie_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().BucketCounts().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderPointsValueDistributionValueBucketCounts) compare(op gotenfilter.CompareOperator, value []int64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                 op,
		TimeSerie_FieldPathValue: NewTimeSerieFieldPathBuilder().Points().Value().DistributionValue().BucketCounts().WithValue(value),
	})
}

type filterCndBuilderPointsAggregation struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderPointsAggregation) Eq(value *common.Aggregation) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderPointsAggregation) Neq(value *common.Aggregation) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderPointsAggregation) Gt(value *common.Aggregation) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderPointsAggregation) Gte(value *common.Aggregation) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderPointsAggregation) Lt(value *common.Aggregation) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderPointsAggregation) Lte(value *common.Aggregation) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderPointsAggregation) In(values []*common.Aggregation) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Points().Aggregation().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderPointsAggregation) NotIn(values []*common.Aggregation) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Points().Aggregation().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderPointsAggregation) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewTimeSerieFieldPathBuilder().Points().Aggregation().FieldPath(),
	})
}

func (b *filterCndBuilderPointsAggregation) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewTimeSerieFieldPathBuilder().Points().Aggregation().FieldPath(),
	})
}

func (b *filterCndBuilderPointsAggregation) compare(op gotenfilter.CompareOperator, value *common.Aggregation) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                 op,
		TimeSerie_FieldPathValue: NewTimeSerieFieldPathBuilder().Points().Aggregation().WithValue(value),
	})
}

func (b *filterCndBuilderPointsAggregation) AlignmentPeriod() *filterCndBuilderPointsAggregationAlignmentPeriod {
	return &filterCndBuilderPointsAggregationAlignmentPeriod{builder: b.builder}
}

func (b *filterCndBuilderPointsAggregation) PerSeriesAligner() *filterCndBuilderPointsAggregationPerSeriesAligner {
	return &filterCndBuilderPointsAggregationPerSeriesAligner{builder: b.builder}
}

func (b *filterCndBuilderPointsAggregation) CrossSeriesReducer() *filterCndBuilderPointsAggregationCrossSeriesReducer {
	return &filterCndBuilderPointsAggregationCrossSeriesReducer{builder: b.builder}
}

func (b *filterCndBuilderPointsAggregation) GroupByFields() *filterCndBuilderPointsAggregationGroupByFields {
	return &filterCndBuilderPointsAggregationGroupByFields{builder: b.builder}
}

type filterCndBuilderPointsAggregationAlignmentPeriod struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderPointsAggregationAlignmentPeriod) Eq(value *durationpb.Duration) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderPointsAggregationAlignmentPeriod) Neq(value *durationpb.Duration) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderPointsAggregationAlignmentPeriod) Gt(value *durationpb.Duration) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderPointsAggregationAlignmentPeriod) Gte(value *durationpb.Duration) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderPointsAggregationAlignmentPeriod) Lt(value *durationpb.Duration) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderPointsAggregationAlignmentPeriod) Lte(value *durationpb.Duration) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderPointsAggregationAlignmentPeriod) In(values []*durationpb.Duration) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Points().Aggregation().AlignmentPeriod().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderPointsAggregationAlignmentPeriod) NotIn(values []*durationpb.Duration) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Points().Aggregation().AlignmentPeriod().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderPointsAggregationAlignmentPeriod) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewTimeSerieFieldPathBuilder().Points().Aggregation().AlignmentPeriod().FieldPath(),
	})
}

func (b *filterCndBuilderPointsAggregationAlignmentPeriod) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewTimeSerieFieldPathBuilder().Points().Aggregation().AlignmentPeriod().FieldPath(),
	})
}

func (b *filterCndBuilderPointsAggregationAlignmentPeriod) compare(op gotenfilter.CompareOperator, value *durationpb.Duration) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                 op,
		TimeSerie_FieldPathValue: NewTimeSerieFieldPathBuilder().Points().Aggregation().AlignmentPeriod().WithValue(value),
	})
}

type filterCndBuilderPointsAggregationPerSeriesAligner struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderPointsAggregationPerSeriesAligner) Eq(value common.Aggregation_Aligner) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderPointsAggregationPerSeriesAligner) Neq(value common.Aggregation_Aligner) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderPointsAggregationPerSeriesAligner) Gt(value common.Aggregation_Aligner) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderPointsAggregationPerSeriesAligner) Gte(value common.Aggregation_Aligner) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderPointsAggregationPerSeriesAligner) Lt(value common.Aggregation_Aligner) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderPointsAggregationPerSeriesAligner) Lte(value common.Aggregation_Aligner) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderPointsAggregationPerSeriesAligner) In(values []common.Aggregation_Aligner) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Points().Aggregation().PerSeriesAligner().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderPointsAggregationPerSeriesAligner) NotIn(values []common.Aggregation_Aligner) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Points().Aggregation().PerSeriesAligner().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderPointsAggregationPerSeriesAligner) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewTimeSerieFieldPathBuilder().Points().Aggregation().PerSeriesAligner().FieldPath(),
	})
}

func (b *filterCndBuilderPointsAggregationPerSeriesAligner) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewTimeSerieFieldPathBuilder().Points().Aggregation().PerSeriesAligner().FieldPath(),
	})
}

func (b *filterCndBuilderPointsAggregationPerSeriesAligner) compare(op gotenfilter.CompareOperator, value common.Aggregation_Aligner) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                 op,
		TimeSerie_FieldPathValue: NewTimeSerieFieldPathBuilder().Points().Aggregation().PerSeriesAligner().WithValue(value),
	})
}

type filterCndBuilderPointsAggregationCrossSeriesReducer struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderPointsAggregationCrossSeriesReducer) Eq(value common.Aggregation_Reducer) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderPointsAggregationCrossSeriesReducer) Neq(value common.Aggregation_Reducer) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderPointsAggregationCrossSeriesReducer) Gt(value common.Aggregation_Reducer) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderPointsAggregationCrossSeriesReducer) Gte(value common.Aggregation_Reducer) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderPointsAggregationCrossSeriesReducer) Lt(value common.Aggregation_Reducer) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderPointsAggregationCrossSeriesReducer) Lte(value common.Aggregation_Reducer) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderPointsAggregationCrossSeriesReducer) In(values []common.Aggregation_Reducer) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Points().Aggregation().CrossSeriesReducer().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderPointsAggregationCrossSeriesReducer) NotIn(values []common.Aggregation_Reducer) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Points().Aggregation().CrossSeriesReducer().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderPointsAggregationCrossSeriesReducer) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewTimeSerieFieldPathBuilder().Points().Aggregation().CrossSeriesReducer().FieldPath(),
	})
}

func (b *filterCndBuilderPointsAggregationCrossSeriesReducer) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewTimeSerieFieldPathBuilder().Points().Aggregation().CrossSeriesReducer().FieldPath(),
	})
}

func (b *filterCndBuilderPointsAggregationCrossSeriesReducer) compare(op gotenfilter.CompareOperator, value common.Aggregation_Reducer) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                 op,
		TimeSerie_FieldPathValue: NewTimeSerieFieldPathBuilder().Points().Aggregation().CrossSeriesReducer().WithValue(value),
	})
}

type filterCndBuilderPointsAggregationGroupByFields struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderPointsAggregationGroupByFields) Eq(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderPointsAggregationGroupByFields) Neq(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderPointsAggregationGroupByFields) Gt(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderPointsAggregationGroupByFields) Gte(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderPointsAggregationGroupByFields) Lt(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderPointsAggregationGroupByFields) Lte(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderPointsAggregationGroupByFields) In(values [][]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Points().Aggregation().GroupByFields().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderPointsAggregationGroupByFields) NotIn(values [][]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		TimeSerie_FieldPathArrayOfValues: NewTimeSerieFieldPathBuilder().Points().Aggregation().GroupByFields().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderPointsAggregationGroupByFields) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewTimeSerieFieldPathBuilder().Points().Aggregation().GroupByFields().FieldPath(),
	})
}

func (b *filterCndBuilderPointsAggregationGroupByFields) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewTimeSerieFieldPathBuilder().Points().Aggregation().GroupByFields().FieldPath(),
	})
}

func (b *filterCndBuilderPointsAggregationGroupByFields) Contains(value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewTimeSerieFieldPathBuilder().Points().Aggregation().GroupByFields().FieldPath(),
		Value:     NewTimeSerieFieldPathBuilder().Points().Aggregation().GroupByFields().WithItemValue(value),
	})
}

func (b *filterCndBuilderPointsAggregationGroupByFields) ContainsAnyOf(values []string) *FilterBuilder {
	pathSelector := NewTimeSerieFieldPathBuilder().Points().Aggregation().GroupByFields()
	itemValues := make([]TimeSerie_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewTimeSerieFieldPathBuilder().Points().Aggregation().GroupByFields().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderPointsAggregationGroupByFields) ContainsAll(values []string) *FilterBuilder {
	pathSelector := NewTimeSerieFieldPathBuilder().Points().Aggregation().GroupByFields()
	itemValues := make([]TimeSerie_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewTimeSerieFieldPathBuilder().Points().Aggregation().GroupByFields().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderPointsAggregationGroupByFields) compare(op gotenfilter.CompareOperator, value []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                 op,
		TimeSerie_FieldPathValue: NewTimeSerieFieldPathBuilder().Points().Aggregation().GroupByFields().WithValue(value),
	})
}