github.com/cloudwan/edgelq-sdk@v1.15.4/alerting/resources/v1/alert/alert.pb.filterbuilder.go

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

package alert

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

// proto imports
import (
	rcommon "github.com/cloudwan/edgelq-sdk/alerting/resources/v1/common"
	document "github.com/cloudwan/edgelq-sdk/alerting/resources/v1/document"
	log_condition "github.com/cloudwan/edgelq-sdk/alerting/resources/v1/log_condition"
	log_condition_template "github.com/cloudwan/edgelq-sdk/alerting/resources/v1/log_condition_template"
	notification_channel "github.com/cloudwan/edgelq-sdk/alerting/resources/v1/notification_channel"
	policy "github.com/cloudwan/edgelq-sdk/alerting/resources/v1/policy"
	policy_template "github.com/cloudwan/edgelq-sdk/alerting/resources/v1/policy_template"
	ts_condition "github.com/cloudwan/edgelq-sdk/alerting/resources/v1/ts_condition"
	api "github.com/cloudwan/edgelq-sdk/common/api"
	iam_iam_common "github.com/cloudwan/edgelq-sdk/iam/resources/v1/common"
	iam_organization "github.com/cloudwan/edgelq-sdk/iam/resources/v1/organization"
	iam_project "github.com/cloudwan/edgelq-sdk/iam/resources/v1/project"
	logging_bucket "github.com/cloudwan/edgelq-sdk/logging/resources/v1/bucket"
	logging_common "github.com/cloudwan/edgelq-sdk/logging/resources/v1/common"
	logging_log "github.com/cloudwan/edgelq-sdk/logging/resources/v1/log"
	logging_log_descriptor "github.com/cloudwan/edgelq-sdk/logging/resources/v1/log_descriptor"
	monitoring_common "github.com/cloudwan/edgelq-sdk/monitoring/resources/v4/common"
	monitoring_metric_descriptor "github.com/cloudwan/edgelq-sdk/monitoring/resources/v4/metric_descriptor"
	monitoring_monitored_resource_descriptor "github.com/cloudwan/edgelq-sdk/monitoring/resources/v4/monitored_resource_descriptor"
	monitoring_project "github.com/cloudwan/edgelq-sdk/monitoring/resources/v4/project"
	monitoring_time_serie "github.com/cloudwan/edgelq-sdk/monitoring/resources/v4/time_serie"
	meta_common "github.com/cloudwan/goten-sdk/meta-service/resources/v1/common"
	meta_resource "github.com/cloudwan/goten-sdk/meta-service/resources/v1/resource"
	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"
	anypb "google.golang.org/protobuf/types/known/anypb"
	durationpb "google.golang.org/protobuf/types/known/durationpb"
	fieldmaskpb "google.golang.org/protobuf/types/known/fieldmaskpb"
	structpb "google.golang.org/protobuf/types/known/structpb"
	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 (
	_ = &document.Document{}
	_ = &log_condition.LogCondition{}
	_ = &log_condition_template.LogConditionTemplate{}
	_ = &notification_channel.NotificationChannel{}
	_ = &policy.Policy{}
	_ = &policy_template.PolicyTemplate{}
	_ = &rcommon.LogCndSpec{}
	_ = &ts_condition.TsCondition{}
	_ = api.LaunchStage(0)
	_ = &iam_iam_common.PCR{}
	_ = &iam_organization.Organization{}
	_ = &iam_project.Project{}
	_ = &logging_bucket.Bucket{}
	_ = &logging_common.LabelDescriptor{}
	_ = &logging_log.Log{}
	_ = &logging_log_descriptor.LogDescriptor{}
	_ = &monitoring_common.LabelDescriptor{}
	_ = &monitoring_metric_descriptor.MetricDescriptor{}
	_ = &monitoring_monitored_resource_descriptor.MonitoredResourceDescriptor{}
	_ = &monitoring_project.Project{}
	_ = &monitoring_time_serie.Point{}
	_ = &anypb.Any{}
	_ = &durationpb.Duration{}
	_ = &fieldmaskpb.FieldMask{}
	_ = &structpb.Struct{}
	_ = &timestamppb.Timestamp{}
	_ = &meta_common.LabelledDomain{}
	_ = &meta_resource.Resource{}
	_ = &meta_service.Service{}
	_ = &meta.Meta{}
	_ = &multi_region_policy.MultiRegionPolicy{}
)

type FilterBuilderOrCondition interface {
	_IsAlertFilterBuilderOrCondition()
}

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

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

func (b *filterCndBuilderAnyPath) NotIn(values interface{}) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Alert_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([]Alert_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([]Alert_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,
		Alert_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) DisplayName() *filterCndBuilderDisplayName {
	return &filterCndBuilderDisplayName{builder: b.builder}
}

func (b *filterCndBuilder) AlertingResource() *filterCndBuilderAlertingResource {
	return &filterCndBuilderAlertingResource{builder: b.builder}
}

func (b *filterCndBuilder) TsInfo() *filterCndBuilderTsInfo {
	return &filterCndBuilderTsInfo{builder: b.builder}
}

func (b *filterCndBuilder) LogInfo() *filterCndBuilderLogInfo {
	return &filterCndBuilderLogInfo{builder: b.builder}
}

func (b *filterCndBuilder) State() *filterCndBuilderState {
	return &filterCndBuilderState{builder: b.builder}
}

func (b *filterCndBuilder) Internal() *filterCndBuilderInternal {
	return &filterCndBuilderInternal{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{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().Name().WithArrayOfValues(values),
	})
}

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

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

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

func (b *filterCndBuilderName) compare(op gotenfilter.CompareOperator, value *Name) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:             op,
		Alert_FieldPathValue: NewAlertFieldPathBuilder().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{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().Metadata().WithArrayOfValues(values),
	})
}

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

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

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

func (b *filterCndBuilderMetadata) compare(op gotenfilter.CompareOperator, value *meta.Meta) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:             op,
		Alert_FieldPathValue: NewAlertFieldPathBuilder().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{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().Metadata().CreateTime().WithArrayOfValues(values),
	})
}

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

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

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

func (b *filterCndBuilderMetadataCreateTime) compare(op gotenfilter.CompareOperator, value *timestamppb.Timestamp) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:             op,
		Alert_FieldPathValue: NewAlertFieldPathBuilder().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{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().Metadata().UpdateTime().WithArrayOfValues(values),
	})
}

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

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

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

func (b *filterCndBuilderMetadataUpdateTime) compare(op gotenfilter.CompareOperator, value *timestamppb.Timestamp) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:             op,
		Alert_FieldPathValue: NewAlertFieldPathBuilder().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{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().Metadata().DeleteTime().WithArrayOfValues(values),
	})
}

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

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

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

func (b *filterCndBuilderMetadataDeleteTime) compare(op gotenfilter.CompareOperator, value *timestamppb.Timestamp) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:             op,
		Alert_FieldPathValue: NewAlertFieldPathBuilder().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{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().Metadata().Uuid().WithArrayOfValues(values),
	})
}

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

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

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

func (b *filterCndBuilderMetadataUuid) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:             op,
		Alert_FieldPathValue: NewAlertFieldPathBuilder().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{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().Metadata().Tags().WithArrayOfValues(values),
	})
}

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

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

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

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

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

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

func (b *filterCndBuilderMetadataTags) compare(op gotenfilter.CompareOperator, value []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:             op,
		Alert_FieldPathValue: NewAlertFieldPathBuilder().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{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().Metadata().Labels().WithArrayOfValues(values),
	})
}

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

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

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

func (b *filterCndBuilderMetadataLabels) compare(op gotenfilter.CompareOperator, value map[string]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:             op,
		Alert_FieldPathValue: NewAlertFieldPathBuilder().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{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().Metadata().Labels().WithKey(b.key).WithArrayOfValues(values),
	})
}

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

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

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

func (b *mapFilterCndBuilderMetadataLabels) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:             op,
		Alert_FieldPathValue: NewAlertFieldPathBuilder().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{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().Metadata().Annotations().WithArrayOfValues(values),
	})
}

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

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

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

func (b *filterCndBuilderMetadataAnnotations) compare(op gotenfilter.CompareOperator, value map[string]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:             op,
		Alert_FieldPathValue: NewAlertFieldPathBuilder().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{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().Metadata().Annotations().WithKey(b.key).WithArrayOfValues(values),
	})
}

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

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

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

func (b *mapFilterCndBuilderMetadataAnnotations) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:             op,
		Alert_FieldPathValue: NewAlertFieldPathBuilder().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{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().Metadata().Generation().WithArrayOfValues(values),
	})
}

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

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

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

func (b *filterCndBuilderMetadataGeneration) compare(op gotenfilter.CompareOperator, value int64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:             op,
		Alert_FieldPathValue: NewAlertFieldPathBuilder().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{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().Metadata().ResourceVersion().WithArrayOfValues(values),
	})
}

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

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

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

func (b *filterCndBuilderMetadataResourceVersion) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:             op,
		Alert_FieldPathValue: NewAlertFieldPathBuilder().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{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().Metadata().OwnerReferences().WithArrayOfValues(values),
	})
}

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

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

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

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

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

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

func (b *filterCndBuilderMetadataOwnerReferences) compare(op gotenfilter.CompareOperator, value []*meta.OwnerReference) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:             op,
		Alert_FieldPathValue: NewAlertFieldPathBuilder().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}
}

func (b *filterCndBuilderMetadataOwnerReferences) UnsetOnDelete() *filterCndBuilderMetadataOwnerReferencesUnsetOnDelete {
	return &filterCndBuilderMetadataOwnerReferencesUnsetOnDelete{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{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().Metadata().OwnerReferences().Kind().WithArrayOfValues(values),
	})
}

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

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

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

func (b *filterCndBuilderMetadataOwnerReferencesKind) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:             op,
		Alert_FieldPathValue: NewAlertFieldPathBuilder().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{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().Metadata().OwnerReferences().Version().WithArrayOfValues(values),
	})
}

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

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

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

func (b *filterCndBuilderMetadataOwnerReferencesVersion) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:             op,
		Alert_FieldPathValue: NewAlertFieldPathBuilder().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{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().Metadata().OwnerReferences().Name().WithArrayOfValues(values),
	})
}

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

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

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

func (b *filterCndBuilderMetadataOwnerReferencesName) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:             op,
		Alert_FieldPathValue: NewAlertFieldPathBuilder().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{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().Metadata().OwnerReferences().Region().WithArrayOfValues(values),
	})
}

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

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

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

func (b *filterCndBuilderMetadataOwnerReferencesRegion) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:             op,
		Alert_FieldPathValue: NewAlertFieldPathBuilder().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{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().Metadata().OwnerReferences().Controller().WithArrayOfValues(values),
	})
}

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

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

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

func (b *filterCndBuilderMetadataOwnerReferencesController) compare(op gotenfilter.CompareOperator, value bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:             op,
		Alert_FieldPathValue: NewAlertFieldPathBuilder().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{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().Metadata().OwnerReferences().RequiresOwnerReference().WithArrayOfValues(values),
	})
}

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

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

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

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

type filterCndBuilderMetadataOwnerReferencesUnsetOnDelete struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderMetadataOwnerReferencesUnsetOnDelete) In(values []bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().Metadata().OwnerReferences().UnsetOnDelete().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderMetadataOwnerReferencesUnsetOnDelete) NotIn(values []bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().Metadata().OwnerReferences().UnsetOnDelete().WithArrayOfValues(values),
	})
}

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

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

func (b *filterCndBuilderMetadataOwnerReferencesUnsetOnDelete) compare(op gotenfilter.CompareOperator, value bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:             op,
		Alert_FieldPathValue: NewAlertFieldPathBuilder().Metadata().OwnerReferences().UnsetOnDelete().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{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().Metadata().Shards().WithArrayOfValues(values),
	})
}

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

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

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

func (b *filterCndBuilderMetadataShards) compare(op gotenfilter.CompareOperator, value map[string]int64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:             op,
		Alert_FieldPathValue: NewAlertFieldPathBuilder().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{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().Metadata().Shards().WithKey(b.key).WithArrayOfValues(values),
	})
}

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

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

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

func (b *mapFilterCndBuilderMetadataShards) compare(op gotenfilter.CompareOperator, value int64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:             op,
		Alert_FieldPathValue: NewAlertFieldPathBuilder().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{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().Metadata().Syncing().WithArrayOfValues(values),
	})
}

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

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

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

func (b *filterCndBuilderMetadataSyncing) compare(op gotenfilter.CompareOperator, value *meta.SyncingMeta) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:             op,
		Alert_FieldPathValue: NewAlertFieldPathBuilder().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{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().Metadata().Syncing().OwningRegion().WithArrayOfValues(values),
	})
}

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

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

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

func (b *filterCndBuilderMetadataSyncingOwningRegion) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:             op,
		Alert_FieldPathValue: NewAlertFieldPathBuilder().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{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().Metadata().Syncing().Regions().WithArrayOfValues(values),
	})
}

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

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

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

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

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

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

func (b *filterCndBuilderMetadataSyncingRegions) compare(op gotenfilter.CompareOperator, value []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:             op,
		Alert_FieldPathValue: NewAlertFieldPathBuilder().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{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().Metadata().Lifecycle().WithArrayOfValues(values),
	})
}

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

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

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

func (b *filterCndBuilderMetadataLifecycle) compare(op gotenfilter.CompareOperator, value *meta.Lifecycle) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:             op,
		Alert_FieldPathValue: NewAlertFieldPathBuilder().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{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().Metadata().Lifecycle().State().WithArrayOfValues(values),
	})
}

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

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

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

func (b *filterCndBuilderMetadataLifecycleState) compare(op gotenfilter.CompareOperator, value meta.Lifecycle_State) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:             op,
		Alert_FieldPathValue: NewAlertFieldPathBuilder().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{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().Metadata().Lifecycle().BlockDeletion().WithArrayOfValues(values),
	})
}

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

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

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

func (b *filterCndBuilderMetadataLifecycleBlockDeletion) compare(op gotenfilter.CompareOperator, value bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:             op,
		Alert_FieldPathValue: NewAlertFieldPathBuilder().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{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().Metadata().Services().WithArrayOfValues(values),
	})
}

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

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

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

func (b *filterCndBuilderMetadataServices) compare(op gotenfilter.CompareOperator, value *meta.ServicesInfo) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:             op,
		Alert_FieldPathValue: NewAlertFieldPathBuilder().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{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().Metadata().Services().OwningService().WithArrayOfValues(values),
	})
}

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

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

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

func (b *filterCndBuilderMetadataServicesOwningService) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:             op,
		Alert_FieldPathValue: NewAlertFieldPathBuilder().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{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().Metadata().Services().AllowedServices().WithArrayOfValues(values),
	})
}

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

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

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

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

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

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

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

type filterCndBuilderDisplayName struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderDisplayName) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().DisplayName().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderDisplayName) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().DisplayName().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderDisplayName) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewAlertFieldPathBuilder().DisplayName().FieldPath(),
	})
}

func (b *filterCndBuilderDisplayName) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewAlertFieldPathBuilder().DisplayName().FieldPath(),
	})
}

func (b *filterCndBuilderDisplayName) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:             op,
		Alert_FieldPathValue: NewAlertFieldPathBuilder().DisplayName().WithValue(value),
	})
}

type filterCndBuilderAlertingResource struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderAlertingResource) In(values []*meta.OwnerReference) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().AlertingResource().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderAlertingResource) NotIn(values []*meta.OwnerReference) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().AlertingResource().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderAlertingResource) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewAlertFieldPathBuilder().AlertingResource().FieldPath(),
	})
}

func (b *filterCndBuilderAlertingResource) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewAlertFieldPathBuilder().AlertingResource().FieldPath(),
	})
}

func (b *filterCndBuilderAlertingResource) compare(op gotenfilter.CompareOperator, value *meta.OwnerReference) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:             op,
		Alert_FieldPathValue: NewAlertFieldPathBuilder().AlertingResource().WithValue(value),
	})
}

func (b *filterCndBuilderAlertingResource) Kind() *filterCndBuilderAlertingResourceKind {
	return &filterCndBuilderAlertingResourceKind{builder: b.builder}
}

func (b *filterCndBuilderAlertingResource) Version() *filterCndBuilderAlertingResourceVersion {
	return &filterCndBuilderAlertingResourceVersion{builder: b.builder}
}

func (b *filterCndBuilderAlertingResource) Name() *filterCndBuilderAlertingResourceName {
	return &filterCndBuilderAlertingResourceName{builder: b.builder}
}

func (b *filterCndBuilderAlertingResource) Region() *filterCndBuilderAlertingResourceRegion {
	return &filterCndBuilderAlertingResourceRegion{builder: b.builder}
}

func (b *filterCndBuilderAlertingResource) Controller() *filterCndBuilderAlertingResourceController {
	return &filterCndBuilderAlertingResourceController{builder: b.builder}
}

func (b *filterCndBuilderAlertingResource) RequiresOwnerReference() *filterCndBuilderAlertingResourceRequiresOwnerReference {
	return &filterCndBuilderAlertingResourceRequiresOwnerReference{builder: b.builder}
}

func (b *filterCndBuilderAlertingResource) UnsetOnDelete() *filterCndBuilderAlertingResourceUnsetOnDelete {
	return &filterCndBuilderAlertingResourceUnsetOnDelete{builder: b.builder}
}

type filterCndBuilderAlertingResourceKind struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderAlertingResourceKind) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().AlertingResource().Kind().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderAlertingResourceKind) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().AlertingResource().Kind().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderAlertingResourceKind) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewAlertFieldPathBuilder().AlertingResource().Kind().FieldPath(),
	})
}

func (b *filterCndBuilderAlertingResourceKind) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewAlertFieldPathBuilder().AlertingResource().Kind().FieldPath(),
	})
}

func (b *filterCndBuilderAlertingResourceKind) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:             op,
		Alert_FieldPathValue: NewAlertFieldPathBuilder().AlertingResource().Kind().WithValue(value),
	})
}

type filterCndBuilderAlertingResourceVersion struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderAlertingResourceVersion) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().AlertingResource().Version().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderAlertingResourceVersion) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().AlertingResource().Version().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderAlertingResourceVersion) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewAlertFieldPathBuilder().AlertingResource().Version().FieldPath(),
	})
}

func (b *filterCndBuilderAlertingResourceVersion) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewAlertFieldPathBuilder().AlertingResource().Version().FieldPath(),
	})
}

func (b *filterCndBuilderAlertingResourceVersion) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:             op,
		Alert_FieldPathValue: NewAlertFieldPathBuilder().AlertingResource().Version().WithValue(value),
	})
}

type filterCndBuilderAlertingResourceName struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderAlertingResourceName) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().AlertingResource().Name().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderAlertingResourceName) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().AlertingResource().Name().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderAlertingResourceName) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewAlertFieldPathBuilder().AlertingResource().Name().FieldPath(),
	})
}

func (b *filterCndBuilderAlertingResourceName) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewAlertFieldPathBuilder().AlertingResource().Name().FieldPath(),
	})
}

func (b *filterCndBuilderAlertingResourceName) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:             op,
		Alert_FieldPathValue: NewAlertFieldPathBuilder().AlertingResource().Name().WithValue(value),
	})
}

type filterCndBuilderAlertingResourceRegion struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderAlertingResourceRegion) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().AlertingResource().Region().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderAlertingResourceRegion) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().AlertingResource().Region().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderAlertingResourceRegion) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewAlertFieldPathBuilder().AlertingResource().Region().FieldPath(),
	})
}

func (b *filterCndBuilderAlertingResourceRegion) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewAlertFieldPathBuilder().AlertingResource().Region().FieldPath(),
	})
}

func (b *filterCndBuilderAlertingResourceRegion) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:             op,
		Alert_FieldPathValue: NewAlertFieldPathBuilder().AlertingResource().Region().WithValue(value),
	})
}

type filterCndBuilderAlertingResourceController struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderAlertingResourceController) In(values []bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().AlertingResource().Controller().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderAlertingResourceController) NotIn(values []bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().AlertingResource().Controller().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderAlertingResourceController) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewAlertFieldPathBuilder().AlertingResource().Controller().FieldPath(),
	})
}

func (b *filterCndBuilderAlertingResourceController) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewAlertFieldPathBuilder().AlertingResource().Controller().FieldPath(),
	})
}

func (b *filterCndBuilderAlertingResourceController) compare(op gotenfilter.CompareOperator, value bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:             op,
		Alert_FieldPathValue: NewAlertFieldPathBuilder().AlertingResource().Controller().WithValue(value),
	})
}

type filterCndBuilderAlertingResourceRequiresOwnerReference struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderAlertingResourceRequiresOwnerReference) In(values []bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().AlertingResource().RequiresOwnerReference().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderAlertingResourceRequiresOwnerReference) NotIn(values []bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().AlertingResource().RequiresOwnerReference().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderAlertingResourceRequiresOwnerReference) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewAlertFieldPathBuilder().AlertingResource().RequiresOwnerReference().FieldPath(),
	})
}

func (b *filterCndBuilderAlertingResourceRequiresOwnerReference) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewAlertFieldPathBuilder().AlertingResource().RequiresOwnerReference().FieldPath(),
	})
}

func (b *filterCndBuilderAlertingResourceRequiresOwnerReference) compare(op gotenfilter.CompareOperator, value bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:             op,
		Alert_FieldPathValue: NewAlertFieldPathBuilder().AlertingResource().RequiresOwnerReference().WithValue(value),
	})
}

type filterCndBuilderAlertingResourceUnsetOnDelete struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderAlertingResourceUnsetOnDelete) In(values []bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().AlertingResource().UnsetOnDelete().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderAlertingResourceUnsetOnDelete) NotIn(values []bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().AlertingResource().UnsetOnDelete().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderAlertingResourceUnsetOnDelete) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewAlertFieldPathBuilder().AlertingResource().UnsetOnDelete().FieldPath(),
	})
}

func (b *filterCndBuilderAlertingResourceUnsetOnDelete) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewAlertFieldPathBuilder().AlertingResource().UnsetOnDelete().FieldPath(),
	})
}

func (b *filterCndBuilderAlertingResourceUnsetOnDelete) compare(op gotenfilter.CompareOperator, value bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:             op,
		Alert_FieldPathValue: NewAlertFieldPathBuilder().AlertingResource().UnsetOnDelete().WithValue(value),
	})
}

type filterCndBuilderTsInfo struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderTsInfo) Eq(value *Alert_TsInfo) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderTsInfo) Neq(value *Alert_TsInfo) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderTsInfo) Gt(value *Alert_TsInfo) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderTsInfo) Gte(value *Alert_TsInfo) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderTsInfo) Lt(value *Alert_TsInfo) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderTsInfo) Lte(value *Alert_TsInfo) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderTsInfo) In(values []*Alert_TsInfo) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().TsInfo().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderTsInfo) NotIn(values []*Alert_TsInfo) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().TsInfo().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderTsInfo) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewAlertFieldPathBuilder().TsInfo().FieldPath(),
	})
}

func (b *filterCndBuilderTsInfo) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewAlertFieldPathBuilder().TsInfo().FieldPath(),
	})
}

func (b *filterCndBuilderTsInfo) compare(op gotenfilter.CompareOperator, value *Alert_TsInfo) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:             op,
		Alert_FieldPathValue: NewAlertFieldPathBuilder().TsInfo().WithValue(value),
	})
}

func (b *filterCndBuilderTsInfo) Type() *filterCndBuilderTsInfoType {
	return &filterCndBuilderTsInfoType{builder: b.builder}
}

func (b *filterCndBuilderTsInfo) AnomalyWindowSize() *filterCndBuilderTsInfoAnomalyWindowSize {
	return &filterCndBuilderTsInfoAnomalyWindowSize{builder: b.builder}
}

func (b *filterCndBuilderTsInfo) CommonKey() *filterCndBuilderTsInfoCommonKey {
	return &filterCndBuilderTsInfoCommonKey{builder: b.builder}
}

func (b *filterCndBuilderTsInfo) MetricTypes() *filterCndBuilderTsInfoMetricTypes {
	return &filterCndBuilderTsInfoMetricTypes{builder: b.builder}
}

func (b *filterCndBuilderTsInfo) ResourceTypes() *filterCndBuilderTsInfoResourceTypes {
	return &filterCndBuilderTsInfoResourceTypes{builder: b.builder}
}

func (b *filterCndBuilderTsInfo) CommonMetricLabels() *filterCndBuilderTsInfoCommonMetricLabels {
	return &filterCndBuilderTsInfoCommonMetricLabels{builder: b.builder}
}

func (b *filterCndBuilderTsInfo) CommonResourceLabels() *filterCndBuilderTsInfoCommonResourceLabels {
	return &filterCndBuilderTsInfoCommonResourceLabels{builder: b.builder}
}

func (b *filterCndBuilderTsInfo) TimeSeries() *filterCndBuilderTsInfoTimeSeries {
	return &filterCndBuilderTsInfoTimeSeries{builder: b.builder}
}

type filterCndBuilderTsInfoType struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderTsInfoType) Eq(value Alert_TsInfo_Type) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderTsInfoType) Neq(value Alert_TsInfo_Type) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderTsInfoType) Gt(value Alert_TsInfo_Type) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderTsInfoType) Gte(value Alert_TsInfo_Type) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderTsInfoType) Lt(value Alert_TsInfo_Type) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderTsInfoType) Lte(value Alert_TsInfo_Type) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderTsInfoType) In(values []Alert_TsInfo_Type) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().TsInfo().Type().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderTsInfoType) NotIn(values []Alert_TsInfo_Type) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().TsInfo().Type().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderTsInfoType) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewAlertFieldPathBuilder().TsInfo().Type().FieldPath(),
	})
}

func (b *filterCndBuilderTsInfoType) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewAlertFieldPathBuilder().TsInfo().Type().FieldPath(),
	})
}

func (b *filterCndBuilderTsInfoType) compare(op gotenfilter.CompareOperator, value Alert_TsInfo_Type) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:             op,
		Alert_FieldPathValue: NewAlertFieldPathBuilder().TsInfo().Type().WithValue(value),
	})
}

type filterCndBuilderTsInfoAnomalyWindowSize struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderTsInfoAnomalyWindowSize) In(values []*durationpb.Duration) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().TsInfo().AnomalyWindowSize().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderTsInfoAnomalyWindowSize) NotIn(values []*durationpb.Duration) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().TsInfo().AnomalyWindowSize().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderTsInfoAnomalyWindowSize) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewAlertFieldPathBuilder().TsInfo().AnomalyWindowSize().FieldPath(),
	})
}

func (b *filterCndBuilderTsInfoAnomalyWindowSize) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewAlertFieldPathBuilder().TsInfo().AnomalyWindowSize().FieldPath(),
	})
}

func (b *filterCndBuilderTsInfoAnomalyWindowSize) compare(op gotenfilter.CompareOperator, value *durationpb.Duration) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:             op,
		Alert_FieldPathValue: NewAlertFieldPathBuilder().TsInfo().AnomalyWindowSize().WithValue(value),
	})
}

type filterCndBuilderTsInfoCommonKey struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderTsInfoCommonKey) In(values [][]byte) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().TsInfo().CommonKey().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderTsInfoCommonKey) NotIn(values [][]byte) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().TsInfo().CommonKey().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderTsInfoCommonKey) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewAlertFieldPathBuilder().TsInfo().CommonKey().FieldPath(),
	})
}

func (b *filterCndBuilderTsInfoCommonKey) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewAlertFieldPathBuilder().TsInfo().CommonKey().FieldPath(),
	})
}

func (b *filterCndBuilderTsInfoCommonKey) compare(op gotenfilter.CompareOperator, value []byte) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:             op,
		Alert_FieldPathValue: NewAlertFieldPathBuilder().TsInfo().CommonKey().WithValue(value),
	})
}

type filterCndBuilderTsInfoMetricTypes struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderTsInfoMetricTypes) In(values [][]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().TsInfo().MetricTypes().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderTsInfoMetricTypes) NotIn(values [][]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().TsInfo().MetricTypes().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderTsInfoMetricTypes) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewAlertFieldPathBuilder().TsInfo().MetricTypes().FieldPath(),
	})
}

func (b *filterCndBuilderTsInfoMetricTypes) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewAlertFieldPathBuilder().TsInfo().MetricTypes().FieldPath(),
	})
}

func (b *filterCndBuilderTsInfoMetricTypes) Contains(value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewAlertFieldPathBuilder().TsInfo().MetricTypes().FieldPath(),
		Value:     NewAlertFieldPathBuilder().TsInfo().MetricTypes().WithItemValue(value),
	})
}

func (b *filterCndBuilderTsInfoMetricTypes) ContainsAnyOf(values []string) *FilterBuilder {
	pathSelector := NewAlertFieldPathBuilder().TsInfo().MetricTypes()
	itemValues := make([]Alert_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewAlertFieldPathBuilder().TsInfo().MetricTypes().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderTsInfoMetricTypes) ContainsAll(values []string) *FilterBuilder {
	pathSelector := NewAlertFieldPathBuilder().TsInfo().MetricTypes()
	itemValues := make([]Alert_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewAlertFieldPathBuilder().TsInfo().MetricTypes().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderTsInfoMetricTypes) compare(op gotenfilter.CompareOperator, value []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:             op,
		Alert_FieldPathValue: NewAlertFieldPathBuilder().TsInfo().MetricTypes().WithValue(value),
	})
}

type filterCndBuilderTsInfoResourceTypes struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderTsInfoResourceTypes) In(values [][]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().TsInfo().ResourceTypes().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderTsInfoResourceTypes) NotIn(values [][]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().TsInfo().ResourceTypes().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderTsInfoResourceTypes) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewAlertFieldPathBuilder().TsInfo().ResourceTypes().FieldPath(),
	})
}

func (b *filterCndBuilderTsInfoResourceTypes) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewAlertFieldPathBuilder().TsInfo().ResourceTypes().FieldPath(),
	})
}

func (b *filterCndBuilderTsInfoResourceTypes) Contains(value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewAlertFieldPathBuilder().TsInfo().ResourceTypes().FieldPath(),
		Value:     NewAlertFieldPathBuilder().TsInfo().ResourceTypes().WithItemValue(value),
	})
}

func (b *filterCndBuilderTsInfoResourceTypes) ContainsAnyOf(values []string) *FilterBuilder {
	pathSelector := NewAlertFieldPathBuilder().TsInfo().ResourceTypes()
	itemValues := make([]Alert_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewAlertFieldPathBuilder().TsInfo().ResourceTypes().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderTsInfoResourceTypes) ContainsAll(values []string) *FilterBuilder {
	pathSelector := NewAlertFieldPathBuilder().TsInfo().ResourceTypes()
	itemValues := make([]Alert_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewAlertFieldPathBuilder().TsInfo().ResourceTypes().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderTsInfoResourceTypes) compare(op gotenfilter.CompareOperator, value []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:             op,
		Alert_FieldPathValue: NewAlertFieldPathBuilder().TsInfo().ResourceTypes().WithValue(value),
	})
}

type filterCndBuilderTsInfoCommonMetricLabels struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderTsInfoCommonMetricLabels) In(values []map[string]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().TsInfo().CommonMetricLabels().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderTsInfoCommonMetricLabels) NotIn(values []map[string]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().TsInfo().CommonMetricLabels().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderTsInfoCommonMetricLabels) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewAlertFieldPathBuilder().TsInfo().CommonMetricLabels().FieldPath(),
	})
}

func (b *filterCndBuilderTsInfoCommonMetricLabels) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewAlertFieldPathBuilder().TsInfo().CommonMetricLabels().FieldPath(),
	})
}

func (b *filterCndBuilderTsInfoCommonMetricLabels) compare(op gotenfilter.CompareOperator, value map[string]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:             op,
		Alert_FieldPathValue: NewAlertFieldPathBuilder().TsInfo().CommonMetricLabels().WithValue(value),
	})
}

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

type mapFilterCndBuilderTsInfoCommonMetricLabels struct {
	builder *FilterBuilder
	key     string
}

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

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

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

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

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

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

func (b *mapFilterCndBuilderTsInfoCommonMetricLabels) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().TsInfo().CommonMetricLabels().WithKey(b.key).WithArrayOfValues(values),
	})
}

func (b *mapFilterCndBuilderTsInfoCommonMetricLabels) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().TsInfo().CommonMetricLabels().WithKey(b.key).WithArrayOfValues(values),
	})
}

func (b *mapFilterCndBuilderTsInfoCommonMetricLabels) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewAlertFieldPathBuilder().TsInfo().CommonMetricLabels().WithKey(b.key).FieldPath(),
	})
}

func (b *mapFilterCndBuilderTsInfoCommonMetricLabels) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewAlertFieldPathBuilder().TsInfo().CommonMetricLabels().WithKey(b.key).FieldPath(),
	})
}

func (b *mapFilterCndBuilderTsInfoCommonMetricLabels) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:             op,
		Alert_FieldPathValue: NewAlertFieldPathBuilder().TsInfo().CommonMetricLabels().WithKey(b.key).WithValue(value),
	})
}

type filterCndBuilderTsInfoCommonResourceLabels struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderTsInfoCommonResourceLabels) In(values []map[string]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().TsInfo().CommonResourceLabels().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderTsInfoCommonResourceLabels) NotIn(values []map[string]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().TsInfo().CommonResourceLabels().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderTsInfoCommonResourceLabels) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewAlertFieldPathBuilder().TsInfo().CommonResourceLabels().FieldPath(),
	})
}

func (b *filterCndBuilderTsInfoCommonResourceLabels) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewAlertFieldPathBuilder().TsInfo().CommonResourceLabels().FieldPath(),
	})
}

func (b *filterCndBuilderTsInfoCommonResourceLabels) compare(op gotenfilter.CompareOperator, value map[string]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:             op,
		Alert_FieldPathValue: NewAlertFieldPathBuilder().TsInfo().CommonResourceLabels().WithValue(value),
	})
}

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

type mapFilterCndBuilderTsInfoCommonResourceLabels struct {
	builder *FilterBuilder
	key     string
}

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

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

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

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

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

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

func (b *mapFilterCndBuilderTsInfoCommonResourceLabels) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().TsInfo().CommonResourceLabels().WithKey(b.key).WithArrayOfValues(values),
	})
}

func (b *mapFilterCndBuilderTsInfoCommonResourceLabels) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().TsInfo().CommonResourceLabels().WithKey(b.key).WithArrayOfValues(values),
	})
}

func (b *mapFilterCndBuilderTsInfoCommonResourceLabels) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewAlertFieldPathBuilder().TsInfo().CommonResourceLabels().WithKey(b.key).FieldPath(),
	})
}

func (b *mapFilterCndBuilderTsInfoCommonResourceLabels) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewAlertFieldPathBuilder().TsInfo().CommonResourceLabels().WithKey(b.key).FieldPath(),
	})
}

func (b *mapFilterCndBuilderTsInfoCommonResourceLabels) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:             op,
		Alert_FieldPathValue: NewAlertFieldPathBuilder().TsInfo().CommonResourceLabels().WithKey(b.key).WithValue(value),
	})
}

type filterCndBuilderTsInfoTimeSeries struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderTsInfoTimeSeries) In(values [][]*Alert_TsInfo_TimeSeries) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().TsInfo().TimeSeries().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderTsInfoTimeSeries) NotIn(values [][]*Alert_TsInfo_TimeSeries) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().TsInfo().TimeSeries().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderTsInfoTimeSeries) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewAlertFieldPathBuilder().TsInfo().TimeSeries().FieldPath(),
	})
}

func (b *filterCndBuilderTsInfoTimeSeries) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewAlertFieldPathBuilder().TsInfo().TimeSeries().FieldPath(),
	})
}

func (b *filterCndBuilderTsInfoTimeSeries) Contains(value *Alert_TsInfo_TimeSeries) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewAlertFieldPathBuilder().TsInfo().TimeSeries().FieldPath(),
		Value:     NewAlertFieldPathBuilder().TsInfo().TimeSeries().WithItemValue(value),
	})
}

func (b *filterCndBuilderTsInfoTimeSeries) ContainsAnyOf(values []*Alert_TsInfo_TimeSeries) *FilterBuilder {
	pathSelector := NewAlertFieldPathBuilder().TsInfo().TimeSeries()
	itemValues := make([]Alert_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewAlertFieldPathBuilder().TsInfo().TimeSeries().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderTsInfoTimeSeries) ContainsAll(values []*Alert_TsInfo_TimeSeries) *FilterBuilder {
	pathSelector := NewAlertFieldPathBuilder().TsInfo().TimeSeries()
	itemValues := make([]Alert_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewAlertFieldPathBuilder().TsInfo().TimeSeries().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderTsInfoTimeSeries) compare(op gotenfilter.CompareOperator, value []*Alert_TsInfo_TimeSeries) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:             op,
		Alert_FieldPathValue: NewAlertFieldPathBuilder().TsInfo().TimeSeries().WithValue(value),
	})
}

func (b *filterCndBuilderTsInfoTimeSeries) QueryName() *filterCndBuilderTsInfoTimeSeriesQueryName {
	return &filterCndBuilderTsInfoTimeSeriesQueryName{builder: b.builder}
}

func (b *filterCndBuilderTsInfoTimeSeries) Values() *filterCndBuilderTsInfoTimeSeriesValues {
	return &filterCndBuilderTsInfoTimeSeriesValues{builder: b.builder}
}

func (b *filterCndBuilderTsInfoTimeSeries) Anomalies() *filterCndBuilderTsInfoTimeSeriesAnomalies {
	return &filterCndBuilderTsInfoTimeSeriesAnomalies{builder: b.builder}
}

func (b *filterCndBuilderTsInfoTimeSeries) UpperThreshold() *filterCndBuilderTsInfoTimeSeriesUpperThreshold {
	return &filterCndBuilderTsInfoTimeSeriesUpperThreshold{builder: b.builder}
}

func (b *filterCndBuilderTsInfoTimeSeries) LowerThreshold() *filterCndBuilderTsInfoTimeSeriesLowerThreshold {
	return &filterCndBuilderTsInfoTimeSeriesLowerThreshold{builder: b.builder}
}

func (b *filterCndBuilderTsInfoTimeSeries) AnomalyThreshold() *filterCndBuilderTsInfoTimeSeriesAnomalyThreshold {
	return &filterCndBuilderTsInfoTimeSeriesAnomalyThreshold{builder: b.builder}
}

func (b *filterCndBuilderTsInfoTimeSeries) AfterDuration() *filterCndBuilderTsInfoTimeSeriesAfterDuration {
	return &filterCndBuilderTsInfoTimeSeriesAfterDuration{builder: b.builder}
}

type filterCndBuilderTsInfoTimeSeriesQueryName struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderTsInfoTimeSeriesQueryName) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().TsInfo().TimeSeries().QueryName().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderTsInfoTimeSeriesQueryName) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().TsInfo().TimeSeries().QueryName().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderTsInfoTimeSeriesQueryName) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewAlertFieldPathBuilder().TsInfo().TimeSeries().QueryName().FieldPath(),
	})
}

func (b *filterCndBuilderTsInfoTimeSeriesQueryName) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewAlertFieldPathBuilder().TsInfo().TimeSeries().QueryName().FieldPath(),
	})
}

func (b *filterCndBuilderTsInfoTimeSeriesQueryName) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:             op,
		Alert_FieldPathValue: NewAlertFieldPathBuilder().TsInfo().TimeSeries().QueryName().WithValue(value),
	})
}

type filterCndBuilderTsInfoTimeSeriesValues struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderTsInfoTimeSeriesValues) In(values [][]float64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().TsInfo().TimeSeries().Values().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderTsInfoTimeSeriesValues) NotIn(values [][]float64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().TsInfo().TimeSeries().Values().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderTsInfoTimeSeriesValues) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewAlertFieldPathBuilder().TsInfo().TimeSeries().Values().FieldPath(),
	})
}

func (b *filterCndBuilderTsInfoTimeSeriesValues) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewAlertFieldPathBuilder().TsInfo().TimeSeries().Values().FieldPath(),
	})
}

func (b *filterCndBuilderTsInfoTimeSeriesValues) Contains(value float64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewAlertFieldPathBuilder().TsInfo().TimeSeries().Values().FieldPath(),
		Value:     NewAlertFieldPathBuilder().TsInfo().TimeSeries().Values().WithItemValue(value),
	})
}

func (b *filterCndBuilderTsInfoTimeSeriesValues) ContainsAnyOf(values []float64) *FilterBuilder {
	pathSelector := NewAlertFieldPathBuilder().TsInfo().TimeSeries().Values()
	itemValues := make([]Alert_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewAlertFieldPathBuilder().TsInfo().TimeSeries().Values().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderTsInfoTimeSeriesValues) ContainsAll(values []float64) *FilterBuilder {
	pathSelector := NewAlertFieldPathBuilder().TsInfo().TimeSeries().Values()
	itemValues := make([]Alert_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewAlertFieldPathBuilder().TsInfo().TimeSeries().Values().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderTsInfoTimeSeriesValues) compare(op gotenfilter.CompareOperator, value []float64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:             op,
		Alert_FieldPathValue: NewAlertFieldPathBuilder().TsInfo().TimeSeries().Values().WithValue(value),
	})
}

type filterCndBuilderTsInfoTimeSeriesAnomalies struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderTsInfoTimeSeriesAnomalies) In(values [][]float64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().TsInfo().TimeSeries().Anomalies().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderTsInfoTimeSeriesAnomalies) NotIn(values [][]float64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().TsInfo().TimeSeries().Anomalies().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderTsInfoTimeSeriesAnomalies) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewAlertFieldPathBuilder().TsInfo().TimeSeries().Anomalies().FieldPath(),
	})
}

func (b *filterCndBuilderTsInfoTimeSeriesAnomalies) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewAlertFieldPathBuilder().TsInfo().TimeSeries().Anomalies().FieldPath(),
	})
}

func (b *filterCndBuilderTsInfoTimeSeriesAnomalies) Contains(value float64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewAlertFieldPathBuilder().TsInfo().TimeSeries().Anomalies().FieldPath(),
		Value:     NewAlertFieldPathBuilder().TsInfo().TimeSeries().Anomalies().WithItemValue(value),
	})
}

func (b *filterCndBuilderTsInfoTimeSeriesAnomalies) ContainsAnyOf(values []float64) *FilterBuilder {
	pathSelector := NewAlertFieldPathBuilder().TsInfo().TimeSeries().Anomalies()
	itemValues := make([]Alert_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewAlertFieldPathBuilder().TsInfo().TimeSeries().Anomalies().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderTsInfoTimeSeriesAnomalies) ContainsAll(values []float64) *FilterBuilder {
	pathSelector := NewAlertFieldPathBuilder().TsInfo().TimeSeries().Anomalies()
	itemValues := make([]Alert_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewAlertFieldPathBuilder().TsInfo().TimeSeries().Anomalies().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderTsInfoTimeSeriesAnomalies) compare(op gotenfilter.CompareOperator, value []float64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:             op,
		Alert_FieldPathValue: NewAlertFieldPathBuilder().TsInfo().TimeSeries().Anomalies().WithValue(value),
	})
}

type filterCndBuilderTsInfoTimeSeriesUpperThreshold struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderTsInfoTimeSeriesUpperThreshold) Eq(value *rcommon.AlertingThreshold) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderTsInfoTimeSeriesUpperThreshold) Neq(value *rcommon.AlertingThreshold) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderTsInfoTimeSeriesUpperThreshold) Gt(value *rcommon.AlertingThreshold) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderTsInfoTimeSeriesUpperThreshold) Gte(value *rcommon.AlertingThreshold) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderTsInfoTimeSeriesUpperThreshold) Lt(value *rcommon.AlertingThreshold) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderTsInfoTimeSeriesUpperThreshold) Lte(value *rcommon.AlertingThreshold) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderTsInfoTimeSeriesUpperThreshold) In(values []*rcommon.AlertingThreshold) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().TsInfo().TimeSeries().UpperThreshold().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderTsInfoTimeSeriesUpperThreshold) NotIn(values []*rcommon.AlertingThreshold) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().TsInfo().TimeSeries().UpperThreshold().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderTsInfoTimeSeriesUpperThreshold) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewAlertFieldPathBuilder().TsInfo().TimeSeries().UpperThreshold().FieldPath(),
	})
}

func (b *filterCndBuilderTsInfoTimeSeriesUpperThreshold) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewAlertFieldPathBuilder().TsInfo().TimeSeries().UpperThreshold().FieldPath(),
	})
}

func (b *filterCndBuilderTsInfoTimeSeriesUpperThreshold) compare(op gotenfilter.CompareOperator, value *rcommon.AlertingThreshold) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:             op,
		Alert_FieldPathValue: NewAlertFieldPathBuilder().TsInfo().TimeSeries().UpperThreshold().WithValue(value),
	})
}

func (b *filterCndBuilderTsInfoTimeSeriesUpperThreshold) Value() *filterCndBuilderTsInfoTimeSeriesUpperThresholdValue {
	return &filterCndBuilderTsInfoTimeSeriesUpperThresholdValue{builder: b.builder}
}

func (b *filterCndBuilderTsInfoTimeSeriesUpperThreshold) IsInclusive() *filterCndBuilderTsInfoTimeSeriesUpperThresholdIsInclusive {
	return &filterCndBuilderTsInfoTimeSeriesUpperThresholdIsInclusive{builder: b.builder}
}

type filterCndBuilderTsInfoTimeSeriesUpperThresholdValue struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderTsInfoTimeSeriesUpperThresholdValue) In(values []float64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().TsInfo().TimeSeries().UpperThreshold().Value().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderTsInfoTimeSeriesUpperThresholdValue) NotIn(values []float64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().TsInfo().TimeSeries().UpperThreshold().Value().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderTsInfoTimeSeriesUpperThresholdValue) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewAlertFieldPathBuilder().TsInfo().TimeSeries().UpperThreshold().Value().FieldPath(),
	})
}

func (b *filterCndBuilderTsInfoTimeSeriesUpperThresholdValue) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewAlertFieldPathBuilder().TsInfo().TimeSeries().UpperThreshold().Value().FieldPath(),
	})
}

func (b *filterCndBuilderTsInfoTimeSeriesUpperThresholdValue) compare(op gotenfilter.CompareOperator, value float64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:             op,
		Alert_FieldPathValue: NewAlertFieldPathBuilder().TsInfo().TimeSeries().UpperThreshold().Value().WithValue(value),
	})
}

type filterCndBuilderTsInfoTimeSeriesUpperThresholdIsInclusive struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderTsInfoTimeSeriesUpperThresholdIsInclusive) In(values []bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().TsInfo().TimeSeries().UpperThreshold().IsInclusive().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderTsInfoTimeSeriesUpperThresholdIsInclusive) NotIn(values []bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().TsInfo().TimeSeries().UpperThreshold().IsInclusive().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderTsInfoTimeSeriesUpperThresholdIsInclusive) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewAlertFieldPathBuilder().TsInfo().TimeSeries().UpperThreshold().IsInclusive().FieldPath(),
	})
}

func (b *filterCndBuilderTsInfoTimeSeriesUpperThresholdIsInclusive) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewAlertFieldPathBuilder().TsInfo().TimeSeries().UpperThreshold().IsInclusive().FieldPath(),
	})
}

func (b *filterCndBuilderTsInfoTimeSeriesUpperThresholdIsInclusive) compare(op gotenfilter.CompareOperator, value bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:             op,
		Alert_FieldPathValue: NewAlertFieldPathBuilder().TsInfo().TimeSeries().UpperThreshold().IsInclusive().WithValue(value),
	})
}

type filterCndBuilderTsInfoTimeSeriesLowerThreshold struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderTsInfoTimeSeriesLowerThreshold) Eq(value *rcommon.AlertingThreshold) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderTsInfoTimeSeriesLowerThreshold) Neq(value *rcommon.AlertingThreshold) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderTsInfoTimeSeriesLowerThreshold) Gt(value *rcommon.AlertingThreshold) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderTsInfoTimeSeriesLowerThreshold) Gte(value *rcommon.AlertingThreshold) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderTsInfoTimeSeriesLowerThreshold) Lt(value *rcommon.AlertingThreshold) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderTsInfoTimeSeriesLowerThreshold) Lte(value *rcommon.AlertingThreshold) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderTsInfoTimeSeriesLowerThreshold) In(values []*rcommon.AlertingThreshold) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().TsInfo().TimeSeries().LowerThreshold().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderTsInfoTimeSeriesLowerThreshold) NotIn(values []*rcommon.AlertingThreshold) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().TsInfo().TimeSeries().LowerThreshold().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderTsInfoTimeSeriesLowerThreshold) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewAlertFieldPathBuilder().TsInfo().TimeSeries().LowerThreshold().FieldPath(),
	})
}

func (b *filterCndBuilderTsInfoTimeSeriesLowerThreshold) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewAlertFieldPathBuilder().TsInfo().TimeSeries().LowerThreshold().FieldPath(),
	})
}

func (b *filterCndBuilderTsInfoTimeSeriesLowerThreshold) compare(op gotenfilter.CompareOperator, value *rcommon.AlertingThreshold) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:             op,
		Alert_FieldPathValue: NewAlertFieldPathBuilder().TsInfo().TimeSeries().LowerThreshold().WithValue(value),
	})
}

func (b *filterCndBuilderTsInfoTimeSeriesLowerThreshold) Value() *filterCndBuilderTsInfoTimeSeriesLowerThresholdValue {
	return &filterCndBuilderTsInfoTimeSeriesLowerThresholdValue{builder: b.builder}
}

func (b *filterCndBuilderTsInfoTimeSeriesLowerThreshold) IsInclusive() *filterCndBuilderTsInfoTimeSeriesLowerThresholdIsInclusive {
	return &filterCndBuilderTsInfoTimeSeriesLowerThresholdIsInclusive{builder: b.builder}
}

type filterCndBuilderTsInfoTimeSeriesLowerThresholdValue struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderTsInfoTimeSeriesLowerThresholdValue) In(values []float64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().TsInfo().TimeSeries().LowerThreshold().Value().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderTsInfoTimeSeriesLowerThresholdValue) NotIn(values []float64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().TsInfo().TimeSeries().LowerThreshold().Value().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderTsInfoTimeSeriesLowerThresholdValue) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewAlertFieldPathBuilder().TsInfo().TimeSeries().LowerThreshold().Value().FieldPath(),
	})
}

func (b *filterCndBuilderTsInfoTimeSeriesLowerThresholdValue) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewAlertFieldPathBuilder().TsInfo().TimeSeries().LowerThreshold().Value().FieldPath(),
	})
}

func (b *filterCndBuilderTsInfoTimeSeriesLowerThresholdValue) compare(op gotenfilter.CompareOperator, value float64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:             op,
		Alert_FieldPathValue: NewAlertFieldPathBuilder().TsInfo().TimeSeries().LowerThreshold().Value().WithValue(value),
	})
}

type filterCndBuilderTsInfoTimeSeriesLowerThresholdIsInclusive struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderTsInfoTimeSeriesLowerThresholdIsInclusive) In(values []bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().TsInfo().TimeSeries().LowerThreshold().IsInclusive().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderTsInfoTimeSeriesLowerThresholdIsInclusive) NotIn(values []bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().TsInfo().TimeSeries().LowerThreshold().IsInclusive().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderTsInfoTimeSeriesLowerThresholdIsInclusive) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewAlertFieldPathBuilder().TsInfo().TimeSeries().LowerThreshold().IsInclusive().FieldPath(),
	})
}

func (b *filterCndBuilderTsInfoTimeSeriesLowerThresholdIsInclusive) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewAlertFieldPathBuilder().TsInfo().TimeSeries().LowerThreshold().IsInclusive().FieldPath(),
	})
}

func (b *filterCndBuilderTsInfoTimeSeriesLowerThresholdIsInclusive) compare(op gotenfilter.CompareOperator, value bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:             op,
		Alert_FieldPathValue: NewAlertFieldPathBuilder().TsInfo().TimeSeries().LowerThreshold().IsInclusive().WithValue(value),
	})
}

type filterCndBuilderTsInfoTimeSeriesAnomalyThreshold struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderTsInfoTimeSeriesAnomalyThreshold) In(values []float64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().TsInfo().TimeSeries().AnomalyThreshold().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderTsInfoTimeSeriesAnomalyThreshold) NotIn(values []float64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().TsInfo().TimeSeries().AnomalyThreshold().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderTsInfoTimeSeriesAnomalyThreshold) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewAlertFieldPathBuilder().TsInfo().TimeSeries().AnomalyThreshold().FieldPath(),
	})
}

func (b *filterCndBuilderTsInfoTimeSeriesAnomalyThreshold) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewAlertFieldPathBuilder().TsInfo().TimeSeries().AnomalyThreshold().FieldPath(),
	})
}

func (b *filterCndBuilderTsInfoTimeSeriesAnomalyThreshold) compare(op gotenfilter.CompareOperator, value float64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:             op,
		Alert_FieldPathValue: NewAlertFieldPathBuilder().TsInfo().TimeSeries().AnomalyThreshold().WithValue(value),
	})
}

type filterCndBuilderTsInfoTimeSeriesAfterDuration struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderTsInfoTimeSeriesAfterDuration) In(values []*durationpb.Duration) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().TsInfo().TimeSeries().AfterDuration().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderTsInfoTimeSeriesAfterDuration) NotIn(values []*durationpb.Duration) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().TsInfo().TimeSeries().AfterDuration().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderTsInfoTimeSeriesAfterDuration) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewAlertFieldPathBuilder().TsInfo().TimeSeries().AfterDuration().FieldPath(),
	})
}

func (b *filterCndBuilderTsInfoTimeSeriesAfterDuration) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewAlertFieldPathBuilder().TsInfo().TimeSeries().AfterDuration().FieldPath(),
	})
}

func (b *filterCndBuilderTsInfoTimeSeriesAfterDuration) compare(op gotenfilter.CompareOperator, value *durationpb.Duration) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:             op,
		Alert_FieldPathValue: NewAlertFieldPathBuilder().TsInfo().TimeSeries().AfterDuration().WithValue(value),
	})
}

type filterCndBuilderLogInfo struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderLogInfo) Eq(value *Alert_LogInfo) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderLogInfo) Neq(value *Alert_LogInfo) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderLogInfo) Gt(value *Alert_LogInfo) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderLogInfo) Gte(value *Alert_LogInfo) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderLogInfo) Lt(value *Alert_LogInfo) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderLogInfo) Lte(value *Alert_LogInfo) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderLogInfo) In(values []*Alert_LogInfo) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().LogInfo().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderLogInfo) NotIn(values []*Alert_LogInfo) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().LogInfo().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderLogInfo) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewAlertFieldPathBuilder().LogInfo().FieldPath(),
	})
}

func (b *filterCndBuilderLogInfo) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewAlertFieldPathBuilder().LogInfo().FieldPath(),
	})
}

func (b *filterCndBuilderLogInfo) compare(op gotenfilter.CompareOperator, value *Alert_LogInfo) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:             op,
		Alert_FieldPathValue: NewAlertFieldPathBuilder().LogInfo().WithValue(value),
	})
}

func (b *filterCndBuilderLogInfo) CommonKey() *filterCndBuilderLogInfoCommonKey {
	return &filterCndBuilderLogInfoCommonKey{builder: b.builder}
}

func (b *filterCndBuilderLogInfo) LogTypes() *filterCndBuilderLogInfoLogTypes {
	return &filterCndBuilderLogInfoLogTypes{builder: b.builder}
}

func (b *filterCndBuilderLogInfo) CommonLogLabels() *filterCndBuilderLogInfoCommonLogLabels {
	return &filterCndBuilderLogInfoCommonLogLabels{builder: b.builder}
}

func (b *filterCndBuilderLogInfo) ViolatingLog() *filterCndBuilderLogInfoViolatingLog {
	return &filterCndBuilderLogInfoViolatingLog{builder: b.builder}
}

type filterCndBuilderLogInfoCommonKey struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderLogInfoCommonKey) In(values [][]byte) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().LogInfo().CommonKey().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderLogInfoCommonKey) NotIn(values [][]byte) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().LogInfo().CommonKey().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderLogInfoCommonKey) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewAlertFieldPathBuilder().LogInfo().CommonKey().FieldPath(),
	})
}

func (b *filterCndBuilderLogInfoCommonKey) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewAlertFieldPathBuilder().LogInfo().CommonKey().FieldPath(),
	})
}

func (b *filterCndBuilderLogInfoCommonKey) compare(op gotenfilter.CompareOperator, value []byte) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:             op,
		Alert_FieldPathValue: NewAlertFieldPathBuilder().LogInfo().CommonKey().WithValue(value),
	})
}

type filterCndBuilderLogInfoLogTypes struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderLogInfoLogTypes) In(values [][]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().LogInfo().LogTypes().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderLogInfoLogTypes) NotIn(values [][]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().LogInfo().LogTypes().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderLogInfoLogTypes) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewAlertFieldPathBuilder().LogInfo().LogTypes().FieldPath(),
	})
}

func (b *filterCndBuilderLogInfoLogTypes) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewAlertFieldPathBuilder().LogInfo().LogTypes().FieldPath(),
	})
}

func (b *filterCndBuilderLogInfoLogTypes) Contains(value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewAlertFieldPathBuilder().LogInfo().LogTypes().FieldPath(),
		Value:     NewAlertFieldPathBuilder().LogInfo().LogTypes().WithItemValue(value),
	})
}

func (b *filterCndBuilderLogInfoLogTypes) ContainsAnyOf(values []string) *FilterBuilder {
	pathSelector := NewAlertFieldPathBuilder().LogInfo().LogTypes()
	itemValues := make([]Alert_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewAlertFieldPathBuilder().LogInfo().LogTypes().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderLogInfoLogTypes) ContainsAll(values []string) *FilterBuilder {
	pathSelector := NewAlertFieldPathBuilder().LogInfo().LogTypes()
	itemValues := make([]Alert_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewAlertFieldPathBuilder().LogInfo().LogTypes().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderLogInfoLogTypes) compare(op gotenfilter.CompareOperator, value []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:             op,
		Alert_FieldPathValue: NewAlertFieldPathBuilder().LogInfo().LogTypes().WithValue(value),
	})
}

type filterCndBuilderLogInfoCommonLogLabels struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderLogInfoCommonLogLabels) In(values []map[string]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().LogInfo().CommonLogLabels().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderLogInfoCommonLogLabels) NotIn(values []map[string]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().LogInfo().CommonLogLabels().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderLogInfoCommonLogLabels) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewAlertFieldPathBuilder().LogInfo().CommonLogLabels().FieldPath(),
	})
}

func (b *filterCndBuilderLogInfoCommonLogLabels) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewAlertFieldPathBuilder().LogInfo().CommonLogLabels().FieldPath(),
	})
}

func (b *filterCndBuilderLogInfoCommonLogLabels) compare(op gotenfilter.CompareOperator, value map[string]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:             op,
		Alert_FieldPathValue: NewAlertFieldPathBuilder().LogInfo().CommonLogLabels().WithValue(value),
	})
}

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

type mapFilterCndBuilderLogInfoCommonLogLabels struct {
	builder *FilterBuilder
	key     string
}

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

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

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

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

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

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

func (b *mapFilterCndBuilderLogInfoCommonLogLabels) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().LogInfo().CommonLogLabels().WithKey(b.key).WithArrayOfValues(values),
	})
}

func (b *mapFilterCndBuilderLogInfoCommonLogLabels) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().LogInfo().CommonLogLabels().WithKey(b.key).WithArrayOfValues(values),
	})
}

func (b *mapFilterCndBuilderLogInfoCommonLogLabels) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewAlertFieldPathBuilder().LogInfo().CommonLogLabels().WithKey(b.key).FieldPath(),
	})
}

func (b *mapFilterCndBuilderLogInfoCommonLogLabels) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewAlertFieldPathBuilder().LogInfo().CommonLogLabels().WithKey(b.key).FieldPath(),
	})
}

func (b *mapFilterCndBuilderLogInfoCommonLogLabels) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:             op,
		Alert_FieldPathValue: NewAlertFieldPathBuilder().LogInfo().CommonLogLabels().WithKey(b.key).WithValue(value),
	})
}

type filterCndBuilderLogInfoViolatingLog struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderLogInfoViolatingLog) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().LogInfo().ViolatingLog().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderLogInfoViolatingLog) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().LogInfo().ViolatingLog().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderLogInfoViolatingLog) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewAlertFieldPathBuilder().LogInfo().ViolatingLog().FieldPath(),
	})
}

func (b *filterCndBuilderLogInfoViolatingLog) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewAlertFieldPathBuilder().LogInfo().ViolatingLog().FieldPath(),
	})
}

func (b *filterCndBuilderLogInfoViolatingLog) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:             op,
		Alert_FieldPathValue: NewAlertFieldPathBuilder().LogInfo().ViolatingLog().WithValue(value),
	})
}

type filterCndBuilderState struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderState) Eq(value *Alert_State) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderState) Neq(value *Alert_State) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderState) Gt(value *Alert_State) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderState) Gte(value *Alert_State) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderState) Lt(value *Alert_State) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderState) Lte(value *Alert_State) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderState) In(values []*Alert_State) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().State().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderState) NotIn(values []*Alert_State) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().State().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderState) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewAlertFieldPathBuilder().State().FieldPath(),
	})
}

func (b *filterCndBuilderState) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewAlertFieldPathBuilder().State().FieldPath(),
	})
}

func (b *filterCndBuilderState) compare(op gotenfilter.CompareOperator, value *Alert_State) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:             op,
		Alert_FieldPathValue: NewAlertFieldPathBuilder().State().WithValue(value),
	})
}

func (b *filterCndBuilderState) IsFiring() *filterCndBuilderStateIsFiring {
	return &filterCndBuilderStateIsFiring{builder: b.builder}
}

func (b *filterCndBuilderState) StartTime() *filterCndBuilderStateStartTime {
	return &filterCndBuilderStateStartTime{builder: b.builder}
}

func (b *filterCndBuilderState) EndTime() *filterCndBuilderStateEndTime {
	return &filterCndBuilderStateEndTime{builder: b.builder}
}

func (b *filterCndBuilderState) NotificationStatuses() *filterCndBuilderStateNotificationStatuses {
	return &filterCndBuilderStateNotificationStatuses{builder: b.builder}
}

func (b *filterCndBuilderState) EscalationLevel() *filterCndBuilderStateEscalationLevel {
	return &filterCndBuilderStateEscalationLevel{builder: b.builder}
}

func (b *filterCndBuilderState) AiAgentHandlingState() *filterCndBuilderStateAiAgentHandlingState {
	return &filterCndBuilderStateAiAgentHandlingState{builder: b.builder}
}

func (b *filterCndBuilderState) AiAgentLastStateChangeTime() *filterCndBuilderStateAiAgentLastStateChangeTime {
	return &filterCndBuilderStateAiAgentLastStateChangeTime{builder: b.builder}
}

func (b *filterCndBuilderState) AiAgentDiagnosisNotes() *filterCndBuilderStateAiAgentDiagnosisNotes {
	return &filterCndBuilderStateAiAgentDiagnosisNotes{builder: b.builder}
}

func (b *filterCndBuilderState) AiRemediationArg() *filterCndBuilderStateAiRemediationArg {
	return &filterCndBuilderStateAiRemediationArg{builder: b.builder}
}

func (b *filterCndBuilderState) AiRemediation() *filterCndBuilderStateAiRemediation {
	return &filterCndBuilderStateAiRemediation{builder: b.builder}
}

func (b *filterCndBuilderState) OperatorHandlingState() *filterCndBuilderStateOperatorHandlingState {
	return &filterCndBuilderStateOperatorHandlingState{builder: b.builder}
}

func (b *filterCndBuilderState) OperatorLastStateChangeTime() *filterCndBuilderStateOperatorLastStateChangeTime {
	return &filterCndBuilderStateOperatorLastStateChangeTime{builder: b.builder}
}

func (b *filterCndBuilderState) OperatorNotes() *filterCndBuilderStateOperatorNotes {
	return &filterCndBuilderStateOperatorNotes{builder: b.builder}
}

func (b *filterCndBuilderState) LifecycleCompleted() *filterCndBuilderStateLifecycleCompleted {
	return &filterCndBuilderStateLifecycleCompleted{builder: b.builder}
}

type filterCndBuilderStateIsFiring struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStateIsFiring) In(values []bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().State().IsFiring().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStateIsFiring) NotIn(values []bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().State().IsFiring().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStateIsFiring) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewAlertFieldPathBuilder().State().IsFiring().FieldPath(),
	})
}

func (b *filterCndBuilderStateIsFiring) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewAlertFieldPathBuilder().State().IsFiring().FieldPath(),
	})
}

func (b *filterCndBuilderStateIsFiring) compare(op gotenfilter.CompareOperator, value bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:             op,
		Alert_FieldPathValue: NewAlertFieldPathBuilder().State().IsFiring().WithValue(value),
	})
}

type filterCndBuilderStateStartTime struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStateStartTime) In(values []*timestamppb.Timestamp) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().State().StartTime().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStateStartTime) NotIn(values []*timestamppb.Timestamp) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().State().StartTime().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStateStartTime) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewAlertFieldPathBuilder().State().StartTime().FieldPath(),
	})
}

func (b *filterCndBuilderStateStartTime) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewAlertFieldPathBuilder().State().StartTime().FieldPath(),
	})
}

func (b *filterCndBuilderStateStartTime) compare(op gotenfilter.CompareOperator, value *timestamppb.Timestamp) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:             op,
		Alert_FieldPathValue: NewAlertFieldPathBuilder().State().StartTime().WithValue(value),
	})
}

type filterCndBuilderStateEndTime struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStateEndTime) In(values []*timestamppb.Timestamp) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().State().EndTime().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStateEndTime) NotIn(values []*timestamppb.Timestamp) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().State().EndTime().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStateEndTime) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewAlertFieldPathBuilder().State().EndTime().FieldPath(),
	})
}

func (b *filterCndBuilderStateEndTime) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewAlertFieldPathBuilder().State().EndTime().FieldPath(),
	})
}

func (b *filterCndBuilderStateEndTime) compare(op gotenfilter.CompareOperator, value *timestamppb.Timestamp) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:             op,
		Alert_FieldPathValue: NewAlertFieldPathBuilder().State().EndTime().WithValue(value),
	})
}

type filterCndBuilderStateNotificationStatuses struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStateNotificationStatuses) In(values [][]*Alert_State_Notification) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().State().NotificationStatuses().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStateNotificationStatuses) NotIn(values [][]*Alert_State_Notification) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().State().NotificationStatuses().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStateNotificationStatuses) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewAlertFieldPathBuilder().State().NotificationStatuses().FieldPath(),
	})
}

func (b *filterCndBuilderStateNotificationStatuses) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewAlertFieldPathBuilder().State().NotificationStatuses().FieldPath(),
	})
}

func (b *filterCndBuilderStateNotificationStatuses) Contains(value *Alert_State_Notification) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewAlertFieldPathBuilder().State().NotificationStatuses().FieldPath(),
		Value:     NewAlertFieldPathBuilder().State().NotificationStatuses().WithItemValue(value),
	})
}

func (b *filterCndBuilderStateNotificationStatuses) ContainsAnyOf(values []*Alert_State_Notification) *FilterBuilder {
	pathSelector := NewAlertFieldPathBuilder().State().NotificationStatuses()
	itemValues := make([]Alert_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewAlertFieldPathBuilder().State().NotificationStatuses().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderStateNotificationStatuses) ContainsAll(values []*Alert_State_Notification) *FilterBuilder {
	pathSelector := NewAlertFieldPathBuilder().State().NotificationStatuses()
	itemValues := make([]Alert_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewAlertFieldPathBuilder().State().NotificationStatuses().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderStateNotificationStatuses) compare(op gotenfilter.CompareOperator, value []*Alert_State_Notification) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:             op,
		Alert_FieldPathValue: NewAlertFieldPathBuilder().State().NotificationStatuses().WithValue(value),
	})
}

func (b *filterCndBuilderStateNotificationStatuses) Kind() *filterCndBuilderStateNotificationStatusesKind {
	return &filterCndBuilderStateNotificationStatusesKind{builder: b.builder}
}

func (b *filterCndBuilderStateNotificationStatuses) PendingChannels() *filterCndBuilderStateNotificationStatusesPendingChannels {
	return &filterCndBuilderStateNotificationStatusesPendingChannels{builder: b.builder}
}

type filterCndBuilderStateNotificationStatusesKind struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStateNotificationStatusesKind) Eq(value rcommon.NotificationChannelSpec_EventKind) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStateNotificationStatusesKind) Neq(value rcommon.NotificationChannelSpec_EventKind) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStateNotificationStatusesKind) Gt(value rcommon.NotificationChannelSpec_EventKind) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStateNotificationStatusesKind) Gte(value rcommon.NotificationChannelSpec_EventKind) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStateNotificationStatusesKind) Lt(value rcommon.NotificationChannelSpec_EventKind) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStateNotificationStatusesKind) Lte(value rcommon.NotificationChannelSpec_EventKind) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStateNotificationStatusesKind) In(values []rcommon.NotificationChannelSpec_EventKind) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().State().NotificationStatuses().Kind().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStateNotificationStatusesKind) NotIn(values []rcommon.NotificationChannelSpec_EventKind) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().State().NotificationStatuses().Kind().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStateNotificationStatusesKind) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewAlertFieldPathBuilder().State().NotificationStatuses().Kind().FieldPath(),
	})
}

func (b *filterCndBuilderStateNotificationStatusesKind) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewAlertFieldPathBuilder().State().NotificationStatuses().Kind().FieldPath(),
	})
}

func (b *filterCndBuilderStateNotificationStatusesKind) compare(op gotenfilter.CompareOperator, value rcommon.NotificationChannelSpec_EventKind) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:             op,
		Alert_FieldPathValue: NewAlertFieldPathBuilder().State().NotificationStatuses().Kind().WithValue(value),
	})
}

type filterCndBuilderStateNotificationStatusesPendingChannels struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStateNotificationStatusesPendingChannels) Eq(value []*notification_channel.Reference) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStateNotificationStatusesPendingChannels) Neq(value []*notification_channel.Reference) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStateNotificationStatusesPendingChannels) Gt(value []*notification_channel.Reference) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStateNotificationStatusesPendingChannels) Gte(value []*notification_channel.Reference) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStateNotificationStatusesPendingChannels) Lt(value []*notification_channel.Reference) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStateNotificationStatusesPendingChannels) Lte(value []*notification_channel.Reference) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStateNotificationStatusesPendingChannels) In(values [][]*notification_channel.Reference) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().State().NotificationStatuses().PendingChannels().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStateNotificationStatusesPendingChannels) NotIn(values [][]*notification_channel.Reference) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().State().NotificationStatuses().PendingChannels().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStateNotificationStatusesPendingChannels) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewAlertFieldPathBuilder().State().NotificationStatuses().PendingChannels().FieldPath(),
	})
}

func (b *filterCndBuilderStateNotificationStatusesPendingChannels) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewAlertFieldPathBuilder().State().NotificationStatuses().PendingChannels().FieldPath(),
	})
}

func (b *filterCndBuilderStateNotificationStatusesPendingChannels) Contains(value *notification_channel.Reference) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewAlertFieldPathBuilder().State().NotificationStatuses().PendingChannels().FieldPath(),
		Value:     NewAlertFieldPathBuilder().State().NotificationStatuses().PendingChannels().WithItemValue(value),
	})
}

func (b *filterCndBuilderStateNotificationStatusesPendingChannels) ContainsAnyOf(values []*notification_channel.Reference) *FilterBuilder {
	pathSelector := NewAlertFieldPathBuilder().State().NotificationStatuses().PendingChannels()
	itemValues := make([]Alert_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewAlertFieldPathBuilder().State().NotificationStatuses().PendingChannels().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderStateNotificationStatusesPendingChannels) ContainsAll(values []*notification_channel.Reference) *FilterBuilder {
	pathSelector := NewAlertFieldPathBuilder().State().NotificationStatuses().PendingChannels()
	itemValues := make([]Alert_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewAlertFieldPathBuilder().State().NotificationStatuses().PendingChannels().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderStateNotificationStatusesPendingChannels) compare(op gotenfilter.CompareOperator, value []*notification_channel.Reference) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:             op,
		Alert_FieldPathValue: NewAlertFieldPathBuilder().State().NotificationStatuses().PendingChannels().WithValue(value),
	})
}

type filterCndBuilderStateEscalationLevel struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStateEscalationLevel) Eq(value Alert_State_EscalationLevel) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStateEscalationLevel) Neq(value Alert_State_EscalationLevel) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStateEscalationLevel) Gt(value Alert_State_EscalationLevel) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStateEscalationLevel) Gte(value Alert_State_EscalationLevel) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStateEscalationLevel) Lt(value Alert_State_EscalationLevel) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStateEscalationLevel) Lte(value Alert_State_EscalationLevel) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStateEscalationLevel) In(values []Alert_State_EscalationLevel) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().State().EscalationLevel().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStateEscalationLevel) NotIn(values []Alert_State_EscalationLevel) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().State().EscalationLevel().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStateEscalationLevel) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewAlertFieldPathBuilder().State().EscalationLevel().FieldPath(),
	})
}

func (b *filterCndBuilderStateEscalationLevel) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewAlertFieldPathBuilder().State().EscalationLevel().FieldPath(),
	})
}

func (b *filterCndBuilderStateEscalationLevel) compare(op gotenfilter.CompareOperator, value Alert_State_EscalationLevel) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:             op,
		Alert_FieldPathValue: NewAlertFieldPathBuilder().State().EscalationLevel().WithValue(value),
	})
}

type filterCndBuilderStateAiAgentHandlingState struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStateAiAgentHandlingState) Eq(value Alert_State_AiHandlingState) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStateAiAgentHandlingState) Neq(value Alert_State_AiHandlingState) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStateAiAgentHandlingState) Gt(value Alert_State_AiHandlingState) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStateAiAgentHandlingState) Gte(value Alert_State_AiHandlingState) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStateAiAgentHandlingState) Lt(value Alert_State_AiHandlingState) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStateAiAgentHandlingState) Lte(value Alert_State_AiHandlingState) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStateAiAgentHandlingState) In(values []Alert_State_AiHandlingState) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().State().AiAgentHandlingState().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStateAiAgentHandlingState) NotIn(values []Alert_State_AiHandlingState) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().State().AiAgentHandlingState().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStateAiAgentHandlingState) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewAlertFieldPathBuilder().State().AiAgentHandlingState().FieldPath(),
	})
}

func (b *filterCndBuilderStateAiAgentHandlingState) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewAlertFieldPathBuilder().State().AiAgentHandlingState().FieldPath(),
	})
}

func (b *filterCndBuilderStateAiAgentHandlingState) compare(op gotenfilter.CompareOperator, value Alert_State_AiHandlingState) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:             op,
		Alert_FieldPathValue: NewAlertFieldPathBuilder().State().AiAgentHandlingState().WithValue(value),
	})
}

type filterCndBuilderStateAiAgentLastStateChangeTime struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStateAiAgentLastStateChangeTime) In(values []*timestamppb.Timestamp) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().State().AiAgentLastStateChangeTime().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStateAiAgentLastStateChangeTime) NotIn(values []*timestamppb.Timestamp) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().State().AiAgentLastStateChangeTime().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStateAiAgentLastStateChangeTime) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewAlertFieldPathBuilder().State().AiAgentLastStateChangeTime().FieldPath(),
	})
}

func (b *filterCndBuilderStateAiAgentLastStateChangeTime) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewAlertFieldPathBuilder().State().AiAgentLastStateChangeTime().FieldPath(),
	})
}

func (b *filterCndBuilderStateAiAgentLastStateChangeTime) compare(op gotenfilter.CompareOperator, value *timestamppb.Timestamp) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:             op,
		Alert_FieldPathValue: NewAlertFieldPathBuilder().State().AiAgentLastStateChangeTime().WithValue(value),
	})
}

type filterCndBuilderStateAiAgentDiagnosisNotes struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStateAiAgentDiagnosisNotes) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().State().AiAgentDiagnosisNotes().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStateAiAgentDiagnosisNotes) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().State().AiAgentDiagnosisNotes().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStateAiAgentDiagnosisNotes) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewAlertFieldPathBuilder().State().AiAgentDiagnosisNotes().FieldPath(),
	})
}

func (b *filterCndBuilderStateAiAgentDiagnosisNotes) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewAlertFieldPathBuilder().State().AiAgentDiagnosisNotes().FieldPath(),
	})
}

func (b *filterCndBuilderStateAiAgentDiagnosisNotes) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:             op,
		Alert_FieldPathValue: NewAlertFieldPathBuilder().State().AiAgentDiagnosisNotes().WithValue(value),
	})
}

type filterCndBuilderStateAiRemediationArg struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStateAiRemediationArg) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().State().AiRemediationArg().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStateAiRemediationArg) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().State().AiRemediationArg().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStateAiRemediationArg) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewAlertFieldPathBuilder().State().AiRemediationArg().FieldPath(),
	})
}

func (b *filterCndBuilderStateAiRemediationArg) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewAlertFieldPathBuilder().State().AiRemediationArg().FieldPath(),
	})
}

func (b *filterCndBuilderStateAiRemediationArg) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:             op,
		Alert_FieldPathValue: NewAlertFieldPathBuilder().State().AiRemediationArg().WithValue(value),
	})
}

type filterCndBuilderStateAiRemediation struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStateAiRemediation) Eq(value *rcommon.PolicySpec_AIAgentHandling_Remediation) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStateAiRemediation) Neq(value *rcommon.PolicySpec_AIAgentHandling_Remediation) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStateAiRemediation) Gt(value *rcommon.PolicySpec_AIAgentHandling_Remediation) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStateAiRemediation) Gte(value *rcommon.PolicySpec_AIAgentHandling_Remediation) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStateAiRemediation) Lt(value *rcommon.PolicySpec_AIAgentHandling_Remediation) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStateAiRemediation) Lte(value *rcommon.PolicySpec_AIAgentHandling_Remediation) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStateAiRemediation) In(values []*rcommon.PolicySpec_AIAgentHandling_Remediation) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().State().AiRemediation().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStateAiRemediation) NotIn(values []*rcommon.PolicySpec_AIAgentHandling_Remediation) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().State().AiRemediation().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStateAiRemediation) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewAlertFieldPathBuilder().State().AiRemediation().FieldPath(),
	})
}

func (b *filterCndBuilderStateAiRemediation) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewAlertFieldPathBuilder().State().AiRemediation().FieldPath(),
	})
}

func (b *filterCndBuilderStateAiRemediation) compare(op gotenfilter.CompareOperator, value *rcommon.PolicySpec_AIAgentHandling_Remediation) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:             op,
		Alert_FieldPathValue: NewAlertFieldPathBuilder().State().AiRemediation().WithValue(value),
	})
}

func (b *filterCndBuilderStateAiRemediation) FixInSsh() *filterCndBuilderStateAiRemediationFixInSsh {
	return &filterCndBuilderStateAiRemediationFixInSsh{builder: b.builder}
}

func (b *filterCndBuilderStateAiRemediation) Reboot() *filterCndBuilderStateAiRemediationReboot {
	return &filterCndBuilderStateAiRemediationReboot{builder: b.builder}
}

type filterCndBuilderStateAiRemediationFixInSsh struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStateAiRemediationFixInSsh) Eq(value *rcommon.PolicySpec_AIAgentHandling_Remediation_FixInSSH) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStateAiRemediationFixInSsh) Neq(value *rcommon.PolicySpec_AIAgentHandling_Remediation_FixInSSH) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStateAiRemediationFixInSsh) Gt(value *rcommon.PolicySpec_AIAgentHandling_Remediation_FixInSSH) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStateAiRemediationFixInSsh) Gte(value *rcommon.PolicySpec_AIAgentHandling_Remediation_FixInSSH) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStateAiRemediationFixInSsh) Lt(value *rcommon.PolicySpec_AIAgentHandling_Remediation_FixInSSH) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStateAiRemediationFixInSsh) Lte(value *rcommon.PolicySpec_AIAgentHandling_Remediation_FixInSSH) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStateAiRemediationFixInSsh) In(values []*rcommon.PolicySpec_AIAgentHandling_Remediation_FixInSSH) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().State().AiRemediation().FixInSsh().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStateAiRemediationFixInSsh) NotIn(values []*rcommon.PolicySpec_AIAgentHandling_Remediation_FixInSSH) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().State().AiRemediation().FixInSsh().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStateAiRemediationFixInSsh) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewAlertFieldPathBuilder().State().AiRemediation().FixInSsh().FieldPath(),
	})
}

func (b *filterCndBuilderStateAiRemediationFixInSsh) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewAlertFieldPathBuilder().State().AiRemediation().FixInSsh().FieldPath(),
	})
}

func (b *filterCndBuilderStateAiRemediationFixInSsh) compare(op gotenfilter.CompareOperator, value *rcommon.PolicySpec_AIAgentHandling_Remediation_FixInSSH) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:             op,
		Alert_FieldPathValue: NewAlertFieldPathBuilder().State().AiRemediation().FixInSsh().WithValue(value),
	})
}

type filterCndBuilderStateAiRemediationReboot struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStateAiRemediationReboot) Eq(value *rcommon.PolicySpec_AIAgentHandling_Remediation_Reboot) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStateAiRemediationReboot) Neq(value *rcommon.PolicySpec_AIAgentHandling_Remediation_Reboot) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStateAiRemediationReboot) Gt(value *rcommon.PolicySpec_AIAgentHandling_Remediation_Reboot) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStateAiRemediationReboot) Gte(value *rcommon.PolicySpec_AIAgentHandling_Remediation_Reboot) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStateAiRemediationReboot) Lt(value *rcommon.PolicySpec_AIAgentHandling_Remediation_Reboot) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStateAiRemediationReboot) Lte(value *rcommon.PolicySpec_AIAgentHandling_Remediation_Reboot) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStateAiRemediationReboot) In(values []*rcommon.PolicySpec_AIAgentHandling_Remediation_Reboot) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().State().AiRemediation().Reboot().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStateAiRemediationReboot) NotIn(values []*rcommon.PolicySpec_AIAgentHandling_Remediation_Reboot) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().State().AiRemediation().Reboot().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStateAiRemediationReboot) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewAlertFieldPathBuilder().State().AiRemediation().Reboot().FieldPath(),
	})
}

func (b *filterCndBuilderStateAiRemediationReboot) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewAlertFieldPathBuilder().State().AiRemediation().Reboot().FieldPath(),
	})
}

func (b *filterCndBuilderStateAiRemediationReboot) compare(op gotenfilter.CompareOperator, value *rcommon.PolicySpec_AIAgentHandling_Remediation_Reboot) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:             op,
		Alert_FieldPathValue: NewAlertFieldPathBuilder().State().AiRemediation().Reboot().WithValue(value),
	})
}

type filterCndBuilderStateOperatorHandlingState struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStateOperatorHandlingState) Eq(value Alert_State_OperatorHandlingState) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStateOperatorHandlingState) Neq(value Alert_State_OperatorHandlingState) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStateOperatorHandlingState) Gt(value Alert_State_OperatorHandlingState) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStateOperatorHandlingState) Gte(value Alert_State_OperatorHandlingState) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStateOperatorHandlingState) Lt(value Alert_State_OperatorHandlingState) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStateOperatorHandlingState) Lte(value Alert_State_OperatorHandlingState) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStateOperatorHandlingState) In(values []Alert_State_OperatorHandlingState) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().State().OperatorHandlingState().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStateOperatorHandlingState) NotIn(values []Alert_State_OperatorHandlingState) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().State().OperatorHandlingState().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStateOperatorHandlingState) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewAlertFieldPathBuilder().State().OperatorHandlingState().FieldPath(),
	})
}

func (b *filterCndBuilderStateOperatorHandlingState) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewAlertFieldPathBuilder().State().OperatorHandlingState().FieldPath(),
	})
}

func (b *filterCndBuilderStateOperatorHandlingState) compare(op gotenfilter.CompareOperator, value Alert_State_OperatorHandlingState) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:             op,
		Alert_FieldPathValue: NewAlertFieldPathBuilder().State().OperatorHandlingState().WithValue(value),
	})
}

type filterCndBuilderStateOperatorLastStateChangeTime struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStateOperatorLastStateChangeTime) In(values []*timestamppb.Timestamp) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().State().OperatorLastStateChangeTime().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStateOperatorLastStateChangeTime) NotIn(values []*timestamppb.Timestamp) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().State().OperatorLastStateChangeTime().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStateOperatorLastStateChangeTime) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewAlertFieldPathBuilder().State().OperatorLastStateChangeTime().FieldPath(),
	})
}

func (b *filterCndBuilderStateOperatorLastStateChangeTime) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewAlertFieldPathBuilder().State().OperatorLastStateChangeTime().FieldPath(),
	})
}

func (b *filterCndBuilderStateOperatorLastStateChangeTime) compare(op gotenfilter.CompareOperator, value *timestamppb.Timestamp) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:             op,
		Alert_FieldPathValue: NewAlertFieldPathBuilder().State().OperatorLastStateChangeTime().WithValue(value),
	})
}

type filterCndBuilderStateOperatorNotes struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStateOperatorNotes) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().State().OperatorNotes().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStateOperatorNotes) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().State().OperatorNotes().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStateOperatorNotes) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewAlertFieldPathBuilder().State().OperatorNotes().FieldPath(),
	})
}

func (b *filterCndBuilderStateOperatorNotes) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewAlertFieldPathBuilder().State().OperatorNotes().FieldPath(),
	})
}

func (b *filterCndBuilderStateOperatorNotes) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:             op,
		Alert_FieldPathValue: NewAlertFieldPathBuilder().State().OperatorNotes().WithValue(value),
	})
}

type filterCndBuilderStateLifecycleCompleted struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStateLifecycleCompleted) In(values []bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().State().LifecycleCompleted().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStateLifecycleCompleted) NotIn(values []bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().State().LifecycleCompleted().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStateLifecycleCompleted) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewAlertFieldPathBuilder().State().LifecycleCompleted().FieldPath(),
	})
}

func (b *filterCndBuilderStateLifecycleCompleted) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewAlertFieldPathBuilder().State().LifecycleCompleted().FieldPath(),
	})
}

func (b *filterCndBuilderStateLifecycleCompleted) compare(op gotenfilter.CompareOperator, value bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:             op,
		Alert_FieldPathValue: NewAlertFieldPathBuilder().State().LifecycleCompleted().WithValue(value),
	})
}

type filterCndBuilderInternal struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderInternal) Eq(value *Alert_Internal) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderInternal) Neq(value *Alert_Internal) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderInternal) Gt(value *Alert_Internal) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderInternal) Gte(value *Alert_Internal) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderInternal) Lt(value *Alert_Internal) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderInternal) Lte(value *Alert_Internal) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderInternal) In(values []*Alert_Internal) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().Internal().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderInternal) NotIn(values []*Alert_Internal) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().Internal().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderInternal) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewAlertFieldPathBuilder().Internal().FieldPath(),
	})
}

func (b *filterCndBuilderInternal) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewAlertFieldPathBuilder().Internal().FieldPath(),
	})
}

func (b *filterCndBuilderInternal) compare(op gotenfilter.CompareOperator, value *Alert_Internal) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:             op,
		Alert_FieldPathValue: NewAlertFieldPathBuilder().Internal().WithValue(value),
	})
}

func (b *filterCndBuilderInternal) AlertingLocation() *filterCndBuilderInternalAlertingLocation {
	return &filterCndBuilderInternalAlertingLocation{builder: b.builder}
}

type filterCndBuilderInternalAlertingLocation struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderInternalAlertingLocation) Eq(value rcommon.PolicySpec_ProcessingLocation) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderInternalAlertingLocation) Neq(value rcommon.PolicySpec_ProcessingLocation) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderInternalAlertingLocation) Gt(value rcommon.PolicySpec_ProcessingLocation) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderInternalAlertingLocation) Gte(value rcommon.PolicySpec_ProcessingLocation) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderInternalAlertingLocation) Lt(value rcommon.PolicySpec_ProcessingLocation) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderInternalAlertingLocation) Lte(value rcommon.PolicySpec_ProcessingLocation) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderInternalAlertingLocation) In(values []rcommon.PolicySpec_ProcessingLocation) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().Internal().AlertingLocation().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderInternalAlertingLocation) NotIn(values []rcommon.PolicySpec_ProcessingLocation) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Alert_FieldPathArrayOfValues: NewAlertFieldPathBuilder().Internal().AlertingLocation().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderInternalAlertingLocation) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewAlertFieldPathBuilder().Internal().AlertingLocation().FieldPath(),
	})
}

func (b *filterCndBuilderInternalAlertingLocation) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewAlertFieldPathBuilder().Internal().AlertingLocation().FieldPath(),
	})
}

func (b *filterCndBuilderInternalAlertingLocation) compare(op gotenfilter.CompareOperator, value rcommon.PolicySpec_ProcessingLocation) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:             op,
		Alert_FieldPathValue: NewAlertFieldPathBuilder().Internal().AlertingLocation().WithValue(value),
	})
}