phantom_time_serie.pb.filterbuilder.go

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

package phantom_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 {
	_IsPhantomTimeSerieFilterBuilderOrCondition()
}

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) _IsPhantomTimeSerieFilterBuilderOrCondition() {}

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 PhantomTimeSerie_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      PhantomTimeSerie_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{
		PhantomTimeSerie_FieldPathArrayOfValues: b.fp.WithIArrayOfValues(values),
	})
}

func (b *filterCndBuilderAnyPath) NotIn(values interface{}) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		PhantomTimeSerie_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) Contains(value interface{}) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: b.fp,
		Value:     b.fp.WithIArrayItemValue(value),
	})
}

func (b *filterCndBuilderAnyPath) ContainsAnyOf(values []interface{}) *FilterBuilder {
	itemValues := make([]PhantomTimeSerie_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, b.fp.WithIArrayItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: b.fp,
		Values:    itemValues,
	})
}

func (b *filterCndBuilderAnyPath) ContainsAll(values []interface{}) *FilterBuilder {
	itemValues := make([]PhantomTimeSerie_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, b.fp.WithIArrayItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: b.fp,
		Values:    itemValues,
	})
}

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

type filterCndBuilder struct {
	builder *FilterBuilder
}

func (b *filterCndBuilder) Name() *filterCndBuilderName {
	return &filterCndBuilderName{builder: b.builder}
}

func (b *filterCndBuilder) Metadata() *filterCndBuilderMetadata {
	return &filterCndBuilderMetadata{builder: b.builder}
}

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

func (b *filterCndBuilder) Project() *filterCndBuilderProject {
	return &filterCndBuilderProject{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) Value() *filterCndBuilderValue {
	return &filterCndBuilderValue{builder: b.builder}
}

type filterCndBuilderName struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderName) Eq(value *Name) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderName) Neq(value *Name) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderName) Gt(value *Name) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderName) Gte(value *Name) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderName) Lt(value *Name) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderName) Lte(value *Name) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderName) In(values []*Name) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Name().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderName) NotIn(values []*Name) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Name().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderName) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPhantomTimeSerieFieldPathBuilder().Name().FieldPath(),
	})
}

func (b *filterCndBuilderName) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPhantomTimeSerieFieldPathBuilder().Name().FieldPath(),
	})
}

func (b *filterCndBuilderName) compare(op gotenfilter.CompareOperator, value *Name) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                        op,
		PhantomTimeSerie_FieldPathValue: NewPhantomTimeSerieFieldPathBuilder().Name().WithValue(value),
	})
}

type filterCndBuilderMetadata struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderMetadata) Eq(value *meta.Meta) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderMetadata) Neq(value *meta.Meta) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderMetadata) Gt(value *meta.Meta) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderMetadata) Gte(value *meta.Meta) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderMetadata) Lt(value *meta.Meta) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderMetadata) Lte(value *meta.Meta) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderMetadata) In(values []*meta.Meta) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Metadata().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderMetadata) NotIn(values []*meta.Meta) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Metadata().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderMetadata) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPhantomTimeSerieFieldPathBuilder().Metadata().FieldPath(),
	})
}

func (b *filterCndBuilderMetadata) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPhantomTimeSerieFieldPathBuilder().Metadata().FieldPath(),
	})
}

func (b *filterCndBuilderMetadata) compare(op gotenfilter.CompareOperator, value *meta.Meta) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                        op,
		PhantomTimeSerie_FieldPathValue: NewPhantomTimeSerieFieldPathBuilder().Metadata().WithValue(value),
	})
}

func (b *filterCndBuilderMetadata) CreateTime() *filterCndBuilderMetadataCreateTime {
	return &filterCndBuilderMetadataCreateTime{builder: b.builder}
}

func (b *filterCndBuilderMetadata) UpdateTime() *filterCndBuilderMetadataUpdateTime {
	return &filterCndBuilderMetadataUpdateTime{builder: b.builder}
}

func (b *filterCndBuilderMetadata) DeleteTime() *filterCndBuilderMetadataDeleteTime {
	return &filterCndBuilderMetadataDeleteTime{builder: b.builder}
}

func (b *filterCndBuilderMetadata) Uuid() *filterCndBuilderMetadataUuid {
	return &filterCndBuilderMetadataUuid{builder: b.builder}
}

func (b *filterCndBuilderMetadata) Tags() *filterCndBuilderMetadataTags {
	return &filterCndBuilderMetadataTags{builder: b.builder}
}

func (b *filterCndBuilderMetadata) Labels() *filterCndBuilderMetadataLabels {
	return &filterCndBuilderMetadataLabels{builder: b.builder}
}

func (b *filterCndBuilderMetadata) Annotations() *filterCndBuilderMetadataAnnotations {
	return &filterCndBuilderMetadataAnnotations{builder: b.builder}
}

func (b *filterCndBuilderMetadata) Generation() *filterCndBuilderMetadataGeneration {
	return &filterCndBuilderMetadataGeneration{builder: b.builder}
}

func (b *filterCndBuilderMetadata) ResourceVersion() *filterCndBuilderMetadataResourceVersion {
	return &filterCndBuilderMetadataResourceVersion{builder: b.builder}
}

func (b *filterCndBuilderMetadata) OwnerReferences() *filterCndBuilderMetadataOwnerReferences {
	return &filterCndBuilderMetadataOwnerReferences{builder: b.builder}
}

func (b *filterCndBuilderMetadata) Shards() *filterCndBuilderMetadataShards {
	return &filterCndBuilderMetadataShards{builder: b.builder}
}

func (b *filterCndBuilderMetadata) Syncing() *filterCndBuilderMetadataSyncing {
	return &filterCndBuilderMetadataSyncing{builder: b.builder}
}

func (b *filterCndBuilderMetadata) Lifecycle() *filterCndBuilderMetadataLifecycle {
	return &filterCndBuilderMetadataLifecycle{builder: b.builder}
}

func (b *filterCndBuilderMetadata) Services() *filterCndBuilderMetadataServices {
	return &filterCndBuilderMetadataServices{builder: b.builder}
}

type filterCndBuilderMetadataCreateTime struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderMetadataCreateTime) In(values []*timestamppb.Timestamp) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Metadata().CreateTime().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderMetadataCreateTime) NotIn(values []*timestamppb.Timestamp) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Metadata().CreateTime().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderMetadataCreateTime) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPhantomTimeSerieFieldPathBuilder().Metadata().CreateTime().FieldPath(),
	})
}

func (b *filterCndBuilderMetadataCreateTime) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPhantomTimeSerieFieldPathBuilder().Metadata().CreateTime().FieldPath(),
	})
}

func (b *filterCndBuilderMetadataCreateTime) compare(op gotenfilter.CompareOperator, value *timestamppb.Timestamp) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                        op,
		PhantomTimeSerie_FieldPathValue: NewPhantomTimeSerieFieldPathBuilder().Metadata().CreateTime().WithValue(value),
	})
}

type filterCndBuilderMetadataUpdateTime struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderMetadataUpdateTime) In(values []*timestamppb.Timestamp) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Metadata().UpdateTime().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderMetadataUpdateTime) NotIn(values []*timestamppb.Timestamp) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Metadata().UpdateTime().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderMetadataUpdateTime) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPhantomTimeSerieFieldPathBuilder().Metadata().UpdateTime().FieldPath(),
	})
}

func (b *filterCndBuilderMetadataUpdateTime) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPhantomTimeSerieFieldPathBuilder().Metadata().UpdateTime().FieldPath(),
	})
}

func (b *filterCndBuilderMetadataUpdateTime) compare(op gotenfilter.CompareOperator, value *timestamppb.Timestamp) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                        op,
		PhantomTimeSerie_FieldPathValue: NewPhantomTimeSerieFieldPathBuilder().Metadata().UpdateTime().WithValue(value),
	})
}

type filterCndBuilderMetadataDeleteTime struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderMetadataDeleteTime) In(values []*timestamppb.Timestamp) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Metadata().DeleteTime().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderMetadataDeleteTime) NotIn(values []*timestamppb.Timestamp) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Metadata().DeleteTime().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderMetadataDeleteTime) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPhantomTimeSerieFieldPathBuilder().Metadata().DeleteTime().FieldPath(),
	})
}

func (b *filterCndBuilderMetadataDeleteTime) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPhantomTimeSerieFieldPathBuilder().Metadata().DeleteTime().FieldPath(),
	})
}

func (b *filterCndBuilderMetadataDeleteTime) compare(op gotenfilter.CompareOperator, value *timestamppb.Timestamp) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                        op,
		PhantomTimeSerie_FieldPathValue: NewPhantomTimeSerieFieldPathBuilder().Metadata().DeleteTime().WithValue(value),
	})
}

type filterCndBuilderMetadataUuid struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderMetadataUuid) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Metadata().Uuid().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderMetadataUuid) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Metadata().Uuid().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderMetadataUuid) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPhantomTimeSerieFieldPathBuilder().Metadata().Uuid().FieldPath(),
	})
}

func (b *filterCndBuilderMetadataUuid) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPhantomTimeSerieFieldPathBuilder().Metadata().Uuid().FieldPath(),
	})
}

func (b *filterCndBuilderMetadataUuid) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                        op,
		PhantomTimeSerie_FieldPathValue: NewPhantomTimeSerieFieldPathBuilder().Metadata().Uuid().WithValue(value),
	})
}

type filterCndBuilderMetadataTags struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderMetadataTags) In(values [][]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Metadata().Tags().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderMetadataTags) NotIn(values [][]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Metadata().Tags().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderMetadataTags) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPhantomTimeSerieFieldPathBuilder().Metadata().Tags().FieldPath(),
	})
}

func (b *filterCndBuilderMetadataTags) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPhantomTimeSerieFieldPathBuilder().Metadata().Tags().FieldPath(),
	})
}

func (b *filterCndBuilderMetadataTags) Contains(value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewPhantomTimeSerieFieldPathBuilder().Metadata().Tags().FieldPath(),
		Value:     NewPhantomTimeSerieFieldPathBuilder().Metadata().Tags().WithItemValue(value),
	})
}

func (b *filterCndBuilderMetadataTags) ContainsAnyOf(values []string) *FilterBuilder {
	pathSelector := NewPhantomTimeSerieFieldPathBuilder().Metadata().Tags()
	itemValues := make([]PhantomTimeSerie_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewPhantomTimeSerieFieldPathBuilder().Metadata().Tags().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderMetadataTags) ContainsAll(values []string) *FilterBuilder {
	pathSelector := NewPhantomTimeSerieFieldPathBuilder().Metadata().Tags()
	itemValues := make([]PhantomTimeSerie_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewPhantomTimeSerieFieldPathBuilder().Metadata().Tags().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderMetadataTags) compare(op gotenfilter.CompareOperator, value []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                        op,
		PhantomTimeSerie_FieldPathValue: NewPhantomTimeSerieFieldPathBuilder().Metadata().Tags().WithValue(value),
	})
}

type filterCndBuilderMetadataLabels struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderMetadataLabels) In(values []map[string]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Metadata().Labels().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderMetadataLabels) NotIn(values []map[string]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Metadata().Labels().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderMetadataLabels) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPhantomTimeSerieFieldPathBuilder().Metadata().Labels().FieldPath(),
	})
}

func (b *filterCndBuilderMetadataLabels) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPhantomTimeSerieFieldPathBuilder().Metadata().Labels().FieldPath(),
	})
}

func (b *filterCndBuilderMetadataLabels) compare(op gotenfilter.CompareOperator, value map[string]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                        op,
		PhantomTimeSerie_FieldPathValue: NewPhantomTimeSerieFieldPathBuilder().Metadata().Labels().WithValue(value),
	})
}

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

type mapFilterCndBuilderMetadataLabels struct {
	builder *FilterBuilder
	key     string
}

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

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

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

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

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

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

func (b *mapFilterCndBuilderMetadataLabels) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Metadata().Labels().WithKey(b.key).WithArrayOfValues(values),
	})
}

func (b *mapFilterCndBuilderMetadataLabels) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Metadata().Labels().WithKey(b.key).WithArrayOfValues(values),
	})
}

func (b *mapFilterCndBuilderMetadataLabels) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPhantomTimeSerieFieldPathBuilder().Metadata().Labels().WithKey(b.key).FieldPath(),
	})
}

func (b *mapFilterCndBuilderMetadataLabels) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPhantomTimeSerieFieldPathBuilder().Metadata().Labels().WithKey(b.key).FieldPath(),
	})
}

func (b *mapFilterCndBuilderMetadataLabels) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                        op,
		PhantomTimeSerie_FieldPathValue: NewPhantomTimeSerieFieldPathBuilder().Metadata().Labels().WithKey(b.key).WithValue(value),
	})
}

type filterCndBuilderMetadataAnnotations struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderMetadataAnnotations) In(values []map[string]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Metadata().Annotations().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderMetadataAnnotations) NotIn(values []map[string]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Metadata().Annotations().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderMetadataAnnotations) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPhantomTimeSerieFieldPathBuilder().Metadata().Annotations().FieldPath(),
	})
}

func (b *filterCndBuilderMetadataAnnotations) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPhantomTimeSerieFieldPathBuilder().Metadata().Annotations().FieldPath(),
	})
}

func (b *filterCndBuilderMetadataAnnotations) compare(op gotenfilter.CompareOperator, value map[string]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                        op,
		PhantomTimeSerie_FieldPathValue: NewPhantomTimeSerieFieldPathBuilder().Metadata().Annotations().WithValue(value),
	})
}

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

type mapFilterCndBuilderMetadataAnnotations struct {
	builder *FilterBuilder
	key     string
}

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

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

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

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

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

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

func (b *mapFilterCndBuilderMetadataAnnotations) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Metadata().Annotations().WithKey(b.key).WithArrayOfValues(values),
	})
}

func (b *mapFilterCndBuilderMetadataAnnotations) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Metadata().Annotations().WithKey(b.key).WithArrayOfValues(values),
	})
}

func (b *mapFilterCndBuilderMetadataAnnotations) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPhantomTimeSerieFieldPathBuilder().Metadata().Annotations().WithKey(b.key).FieldPath(),
	})
}

func (b *mapFilterCndBuilderMetadataAnnotations) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPhantomTimeSerieFieldPathBuilder().Metadata().Annotations().WithKey(b.key).FieldPath(),
	})
}

func (b *mapFilterCndBuilderMetadataAnnotations) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                        op,
		PhantomTimeSerie_FieldPathValue: NewPhantomTimeSerieFieldPathBuilder().Metadata().Annotations().WithKey(b.key).WithValue(value),
	})
}

type filterCndBuilderMetadataGeneration struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderMetadataGeneration) In(values []int64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Metadata().Generation().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderMetadataGeneration) NotIn(values []int64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Metadata().Generation().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderMetadataGeneration) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPhantomTimeSerieFieldPathBuilder().Metadata().Generation().FieldPath(),
	})
}

func (b *filterCndBuilderMetadataGeneration) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPhantomTimeSerieFieldPathBuilder().Metadata().Generation().FieldPath(),
	})
}

func (b *filterCndBuilderMetadataGeneration) compare(op gotenfilter.CompareOperator, value int64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                        op,
		PhantomTimeSerie_FieldPathValue: NewPhantomTimeSerieFieldPathBuilder().Metadata().Generation().WithValue(value),
	})
}

type filterCndBuilderMetadataResourceVersion struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderMetadataResourceVersion) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Metadata().ResourceVersion().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderMetadataResourceVersion) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Metadata().ResourceVersion().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderMetadataResourceVersion) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPhantomTimeSerieFieldPathBuilder().Metadata().ResourceVersion().FieldPath(),
	})
}

func (b *filterCndBuilderMetadataResourceVersion) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPhantomTimeSerieFieldPathBuilder().Metadata().ResourceVersion().FieldPath(),
	})
}

func (b *filterCndBuilderMetadataResourceVersion) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                        op,
		PhantomTimeSerie_FieldPathValue: NewPhantomTimeSerieFieldPathBuilder().Metadata().ResourceVersion().WithValue(value),
	})
}

type filterCndBuilderMetadataOwnerReferences struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderMetadataOwnerReferences) Eq(value []*meta.OwnerReference) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderMetadataOwnerReferences) Neq(value []*meta.OwnerReference) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderMetadataOwnerReferences) Gt(value []*meta.OwnerReference) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderMetadataOwnerReferences) Gte(value []*meta.OwnerReference) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderMetadataOwnerReferences) Lt(value []*meta.OwnerReference) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderMetadataOwnerReferences) Lte(value []*meta.OwnerReference) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderMetadataOwnerReferences) In(values [][]*meta.OwnerReference) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Metadata().OwnerReferences().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderMetadataOwnerReferences) NotIn(values [][]*meta.OwnerReference) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Metadata().OwnerReferences().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderMetadataOwnerReferences) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPhantomTimeSerieFieldPathBuilder().Metadata().OwnerReferences().FieldPath(),
	})
}

func (b *filterCndBuilderMetadataOwnerReferences) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPhantomTimeSerieFieldPathBuilder().Metadata().OwnerReferences().FieldPath(),
	})
}

func (b *filterCndBuilderMetadataOwnerReferences) Contains(value *meta.OwnerReference) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewPhantomTimeSerieFieldPathBuilder().Metadata().OwnerReferences().FieldPath(),
		Value:     NewPhantomTimeSerieFieldPathBuilder().Metadata().OwnerReferences().WithItemValue(value),
	})
}

func (b *filterCndBuilderMetadataOwnerReferences) ContainsAnyOf(values []*meta.OwnerReference) *FilterBuilder {
	pathSelector := NewPhantomTimeSerieFieldPathBuilder().Metadata().OwnerReferences()
	itemValues := make([]PhantomTimeSerie_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewPhantomTimeSerieFieldPathBuilder().Metadata().OwnerReferences().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderMetadataOwnerReferences) ContainsAll(values []*meta.OwnerReference) *FilterBuilder {
	pathSelector := NewPhantomTimeSerieFieldPathBuilder().Metadata().OwnerReferences()
	itemValues := make([]PhantomTimeSerie_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewPhantomTimeSerieFieldPathBuilder().Metadata().OwnerReferences().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderMetadataOwnerReferences) compare(op gotenfilter.CompareOperator, value []*meta.OwnerReference) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                        op,
		PhantomTimeSerie_FieldPathValue: NewPhantomTimeSerieFieldPathBuilder().Metadata().OwnerReferences().WithValue(value),
	})
}

func (b *filterCndBuilderMetadataOwnerReferences) Kind() *filterCndBuilderMetadataOwnerReferencesKind {
	return &filterCndBuilderMetadataOwnerReferencesKind{builder: b.builder}
}

func (b *filterCndBuilderMetadataOwnerReferences) Version() *filterCndBuilderMetadataOwnerReferencesVersion {
	return &filterCndBuilderMetadataOwnerReferencesVersion{builder: b.builder}
}

func (b *filterCndBuilderMetadataOwnerReferences) Name() *filterCndBuilderMetadataOwnerReferencesName {
	return &filterCndBuilderMetadataOwnerReferencesName{builder: b.builder}
}

func (b *filterCndBuilderMetadataOwnerReferences) Region() *filterCndBuilderMetadataOwnerReferencesRegion {
	return &filterCndBuilderMetadataOwnerReferencesRegion{builder: b.builder}
}

func (b *filterCndBuilderMetadataOwnerReferences) Controller() *filterCndBuilderMetadataOwnerReferencesController {
	return &filterCndBuilderMetadataOwnerReferencesController{builder: b.builder}
}

func (b *filterCndBuilderMetadataOwnerReferences) RequiresOwnerReference() *filterCndBuilderMetadataOwnerReferencesRequiresOwnerReference {
	return &filterCndBuilderMetadataOwnerReferencesRequiresOwnerReference{builder: b.builder}
}

type filterCndBuilderMetadataOwnerReferencesKind struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderMetadataOwnerReferencesKind) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Metadata().OwnerReferences().Kind().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderMetadataOwnerReferencesKind) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Metadata().OwnerReferences().Kind().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderMetadataOwnerReferencesKind) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPhantomTimeSerieFieldPathBuilder().Metadata().OwnerReferences().Kind().FieldPath(),
	})
}

func (b *filterCndBuilderMetadataOwnerReferencesKind) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPhantomTimeSerieFieldPathBuilder().Metadata().OwnerReferences().Kind().FieldPath(),
	})
}

func (b *filterCndBuilderMetadataOwnerReferencesKind) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                        op,
		PhantomTimeSerie_FieldPathValue: NewPhantomTimeSerieFieldPathBuilder().Metadata().OwnerReferences().Kind().WithValue(value),
	})
}

type filterCndBuilderMetadataOwnerReferencesVersion struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderMetadataOwnerReferencesVersion) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Metadata().OwnerReferences().Version().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderMetadataOwnerReferencesVersion) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Metadata().OwnerReferences().Version().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderMetadataOwnerReferencesVersion) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPhantomTimeSerieFieldPathBuilder().Metadata().OwnerReferences().Version().FieldPath(),
	})
}

func (b *filterCndBuilderMetadataOwnerReferencesVersion) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPhantomTimeSerieFieldPathBuilder().Metadata().OwnerReferences().Version().FieldPath(),
	})
}

func (b *filterCndBuilderMetadataOwnerReferencesVersion) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                        op,
		PhantomTimeSerie_FieldPathValue: NewPhantomTimeSerieFieldPathBuilder().Metadata().OwnerReferences().Version().WithValue(value),
	})
}

type filterCndBuilderMetadataOwnerReferencesName struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderMetadataOwnerReferencesName) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Metadata().OwnerReferences().Name().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderMetadataOwnerReferencesName) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Metadata().OwnerReferences().Name().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderMetadataOwnerReferencesName) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPhantomTimeSerieFieldPathBuilder().Metadata().OwnerReferences().Name().FieldPath(),
	})
}

func (b *filterCndBuilderMetadataOwnerReferencesName) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPhantomTimeSerieFieldPathBuilder().Metadata().OwnerReferences().Name().FieldPath(),
	})
}

func (b *filterCndBuilderMetadataOwnerReferencesName) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                        op,
		PhantomTimeSerie_FieldPathValue: NewPhantomTimeSerieFieldPathBuilder().Metadata().OwnerReferences().Name().WithValue(value),
	})
}

type filterCndBuilderMetadataOwnerReferencesRegion struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderMetadataOwnerReferencesRegion) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Metadata().OwnerReferences().Region().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderMetadataOwnerReferencesRegion) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Metadata().OwnerReferences().Region().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderMetadataOwnerReferencesRegion) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPhantomTimeSerieFieldPathBuilder().Metadata().OwnerReferences().Region().FieldPath(),
	})
}

func (b *filterCndBuilderMetadataOwnerReferencesRegion) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPhantomTimeSerieFieldPathBuilder().Metadata().OwnerReferences().Region().FieldPath(),
	})
}

func (b *filterCndBuilderMetadataOwnerReferencesRegion) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                        op,
		PhantomTimeSerie_FieldPathValue: NewPhantomTimeSerieFieldPathBuilder().Metadata().OwnerReferences().Region().WithValue(value),
	})
}

type filterCndBuilderMetadataOwnerReferencesController struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderMetadataOwnerReferencesController) In(values []bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Metadata().OwnerReferences().Controller().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderMetadataOwnerReferencesController) NotIn(values []bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Metadata().OwnerReferences().Controller().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderMetadataOwnerReferencesController) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPhantomTimeSerieFieldPathBuilder().Metadata().OwnerReferences().Controller().FieldPath(),
	})
}

func (b *filterCndBuilderMetadataOwnerReferencesController) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPhantomTimeSerieFieldPathBuilder().Metadata().OwnerReferences().Controller().FieldPath(),
	})
}

func (b *filterCndBuilderMetadataOwnerReferencesController) compare(op gotenfilter.CompareOperator, value bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                        op,
		PhantomTimeSerie_FieldPathValue: NewPhantomTimeSerieFieldPathBuilder().Metadata().OwnerReferences().Controller().WithValue(value),
	})
}

type filterCndBuilderMetadataOwnerReferencesRequiresOwnerReference struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderMetadataOwnerReferencesRequiresOwnerReference) In(values []bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Metadata().OwnerReferences().RequiresOwnerReference().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderMetadataOwnerReferencesRequiresOwnerReference) NotIn(values []bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Metadata().OwnerReferences().RequiresOwnerReference().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderMetadataOwnerReferencesRequiresOwnerReference) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPhantomTimeSerieFieldPathBuilder().Metadata().OwnerReferences().RequiresOwnerReference().FieldPath(),
	})
}

func (b *filterCndBuilderMetadataOwnerReferencesRequiresOwnerReference) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPhantomTimeSerieFieldPathBuilder().Metadata().OwnerReferences().RequiresOwnerReference().FieldPath(),
	})
}

func (b *filterCndBuilderMetadataOwnerReferencesRequiresOwnerReference) compare(op gotenfilter.CompareOperator, value bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                        op,
		PhantomTimeSerie_FieldPathValue: NewPhantomTimeSerieFieldPathBuilder().Metadata().OwnerReferences().RequiresOwnerReference().WithValue(value),
	})
}

type filterCndBuilderMetadataShards struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderMetadataShards) In(values []map[string]int64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Metadata().Shards().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderMetadataShards) NotIn(values []map[string]int64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Metadata().Shards().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderMetadataShards) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPhantomTimeSerieFieldPathBuilder().Metadata().Shards().FieldPath(),
	})
}

func (b *filterCndBuilderMetadataShards) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPhantomTimeSerieFieldPathBuilder().Metadata().Shards().FieldPath(),
	})
}

func (b *filterCndBuilderMetadataShards) compare(op gotenfilter.CompareOperator, value map[string]int64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                        op,
		PhantomTimeSerie_FieldPathValue: NewPhantomTimeSerieFieldPathBuilder().Metadata().Shards().WithValue(value),
	})
}

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

type mapFilterCndBuilderMetadataShards struct {
	builder *FilterBuilder
	key     string
}

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

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

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

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

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

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

func (b *mapFilterCndBuilderMetadataShards) In(values []int64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Metadata().Shards().WithKey(b.key).WithArrayOfValues(values),
	})
}

func (b *mapFilterCndBuilderMetadataShards) NotIn(values []int64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Metadata().Shards().WithKey(b.key).WithArrayOfValues(values),
	})
}

func (b *mapFilterCndBuilderMetadataShards) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPhantomTimeSerieFieldPathBuilder().Metadata().Shards().WithKey(b.key).FieldPath(),
	})
}

func (b *mapFilterCndBuilderMetadataShards) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPhantomTimeSerieFieldPathBuilder().Metadata().Shards().WithKey(b.key).FieldPath(),
	})
}

func (b *mapFilterCndBuilderMetadataShards) compare(op gotenfilter.CompareOperator, value int64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                        op,
		PhantomTimeSerie_FieldPathValue: NewPhantomTimeSerieFieldPathBuilder().Metadata().Shards().WithKey(b.key).WithValue(value),
	})
}

type filterCndBuilderMetadataSyncing struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderMetadataSyncing) Eq(value *meta.SyncingMeta) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderMetadataSyncing) Neq(value *meta.SyncingMeta) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderMetadataSyncing) Gt(value *meta.SyncingMeta) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderMetadataSyncing) Gte(value *meta.SyncingMeta) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderMetadataSyncing) Lt(value *meta.SyncingMeta) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderMetadataSyncing) Lte(value *meta.SyncingMeta) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderMetadataSyncing) In(values []*meta.SyncingMeta) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Metadata().Syncing().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderMetadataSyncing) NotIn(values []*meta.SyncingMeta) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Metadata().Syncing().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderMetadataSyncing) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPhantomTimeSerieFieldPathBuilder().Metadata().Syncing().FieldPath(),
	})
}

func (b *filterCndBuilderMetadataSyncing) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPhantomTimeSerieFieldPathBuilder().Metadata().Syncing().FieldPath(),
	})
}

func (b *filterCndBuilderMetadataSyncing) compare(op gotenfilter.CompareOperator, value *meta.SyncingMeta) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                        op,
		PhantomTimeSerie_FieldPathValue: NewPhantomTimeSerieFieldPathBuilder().Metadata().Syncing().WithValue(value),
	})
}

func (b *filterCndBuilderMetadataSyncing) OwningRegion() *filterCndBuilderMetadataSyncingOwningRegion {
	return &filterCndBuilderMetadataSyncingOwningRegion{builder: b.builder}
}

func (b *filterCndBuilderMetadataSyncing) Regions() *filterCndBuilderMetadataSyncingRegions {
	return &filterCndBuilderMetadataSyncingRegions{builder: b.builder}
}

type filterCndBuilderMetadataSyncingOwningRegion struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderMetadataSyncingOwningRegion) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Metadata().Syncing().OwningRegion().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderMetadataSyncingOwningRegion) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Metadata().Syncing().OwningRegion().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderMetadataSyncingOwningRegion) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPhantomTimeSerieFieldPathBuilder().Metadata().Syncing().OwningRegion().FieldPath(),
	})
}

func (b *filterCndBuilderMetadataSyncingOwningRegion) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPhantomTimeSerieFieldPathBuilder().Metadata().Syncing().OwningRegion().FieldPath(),
	})
}

func (b *filterCndBuilderMetadataSyncingOwningRegion) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                        op,
		PhantomTimeSerie_FieldPathValue: NewPhantomTimeSerieFieldPathBuilder().Metadata().Syncing().OwningRegion().WithValue(value),
	})
}

type filterCndBuilderMetadataSyncingRegions struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderMetadataSyncingRegions) In(values [][]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Metadata().Syncing().Regions().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderMetadataSyncingRegions) NotIn(values [][]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Metadata().Syncing().Regions().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderMetadataSyncingRegions) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPhantomTimeSerieFieldPathBuilder().Metadata().Syncing().Regions().FieldPath(),
	})
}

func (b *filterCndBuilderMetadataSyncingRegions) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPhantomTimeSerieFieldPathBuilder().Metadata().Syncing().Regions().FieldPath(),
	})
}

func (b *filterCndBuilderMetadataSyncingRegions) Contains(value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewPhantomTimeSerieFieldPathBuilder().Metadata().Syncing().Regions().FieldPath(),
		Value:     NewPhantomTimeSerieFieldPathBuilder().Metadata().Syncing().Regions().WithItemValue(value),
	})
}

func (b *filterCndBuilderMetadataSyncingRegions) ContainsAnyOf(values []string) *FilterBuilder {
	pathSelector := NewPhantomTimeSerieFieldPathBuilder().Metadata().Syncing().Regions()
	itemValues := make([]PhantomTimeSerie_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewPhantomTimeSerieFieldPathBuilder().Metadata().Syncing().Regions().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderMetadataSyncingRegions) ContainsAll(values []string) *FilterBuilder {
	pathSelector := NewPhantomTimeSerieFieldPathBuilder().Metadata().Syncing().Regions()
	itemValues := make([]PhantomTimeSerie_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewPhantomTimeSerieFieldPathBuilder().Metadata().Syncing().Regions().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderMetadataSyncingRegions) compare(op gotenfilter.CompareOperator, value []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                        op,
		PhantomTimeSerie_FieldPathValue: NewPhantomTimeSerieFieldPathBuilder().Metadata().Syncing().Regions().WithValue(value),
	})
}

type filterCndBuilderMetadataLifecycle struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderMetadataLifecycle) Eq(value *meta.Lifecycle) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderMetadataLifecycle) Neq(value *meta.Lifecycle) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderMetadataLifecycle) Gt(value *meta.Lifecycle) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderMetadataLifecycle) Gte(value *meta.Lifecycle) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderMetadataLifecycle) Lt(value *meta.Lifecycle) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderMetadataLifecycle) Lte(value *meta.Lifecycle) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderMetadataLifecycle) In(values []*meta.Lifecycle) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Metadata().Lifecycle().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderMetadataLifecycle) NotIn(values []*meta.Lifecycle) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Metadata().Lifecycle().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderMetadataLifecycle) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPhantomTimeSerieFieldPathBuilder().Metadata().Lifecycle().FieldPath(),
	})
}

func (b *filterCndBuilderMetadataLifecycle) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPhantomTimeSerieFieldPathBuilder().Metadata().Lifecycle().FieldPath(),
	})
}

func (b *filterCndBuilderMetadataLifecycle) compare(op gotenfilter.CompareOperator, value *meta.Lifecycle) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                        op,
		PhantomTimeSerie_FieldPathValue: NewPhantomTimeSerieFieldPathBuilder().Metadata().Lifecycle().WithValue(value),
	})
}

func (b *filterCndBuilderMetadataLifecycle) State() *filterCndBuilderMetadataLifecycleState {
	return &filterCndBuilderMetadataLifecycleState{builder: b.builder}
}

func (b *filterCndBuilderMetadataLifecycle) BlockDeletion() *filterCndBuilderMetadataLifecycleBlockDeletion {
	return &filterCndBuilderMetadataLifecycleBlockDeletion{builder: b.builder}
}

type filterCndBuilderMetadataLifecycleState struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderMetadataLifecycleState) Eq(value meta.Lifecycle_State) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderMetadataLifecycleState) Neq(value meta.Lifecycle_State) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderMetadataLifecycleState) Gt(value meta.Lifecycle_State) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderMetadataLifecycleState) Gte(value meta.Lifecycle_State) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderMetadataLifecycleState) Lt(value meta.Lifecycle_State) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderMetadataLifecycleState) Lte(value meta.Lifecycle_State) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderMetadataLifecycleState) In(values []meta.Lifecycle_State) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Metadata().Lifecycle().State().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderMetadataLifecycleState) NotIn(values []meta.Lifecycle_State) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Metadata().Lifecycle().State().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderMetadataLifecycleState) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPhantomTimeSerieFieldPathBuilder().Metadata().Lifecycle().State().FieldPath(),
	})
}

func (b *filterCndBuilderMetadataLifecycleState) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPhantomTimeSerieFieldPathBuilder().Metadata().Lifecycle().State().FieldPath(),
	})
}

func (b *filterCndBuilderMetadataLifecycleState) compare(op gotenfilter.CompareOperator, value meta.Lifecycle_State) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                        op,
		PhantomTimeSerie_FieldPathValue: NewPhantomTimeSerieFieldPathBuilder().Metadata().Lifecycle().State().WithValue(value),
	})
}

type filterCndBuilderMetadataLifecycleBlockDeletion struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderMetadataLifecycleBlockDeletion) In(values []bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Metadata().Lifecycle().BlockDeletion().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderMetadataLifecycleBlockDeletion) NotIn(values []bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Metadata().Lifecycle().BlockDeletion().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderMetadataLifecycleBlockDeletion) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPhantomTimeSerieFieldPathBuilder().Metadata().Lifecycle().BlockDeletion().FieldPath(),
	})
}

func (b *filterCndBuilderMetadataLifecycleBlockDeletion) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPhantomTimeSerieFieldPathBuilder().Metadata().Lifecycle().BlockDeletion().FieldPath(),
	})
}

func (b *filterCndBuilderMetadataLifecycleBlockDeletion) compare(op gotenfilter.CompareOperator, value bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                        op,
		PhantomTimeSerie_FieldPathValue: NewPhantomTimeSerieFieldPathBuilder().Metadata().Lifecycle().BlockDeletion().WithValue(value),
	})
}

type filterCndBuilderMetadataServices struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderMetadataServices) Eq(value *meta.ServicesInfo) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderMetadataServices) Neq(value *meta.ServicesInfo) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderMetadataServices) Gt(value *meta.ServicesInfo) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderMetadataServices) Gte(value *meta.ServicesInfo) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderMetadataServices) Lt(value *meta.ServicesInfo) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderMetadataServices) Lte(value *meta.ServicesInfo) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderMetadataServices) In(values []*meta.ServicesInfo) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Metadata().Services().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderMetadataServices) NotIn(values []*meta.ServicesInfo) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Metadata().Services().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderMetadataServices) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPhantomTimeSerieFieldPathBuilder().Metadata().Services().FieldPath(),
	})
}

func (b *filterCndBuilderMetadataServices) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPhantomTimeSerieFieldPathBuilder().Metadata().Services().FieldPath(),
	})
}

func (b *filterCndBuilderMetadataServices) compare(op gotenfilter.CompareOperator, value *meta.ServicesInfo) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                        op,
		PhantomTimeSerie_FieldPathValue: NewPhantomTimeSerieFieldPathBuilder().Metadata().Services().WithValue(value),
	})
}

func (b *filterCndBuilderMetadataServices) OwningService() *filterCndBuilderMetadataServicesOwningService {
	return &filterCndBuilderMetadataServicesOwningService{builder: b.builder}
}

func (b *filterCndBuilderMetadataServices) AllowedServices() *filterCndBuilderMetadataServicesAllowedServices {
	return &filterCndBuilderMetadataServicesAllowedServices{builder: b.builder}
}

type filterCndBuilderMetadataServicesOwningService struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderMetadataServicesOwningService) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Metadata().Services().OwningService().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderMetadataServicesOwningService) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Metadata().Services().OwningService().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderMetadataServicesOwningService) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPhantomTimeSerieFieldPathBuilder().Metadata().Services().OwningService().FieldPath(),
	})
}

func (b *filterCndBuilderMetadataServicesOwningService) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPhantomTimeSerieFieldPathBuilder().Metadata().Services().OwningService().FieldPath(),
	})
}

func (b *filterCndBuilderMetadataServicesOwningService) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                        op,
		PhantomTimeSerie_FieldPathValue: NewPhantomTimeSerieFieldPathBuilder().Metadata().Services().OwningService().WithValue(value),
	})
}

type filterCndBuilderMetadataServicesAllowedServices struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderMetadataServicesAllowedServices) In(values [][]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Metadata().Services().AllowedServices().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderMetadataServicesAllowedServices) NotIn(values [][]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Metadata().Services().AllowedServices().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderMetadataServicesAllowedServices) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPhantomTimeSerieFieldPathBuilder().Metadata().Services().AllowedServices().FieldPath(),
	})
}

func (b *filterCndBuilderMetadataServicesAllowedServices) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPhantomTimeSerieFieldPathBuilder().Metadata().Services().AllowedServices().FieldPath(),
	})
}

func (b *filterCndBuilderMetadataServicesAllowedServices) Contains(value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewPhantomTimeSerieFieldPathBuilder().Metadata().Services().AllowedServices().FieldPath(),
		Value:     NewPhantomTimeSerieFieldPathBuilder().Metadata().Services().AllowedServices().WithItemValue(value),
	})
}

func (b *filterCndBuilderMetadataServicesAllowedServices) ContainsAnyOf(values []string) *FilterBuilder {
	pathSelector := NewPhantomTimeSerieFieldPathBuilder().Metadata().Services().AllowedServices()
	itemValues := make([]PhantomTimeSerie_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewPhantomTimeSerieFieldPathBuilder().Metadata().Services().AllowedServices().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderMetadataServicesAllowedServices) ContainsAll(values []string) *FilterBuilder {
	pathSelector := NewPhantomTimeSerieFieldPathBuilder().Metadata().Services().AllowedServices()
	itemValues := make([]PhantomTimeSerie_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewPhantomTimeSerieFieldPathBuilder().Metadata().Services().AllowedServices().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderMetadataServicesAllowedServices) compare(op gotenfilter.CompareOperator, value []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                        op,
		PhantomTimeSerie_FieldPathValue: NewPhantomTimeSerieFieldPathBuilder().Metadata().Services().AllowedServices().WithValue(value),
	})
}

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{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Key().WithArrayOfValues(values),
	})
}

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

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

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

func (b *filterCndBuilderKey) compare(op gotenfilter.CompareOperator, value []byte) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                        op,
		PhantomTimeSerie_FieldPathValue: NewPhantomTimeSerieFieldPathBuilder().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{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Project().WithArrayOfValues(values),
	})
}

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

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

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

func (b *filterCndBuilderProject) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                        op,
		PhantomTimeSerie_FieldPathValue: NewPhantomTimeSerieFieldPathBuilder().Project().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{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Metric().WithArrayOfValues(values),
	})
}

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

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

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

func (b *filterCndBuilderMetric) compare(op gotenfilter.CompareOperator, value *common.Metric) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                        op,
		PhantomTimeSerie_FieldPathValue: NewPhantomTimeSerieFieldPathBuilder().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{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Metric().Type().WithArrayOfValues(values),
	})
}

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

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

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

func (b *filterCndBuilderMetricType) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                        op,
		PhantomTimeSerie_FieldPathValue: NewPhantomTimeSerieFieldPathBuilder().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{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Metric().Labels().WithArrayOfValues(values),
	})
}

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

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

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

func (b *filterCndBuilderMetricLabels) compare(op gotenfilter.CompareOperator, value map[string]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                        op,
		PhantomTimeSerie_FieldPathValue: NewPhantomTimeSerieFieldPathBuilder().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{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Metric().Labels().WithKey(b.key).WithArrayOfValues(values),
	})
}

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

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

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

func (b *mapFilterCndBuilderMetricLabels) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                        op,
		PhantomTimeSerie_FieldPathValue: NewPhantomTimeSerieFieldPathBuilder().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{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Metric().ReducedLabels().WithArrayOfValues(values),
	})
}

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

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

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

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

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

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

func (b *filterCndBuilderMetricReducedLabels) compare(op gotenfilter.CompareOperator, value []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                        op,
		PhantomTimeSerie_FieldPathValue: NewPhantomTimeSerieFieldPathBuilder().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{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Resource().WithArrayOfValues(values),
	})
}

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

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

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

func (b *filterCndBuilderResource) compare(op gotenfilter.CompareOperator, value *common.MonitoredResource) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                        op,
		PhantomTimeSerie_FieldPathValue: NewPhantomTimeSerieFieldPathBuilder().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{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Resource().Type().WithArrayOfValues(values),
	})
}

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

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

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

func (b *filterCndBuilderResourceType) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                        op,
		PhantomTimeSerie_FieldPathValue: NewPhantomTimeSerieFieldPathBuilder().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{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Resource().Labels().WithArrayOfValues(values),
	})
}

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

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

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

func (b *filterCndBuilderResourceLabels) compare(op gotenfilter.CompareOperator, value map[string]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                        op,
		PhantomTimeSerie_FieldPathValue: NewPhantomTimeSerieFieldPathBuilder().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{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Resource().Labels().WithKey(b.key).WithArrayOfValues(values),
	})
}

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

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

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

func (b *mapFilterCndBuilderResourceLabels) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                        op,
		PhantomTimeSerie_FieldPathValue: NewPhantomTimeSerieFieldPathBuilder().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{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Resource().ReducedLabels().WithArrayOfValues(values),
	})
}

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

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

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

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

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

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

func (b *filterCndBuilderResourceReducedLabels) compare(op gotenfilter.CompareOperator, value []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                        op,
		PhantomTimeSerie_FieldPathValue: NewPhantomTimeSerieFieldPathBuilder().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{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().MetricKind().WithArrayOfValues(values),
	})
}

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

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

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

func (b *filterCndBuilderMetricKind) compare(op gotenfilter.CompareOperator, value metric_descriptor.MetricDescriptor_MetricKind) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                        op,
		PhantomTimeSerie_FieldPathValue: NewPhantomTimeSerieFieldPathBuilder().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{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().ValueType().WithArrayOfValues(values),
	})
}

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

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

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

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

type filterCndBuilderValue struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderValue) In(values []*common.TypedValue) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Value().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderValue) NotIn(values []*common.TypedValue) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Value().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderValue) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPhantomTimeSerieFieldPathBuilder().Value().FieldPath(),
	})
}

func (b *filterCndBuilderValue) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPhantomTimeSerieFieldPathBuilder().Value().FieldPath(),
	})
}

func (b *filterCndBuilderValue) compare(op gotenfilter.CompareOperator, value *common.TypedValue) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                        op,
		PhantomTimeSerie_FieldPathValue: NewPhantomTimeSerieFieldPathBuilder().Value().WithValue(value),
	})
}

func (b *filterCndBuilderValue) BoolValue() *filterCndBuilderValueBoolValue {
	return &filterCndBuilderValueBoolValue{builder: b.builder}
}

func (b *filterCndBuilderValue) Int64Value() *filterCndBuilderValueInt64Value {
	return &filterCndBuilderValueInt64Value{builder: b.builder}
}

func (b *filterCndBuilderValue) DoubleValue() *filterCndBuilderValueDoubleValue {
	return &filterCndBuilderValueDoubleValue{builder: b.builder}
}

func (b *filterCndBuilderValue) StringValue() *filterCndBuilderValueStringValue {
	return &filterCndBuilderValueStringValue{builder: b.builder}
}

func (b *filterCndBuilderValue) DistributionValue() *filterCndBuilderValueDistributionValue {
	return &filterCndBuilderValueDistributionValue{builder: b.builder}
}

type filterCndBuilderValueBoolValue struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderValueBoolValue) In(values []bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Value().BoolValue().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderValueBoolValue) NotIn(values []bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Value().BoolValue().WithArrayOfValues(values),
	})
}

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

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

func (b *filterCndBuilderValueBoolValue) compare(op gotenfilter.CompareOperator, value bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                        op,
		PhantomTimeSerie_FieldPathValue: NewPhantomTimeSerieFieldPathBuilder().Value().BoolValue().WithValue(value),
	})
}

type filterCndBuilderValueInt64Value struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderValueInt64Value) In(values []int64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Value().Int64Value().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderValueInt64Value) NotIn(values []int64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Value().Int64Value().WithArrayOfValues(values),
	})
}

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

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

func (b *filterCndBuilderValueInt64Value) compare(op gotenfilter.CompareOperator, value int64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                        op,
		PhantomTimeSerie_FieldPathValue: NewPhantomTimeSerieFieldPathBuilder().Value().Int64Value().WithValue(value),
	})
}

type filterCndBuilderValueDoubleValue struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderValueDoubleValue) In(values []float64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Value().DoubleValue().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderValueDoubleValue) NotIn(values []float64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Value().DoubleValue().WithArrayOfValues(values),
	})
}

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

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

func (b *filterCndBuilderValueDoubleValue) compare(op gotenfilter.CompareOperator, value float64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                        op,
		PhantomTimeSerie_FieldPathValue: NewPhantomTimeSerieFieldPathBuilder().Value().DoubleValue().WithValue(value),
	})
}

type filterCndBuilderValueStringValue struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderValueStringValue) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Value().StringValue().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderValueStringValue) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Value().StringValue().WithArrayOfValues(values),
	})
}

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

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

func (b *filterCndBuilderValueStringValue) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                        op,
		PhantomTimeSerie_FieldPathValue: NewPhantomTimeSerieFieldPathBuilder().Value().StringValue().WithValue(value),
	})
}

type filterCndBuilderValueDistributionValue struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderValueDistributionValue) In(values []*common.Distribution) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Value().DistributionValue().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderValueDistributionValue) NotIn(values []*common.Distribution) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Value().DistributionValue().WithArrayOfValues(values),
	})
}

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

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

func (b *filterCndBuilderValueDistributionValue) compare(op gotenfilter.CompareOperator, value *common.Distribution) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                        op,
		PhantomTimeSerie_FieldPathValue: NewPhantomTimeSerieFieldPathBuilder().Value().DistributionValue().WithValue(value),
	})
}

func (b *filterCndBuilderValueDistributionValue) Count() *filterCndBuilderValueDistributionValueCount {
	return &filterCndBuilderValueDistributionValueCount{builder: b.builder}
}

func (b *filterCndBuilderValueDistributionValue) Mean() *filterCndBuilderValueDistributionValueMean {
	return &filterCndBuilderValueDistributionValueMean{builder: b.builder}
}

func (b *filterCndBuilderValueDistributionValue) SumOfSquaredDeviation() *filterCndBuilderValueDistributionValueSumOfSquaredDeviation {
	return &filterCndBuilderValueDistributionValueSumOfSquaredDeviation{builder: b.builder}
}

func (b *filterCndBuilderValueDistributionValue) Range() *filterCndBuilderValueDistributionValueRange {
	return &filterCndBuilderValueDistributionValueRange{builder: b.builder}
}

func (b *filterCndBuilderValueDistributionValue) BucketOptions() *filterCndBuilderValueDistributionValueBucketOptions {
	return &filterCndBuilderValueDistributionValueBucketOptions{builder: b.builder}
}

func (b *filterCndBuilderValueDistributionValue) BucketCounts() *filterCndBuilderValueDistributionValueBucketCounts {
	return &filterCndBuilderValueDistributionValueBucketCounts{builder: b.builder}
}

type filterCndBuilderValueDistributionValueCount struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderValueDistributionValueCount) In(values []int64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Value().DistributionValue().Count().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderValueDistributionValueCount) NotIn(values []int64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Value().DistributionValue().Count().WithArrayOfValues(values),
	})
}

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

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

func (b *filterCndBuilderValueDistributionValueCount) compare(op gotenfilter.CompareOperator, value int64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                        op,
		PhantomTimeSerie_FieldPathValue: NewPhantomTimeSerieFieldPathBuilder().Value().DistributionValue().Count().WithValue(value),
	})
}

type filterCndBuilderValueDistributionValueMean struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderValueDistributionValueMean) In(values []float64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Value().DistributionValue().Mean().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderValueDistributionValueMean) NotIn(values []float64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Value().DistributionValue().Mean().WithArrayOfValues(values),
	})
}

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

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

func (b *filterCndBuilderValueDistributionValueMean) compare(op gotenfilter.CompareOperator, value float64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                        op,
		PhantomTimeSerie_FieldPathValue: NewPhantomTimeSerieFieldPathBuilder().Value().DistributionValue().Mean().WithValue(value),
	})
}

type filterCndBuilderValueDistributionValueSumOfSquaredDeviation struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderValueDistributionValueSumOfSquaredDeviation) In(values []float64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Value().DistributionValue().SumOfSquaredDeviation().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderValueDistributionValueSumOfSquaredDeviation) NotIn(values []float64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Value().DistributionValue().SumOfSquaredDeviation().WithArrayOfValues(values),
	})
}

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

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

func (b *filterCndBuilderValueDistributionValueSumOfSquaredDeviation) compare(op gotenfilter.CompareOperator, value float64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                        op,
		PhantomTimeSerie_FieldPathValue: NewPhantomTimeSerieFieldPathBuilder().Value().DistributionValue().SumOfSquaredDeviation().WithValue(value),
	})
}

type filterCndBuilderValueDistributionValueRange struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderValueDistributionValueRange) In(values []*common.Distribution_Range) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Value().DistributionValue().Range().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderValueDistributionValueRange) NotIn(values []*common.Distribution_Range) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Value().DistributionValue().Range().WithArrayOfValues(values),
	})
}

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

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

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

func (b *filterCndBuilderValueDistributionValueRange) Min() *filterCndBuilderValueDistributionValueRangeMin {
	return &filterCndBuilderValueDistributionValueRangeMin{builder: b.builder}
}

func (b *filterCndBuilderValueDistributionValueRange) Max() *filterCndBuilderValueDistributionValueRangeMax {
	return &filterCndBuilderValueDistributionValueRangeMax{builder: b.builder}
}

type filterCndBuilderValueDistributionValueRangeMin struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderValueDistributionValueRangeMin) In(values []float64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Value().DistributionValue().Range().Min().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderValueDistributionValueRangeMin) NotIn(values []float64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Value().DistributionValue().Range().Min().WithArrayOfValues(values),
	})
}

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

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

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

type filterCndBuilderValueDistributionValueRangeMax struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderValueDistributionValueRangeMax) In(values []float64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Value().DistributionValue().Range().Max().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderValueDistributionValueRangeMax) NotIn(values []float64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Value().DistributionValue().Range().Max().WithArrayOfValues(values),
	})
}

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

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

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

type filterCndBuilderValueDistributionValueBucketOptions struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderValueDistributionValueBucketOptions) In(values []*common.Distribution_BucketOptions) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Value().DistributionValue().BucketOptions().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderValueDistributionValueBucketOptions) NotIn(values []*common.Distribution_BucketOptions) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Value().DistributionValue().BucketOptions().WithArrayOfValues(values),
	})
}

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

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

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

func (b *filterCndBuilderValueDistributionValueBucketOptions) LinearBuckets() *filterCndBuilderValueDistributionValueBucketOptionsLinearBuckets {
	return &filterCndBuilderValueDistributionValueBucketOptionsLinearBuckets{builder: b.builder}
}

func (b *filterCndBuilderValueDistributionValueBucketOptions) ExponentialBuckets() *filterCndBuilderValueDistributionValueBucketOptionsExponentialBuckets {
	return &filterCndBuilderValueDistributionValueBucketOptionsExponentialBuckets{builder: b.builder}
}

func (b *filterCndBuilderValueDistributionValueBucketOptions) ExplicitBuckets() *filterCndBuilderValueDistributionValueBucketOptionsExplicitBuckets {
	return &filterCndBuilderValueDistributionValueBucketOptionsExplicitBuckets{builder: b.builder}
}

func (b *filterCndBuilderValueDistributionValueBucketOptions) DynamicBuckets() *filterCndBuilderValueDistributionValueBucketOptionsDynamicBuckets {
	return &filterCndBuilderValueDistributionValueBucketOptionsDynamicBuckets{builder: b.builder}
}

type filterCndBuilderValueDistributionValueBucketOptionsLinearBuckets struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderValueDistributionValueBucketOptionsLinearBuckets) In(values []*common.Distribution_BucketOptions_Linear) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Value().DistributionValue().BucketOptions().LinearBuckets().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderValueDistributionValueBucketOptionsLinearBuckets) NotIn(values []*common.Distribution_BucketOptions_Linear) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Value().DistributionValue().BucketOptions().LinearBuckets().WithArrayOfValues(values),
	})
}

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

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

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

func (b *filterCndBuilderValueDistributionValueBucketOptionsLinearBuckets) NumFiniteBuckets() *filterCndBuilderValueDistributionValueBucketOptionsLinearBucketsNumFiniteBuckets {
	return &filterCndBuilderValueDistributionValueBucketOptionsLinearBucketsNumFiniteBuckets{builder: b.builder}
}

func (b *filterCndBuilderValueDistributionValueBucketOptionsLinearBuckets) Width() *filterCndBuilderValueDistributionValueBucketOptionsLinearBucketsWidth {
	return &filterCndBuilderValueDistributionValueBucketOptionsLinearBucketsWidth{builder: b.builder}
}

func (b *filterCndBuilderValueDistributionValueBucketOptionsLinearBuckets) Offset() *filterCndBuilderValueDistributionValueBucketOptionsLinearBucketsOffset {
	return &filterCndBuilderValueDistributionValueBucketOptionsLinearBucketsOffset{builder: b.builder}
}

type filterCndBuilderValueDistributionValueBucketOptionsLinearBucketsNumFiniteBuckets struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderValueDistributionValueBucketOptionsLinearBucketsNumFiniteBuckets) In(values []int32) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Value().DistributionValue().BucketOptions().LinearBuckets().NumFiniteBuckets().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderValueDistributionValueBucketOptionsLinearBucketsNumFiniteBuckets) NotIn(values []int32) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Value().DistributionValue().BucketOptions().LinearBuckets().NumFiniteBuckets().WithArrayOfValues(values),
	})
}

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

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

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

type filterCndBuilderValueDistributionValueBucketOptionsLinearBucketsWidth struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderValueDistributionValueBucketOptionsLinearBucketsWidth) In(values []float64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Value().DistributionValue().BucketOptions().LinearBuckets().Width().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderValueDistributionValueBucketOptionsLinearBucketsWidth) NotIn(values []float64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Value().DistributionValue().BucketOptions().LinearBuckets().Width().WithArrayOfValues(values),
	})
}

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

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

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

type filterCndBuilderValueDistributionValueBucketOptionsLinearBucketsOffset struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderValueDistributionValueBucketOptionsLinearBucketsOffset) In(values []float64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Value().DistributionValue().BucketOptions().LinearBuckets().Offset().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderValueDistributionValueBucketOptionsLinearBucketsOffset) NotIn(values []float64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Value().DistributionValue().BucketOptions().LinearBuckets().Offset().WithArrayOfValues(values),
	})
}

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

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

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

type filterCndBuilderValueDistributionValueBucketOptionsExponentialBuckets struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderValueDistributionValueBucketOptionsExponentialBuckets) In(values []*common.Distribution_BucketOptions_Exponential) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Value().DistributionValue().BucketOptions().ExponentialBuckets().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderValueDistributionValueBucketOptionsExponentialBuckets) NotIn(values []*common.Distribution_BucketOptions_Exponential) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Value().DistributionValue().BucketOptions().ExponentialBuckets().WithArrayOfValues(values),
	})
}

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

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

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

func (b *filterCndBuilderValueDistributionValueBucketOptionsExponentialBuckets) NumFiniteBuckets() *filterCndBuilderValueDistributionValueBucketOptionsExponentialBucketsNumFiniteBuckets {
	return &filterCndBuilderValueDistributionValueBucketOptionsExponentialBucketsNumFiniteBuckets{builder: b.builder}
}

func (b *filterCndBuilderValueDistributionValueBucketOptionsExponentialBuckets) GrowthFactor() *filterCndBuilderValueDistributionValueBucketOptionsExponentialBucketsGrowthFactor {
	return &filterCndBuilderValueDistributionValueBucketOptionsExponentialBucketsGrowthFactor{builder: b.builder}
}

func (b *filterCndBuilderValueDistributionValueBucketOptionsExponentialBuckets) Scale() *filterCndBuilderValueDistributionValueBucketOptionsExponentialBucketsScale {
	return &filterCndBuilderValueDistributionValueBucketOptionsExponentialBucketsScale{builder: b.builder}
}

type filterCndBuilderValueDistributionValueBucketOptionsExponentialBucketsNumFiniteBuckets struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderValueDistributionValueBucketOptionsExponentialBucketsNumFiniteBuckets) In(values []int32) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Value().DistributionValue().BucketOptions().ExponentialBuckets().NumFiniteBuckets().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderValueDistributionValueBucketOptionsExponentialBucketsNumFiniteBuckets) NotIn(values []int32) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Value().DistributionValue().BucketOptions().ExponentialBuckets().NumFiniteBuckets().WithArrayOfValues(values),
	})
}

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

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

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

type filterCndBuilderValueDistributionValueBucketOptionsExponentialBucketsGrowthFactor struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderValueDistributionValueBucketOptionsExponentialBucketsGrowthFactor) In(values []float64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Value().DistributionValue().BucketOptions().ExponentialBuckets().GrowthFactor().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderValueDistributionValueBucketOptionsExponentialBucketsGrowthFactor) NotIn(values []float64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Value().DistributionValue().BucketOptions().ExponentialBuckets().GrowthFactor().WithArrayOfValues(values),
	})
}

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

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

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

type filterCndBuilderValueDistributionValueBucketOptionsExponentialBucketsScale struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderValueDistributionValueBucketOptionsExponentialBucketsScale) In(values []float64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Value().DistributionValue().BucketOptions().ExponentialBuckets().Scale().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderValueDistributionValueBucketOptionsExponentialBucketsScale) NotIn(values []float64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Value().DistributionValue().BucketOptions().ExponentialBuckets().Scale().WithArrayOfValues(values),
	})
}

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

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

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

type filterCndBuilderValueDistributionValueBucketOptionsExplicitBuckets struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderValueDistributionValueBucketOptionsExplicitBuckets) In(values []*common.Distribution_BucketOptions_Explicit) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Value().DistributionValue().BucketOptions().ExplicitBuckets().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderValueDistributionValueBucketOptionsExplicitBuckets) NotIn(values []*common.Distribution_BucketOptions_Explicit) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Value().DistributionValue().BucketOptions().ExplicitBuckets().WithArrayOfValues(values),
	})
}

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

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

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

func (b *filterCndBuilderValueDistributionValueBucketOptionsExplicitBuckets) Bounds() *filterCndBuilderValueDistributionValueBucketOptionsExplicitBucketsBounds {
	return &filterCndBuilderValueDistributionValueBucketOptionsExplicitBucketsBounds{builder: b.builder}
}

type filterCndBuilderValueDistributionValueBucketOptionsExplicitBucketsBounds struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderValueDistributionValueBucketOptionsExplicitBucketsBounds) In(values [][]float64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Value().DistributionValue().BucketOptions().ExplicitBuckets().Bounds().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderValueDistributionValueBucketOptionsExplicitBucketsBounds) NotIn(values [][]float64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Value().DistributionValue().BucketOptions().ExplicitBuckets().Bounds().WithArrayOfValues(values),
	})
}

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

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

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

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

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

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

type filterCndBuilderValueDistributionValueBucketOptionsDynamicBuckets struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderValueDistributionValueBucketOptionsDynamicBuckets) In(values []*common.Distribution_BucketOptions_Dynamic) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Value().DistributionValue().BucketOptions().DynamicBuckets().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderValueDistributionValueBucketOptionsDynamicBuckets) NotIn(values []*common.Distribution_BucketOptions_Dynamic) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Value().DistributionValue().BucketOptions().DynamicBuckets().WithArrayOfValues(values),
	})
}

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

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

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

func (b *filterCndBuilderValueDistributionValueBucketOptionsDynamicBuckets) Compression() *filterCndBuilderValueDistributionValueBucketOptionsDynamicBucketsCompression {
	return &filterCndBuilderValueDistributionValueBucketOptionsDynamicBucketsCompression{builder: b.builder}
}

func (b *filterCndBuilderValueDistributionValueBucketOptionsDynamicBuckets) Means() *filterCndBuilderValueDistributionValueBucketOptionsDynamicBucketsMeans {
	return &filterCndBuilderValueDistributionValueBucketOptionsDynamicBucketsMeans{builder: b.builder}
}

type filterCndBuilderValueDistributionValueBucketOptionsDynamicBucketsCompression struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderValueDistributionValueBucketOptionsDynamicBucketsCompression) In(values []float64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Value().DistributionValue().BucketOptions().DynamicBuckets().Compression().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderValueDistributionValueBucketOptionsDynamicBucketsCompression) NotIn(values []float64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Value().DistributionValue().BucketOptions().DynamicBuckets().Compression().WithArrayOfValues(values),
	})
}

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

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

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

type filterCndBuilderValueDistributionValueBucketOptionsDynamicBucketsMeans struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderValueDistributionValueBucketOptionsDynamicBucketsMeans) In(values [][]float64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Value().DistributionValue().BucketOptions().DynamicBuckets().Means().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderValueDistributionValueBucketOptionsDynamicBucketsMeans) NotIn(values [][]float64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Value().DistributionValue().BucketOptions().DynamicBuckets().Means().WithArrayOfValues(values),
	})
}

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

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

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

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

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

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

type filterCndBuilderValueDistributionValueBucketCounts struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderValueDistributionValueBucketCounts) In(values [][]int64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Value().DistributionValue().BucketCounts().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderValueDistributionValueBucketCounts) NotIn(values [][]int64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		PhantomTimeSerie_FieldPathArrayOfValues: NewPhantomTimeSerieFieldPathBuilder().Value().DistributionValue().BucketCounts().WithArrayOfValues(values),
	})
}

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

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

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

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

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

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