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

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

package policy

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"
	notification_channel "github.com/cloudwan/edgelq-sdk/alerting/resources/v1/notification_channel"
	policy_template "github.com/cloudwan/edgelq-sdk/alerting/resources/v1/policy_template"
	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{}
	_ = &notification_channel.NotificationChannel{}
	_ = &policy_template.PolicyTemplate{}
	_ = &rcommon.LogCndSpec{}
	_ = 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 {
	_IsPolicyFilterBuilderOrCondition()
}

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

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

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

func (b *filterCndBuilder) SupportingDocs() *filterCndBuilderSupportingDocs {
	return &filterCndBuilderSupportingDocs{builder: b.builder}
}

func (b *filterCndBuilder) Spec() *filterCndBuilderSpec {
	return &filterCndBuilderSpec{builder: b.builder}
}

func (b *filterCndBuilder) TemplateSource() *filterCndBuilderTemplateSource {
	return &filterCndBuilderTemplateSource{builder: b.builder}
}

func (b *filterCndBuilder) NotificationChannels() *filterCndBuilderNotificationChannels {
	return &filterCndBuilderNotificationChannels{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{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Name().WithArrayOfValues(values),
	})
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func (b *filterCndBuilderMetadataOwnerReferences) compare(op gotenfilter.CompareOperator, value []*meta.OwnerReference) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Policy_FieldPathValue: NewPolicyFieldPathBuilder().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{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Metadata().OwnerReferences().Kind().WithArrayOfValues(values),
	})
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func (b *filterCndBuilderMetadataServicesAllowedServices) compare(op gotenfilter.CompareOperator, value []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Policy_FieldPathValue: NewPolicyFieldPathBuilder().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{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().DisplayName().WithArrayOfValues(values),
	})
}

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

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

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

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

type filterCndBuilderDescription struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderDescription) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Description().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderDescription) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Description().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderDescription) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPolicyFieldPathBuilder().Description().FieldPath(),
	})
}

func (b *filterCndBuilderDescription) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPolicyFieldPathBuilder().Description().FieldPath(),
	})
}

func (b *filterCndBuilderDescription) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Policy_FieldPathValue: NewPolicyFieldPathBuilder().Description().WithValue(value),
	})
}

type filterCndBuilderSupportingDocs struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSupportingDocs) In(values [][]*document.Reference) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().SupportingDocs().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSupportingDocs) NotIn(values [][]*document.Reference) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().SupportingDocs().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSupportingDocs) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPolicyFieldPathBuilder().SupportingDocs().FieldPath(),
	})
}

func (b *filterCndBuilderSupportingDocs) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPolicyFieldPathBuilder().SupportingDocs().FieldPath(),
	})
}

func (b *filterCndBuilderSupportingDocs) Contains(value *document.Reference) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewPolicyFieldPathBuilder().SupportingDocs().FieldPath(),
		Value:     NewPolicyFieldPathBuilder().SupportingDocs().WithItemValue(value),
	})
}

func (b *filterCndBuilderSupportingDocs) ContainsAnyOf(values []*document.Reference) *FilterBuilder {
	pathSelector := NewPolicyFieldPathBuilder().SupportingDocs()
	itemValues := make([]Policy_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewPolicyFieldPathBuilder().SupportingDocs().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderSupportingDocs) ContainsAll(values []*document.Reference) *FilterBuilder {
	pathSelector := NewPolicyFieldPathBuilder().SupportingDocs()
	itemValues := make([]Policy_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewPolicyFieldPathBuilder().SupportingDocs().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderSupportingDocs) compare(op gotenfilter.CompareOperator, value []*document.Reference) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Policy_FieldPathValue: NewPolicyFieldPathBuilder().SupportingDocs().WithValue(value),
	})
}

type filterCndBuilderSpec struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpec) In(values []*rcommon.PolicySpec) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpec) NotIn(values []*rcommon.PolicySpec) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpec) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPolicyFieldPathBuilder().Spec().FieldPath(),
	})
}

func (b *filterCndBuilderSpec) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPolicyFieldPathBuilder().Spec().FieldPath(),
	})
}

func (b *filterCndBuilderSpec) compare(op gotenfilter.CompareOperator, value *rcommon.PolicySpec) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Policy_FieldPathValue: NewPolicyFieldPathBuilder().Spec().WithValue(value),
	})
}

func (b *filterCndBuilderSpec) Enabled() *filterCndBuilderSpecEnabled {
	return &filterCndBuilderSpecEnabled{builder: b.builder}
}

func (b *filterCndBuilderSpec) ProcessingLocation() *filterCndBuilderSpecProcessingLocation {
	return &filterCndBuilderSpecProcessingLocation{builder: b.builder}
}

func (b *filterCndBuilderSpec) ResourceIdentity() *filterCndBuilderSpecResourceIdentity {
	return &filterCndBuilderSpecResourceIdentity{builder: b.builder}
}

func (b *filterCndBuilderSpec) SupportingQueries() *filterCndBuilderSpecSupportingQueries {
	return &filterCndBuilderSpecSupportingQueries{builder: b.builder}
}

func (b *filterCndBuilderSpec) AiAgent() *filterCndBuilderSpecAiAgent {
	return &filterCndBuilderSpecAiAgent{builder: b.builder}
}

type filterCndBuilderSpecEnabled struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecEnabled) In(values []bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().Enabled().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecEnabled) NotIn(values []bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().Enabled().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecEnabled) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPolicyFieldPathBuilder().Spec().Enabled().FieldPath(),
	})
}

func (b *filterCndBuilderSpecEnabled) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPolicyFieldPathBuilder().Spec().Enabled().FieldPath(),
	})
}

func (b *filterCndBuilderSpecEnabled) compare(op gotenfilter.CompareOperator, value bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Policy_FieldPathValue: NewPolicyFieldPathBuilder().Spec().Enabled().WithValue(value),
	})
}

type filterCndBuilderSpecProcessingLocation struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecProcessingLocation) In(values []rcommon.PolicySpec_ProcessingLocation) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().ProcessingLocation().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecProcessingLocation) NotIn(values []rcommon.PolicySpec_ProcessingLocation) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().ProcessingLocation().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecProcessingLocation) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPolicyFieldPathBuilder().Spec().ProcessingLocation().FieldPath(),
	})
}

func (b *filterCndBuilderSpecProcessingLocation) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPolicyFieldPathBuilder().Spec().ProcessingLocation().FieldPath(),
	})
}

func (b *filterCndBuilderSpecProcessingLocation) compare(op gotenfilter.CompareOperator, value rcommon.PolicySpec_ProcessingLocation) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Policy_FieldPathValue: NewPolicyFieldPathBuilder().Spec().ProcessingLocation().WithValue(value),
	})
}

type filterCndBuilderSpecResourceIdentity struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecResourceIdentity) In(values []*rcommon.PolicySpec_ResourceIdentity) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().ResourceIdentity().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecResourceIdentity) NotIn(values []*rcommon.PolicySpec_ResourceIdentity) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().ResourceIdentity().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecResourceIdentity) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPolicyFieldPathBuilder().Spec().ResourceIdentity().FieldPath(),
	})
}

func (b *filterCndBuilderSpecResourceIdentity) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPolicyFieldPathBuilder().Spec().ResourceIdentity().FieldPath(),
	})
}

func (b *filterCndBuilderSpecResourceIdentity) compare(op gotenfilter.CompareOperator, value *rcommon.PolicySpec_ResourceIdentity) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Policy_FieldPathValue: NewPolicyFieldPathBuilder().Spec().ResourceIdentity().WithValue(value),
	})
}

func (b *filterCndBuilderSpecResourceIdentity) AlertingResource() *filterCndBuilderSpecResourceIdentityAlertingResource {
	return &filterCndBuilderSpecResourceIdentityAlertingResource{builder: b.builder}
}

func (b *filterCndBuilderSpecResourceIdentity) Labels() *filterCndBuilderSpecResourceIdentityLabels {
	return &filterCndBuilderSpecResourceIdentityLabels{builder: b.builder}
}

func (b *filterCndBuilderSpecResourceIdentity) NamePatterns() *filterCndBuilderSpecResourceIdentityNamePatterns {
	return &filterCndBuilderSpecResourceIdentityNamePatterns{builder: b.builder}
}

type filterCndBuilderSpecResourceIdentityAlertingResource struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderSpecResourceIdentityAlertingResource) Eq(value *meta_resource.Reference) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderSpecResourceIdentityAlertingResource) Neq(value *meta_resource.Reference) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderSpecResourceIdentityAlertingResource) Gt(value *meta_resource.Reference) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderSpecResourceIdentityAlertingResource) Gte(value *meta_resource.Reference) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderSpecResourceIdentityAlertingResource) Lt(value *meta_resource.Reference) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderSpecResourceIdentityAlertingResource) Lte(value *meta_resource.Reference) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderSpecResourceIdentityAlertingResource) In(values []*meta_resource.Reference) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().ResourceIdentity().AlertingResource().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecResourceIdentityAlertingResource) NotIn(values []*meta_resource.Reference) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().ResourceIdentity().AlertingResource().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecResourceIdentityAlertingResource) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPolicyFieldPathBuilder().Spec().ResourceIdentity().AlertingResource().FieldPath(),
	})
}

func (b *filterCndBuilderSpecResourceIdentityAlertingResource) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPolicyFieldPathBuilder().Spec().ResourceIdentity().AlertingResource().FieldPath(),
	})
}

func (b *filterCndBuilderSpecResourceIdentityAlertingResource) compare(op gotenfilter.CompareOperator, value *meta_resource.Reference) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Policy_FieldPathValue: NewPolicyFieldPathBuilder().Spec().ResourceIdentity().AlertingResource().WithValue(value),
	})
}

type filterCndBuilderSpecResourceIdentityLabels struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderSpecResourceIdentityLabels) Eq(value []*rcommon.PolicySpec_ResourceIdentity_LabelInfo) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderSpecResourceIdentityLabels) Neq(value []*rcommon.PolicySpec_ResourceIdentity_LabelInfo) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderSpecResourceIdentityLabels) Gt(value []*rcommon.PolicySpec_ResourceIdentity_LabelInfo) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderSpecResourceIdentityLabels) Gte(value []*rcommon.PolicySpec_ResourceIdentity_LabelInfo) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderSpecResourceIdentityLabels) Lt(value []*rcommon.PolicySpec_ResourceIdentity_LabelInfo) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderSpecResourceIdentityLabels) Lte(value []*rcommon.PolicySpec_ResourceIdentity_LabelInfo) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderSpecResourceIdentityLabels) In(values [][]*rcommon.PolicySpec_ResourceIdentity_LabelInfo) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().ResourceIdentity().Labels().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecResourceIdentityLabels) NotIn(values [][]*rcommon.PolicySpec_ResourceIdentity_LabelInfo) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().ResourceIdentity().Labels().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecResourceIdentityLabels) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPolicyFieldPathBuilder().Spec().ResourceIdentity().Labels().FieldPath(),
	})
}

func (b *filterCndBuilderSpecResourceIdentityLabels) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPolicyFieldPathBuilder().Spec().ResourceIdentity().Labels().FieldPath(),
	})
}

func (b *filterCndBuilderSpecResourceIdentityLabels) Contains(value *rcommon.PolicySpec_ResourceIdentity_LabelInfo) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewPolicyFieldPathBuilder().Spec().ResourceIdentity().Labels().FieldPath(),
		Value:     NewPolicyFieldPathBuilder().Spec().ResourceIdentity().Labels().WithItemValue(value),
	})
}

func (b *filterCndBuilderSpecResourceIdentityLabels) ContainsAnyOf(values []*rcommon.PolicySpec_ResourceIdentity_LabelInfo) *FilterBuilder {
	pathSelector := NewPolicyFieldPathBuilder().Spec().ResourceIdentity().Labels()
	itemValues := make([]Policy_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewPolicyFieldPathBuilder().Spec().ResourceIdentity().Labels().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderSpecResourceIdentityLabels) ContainsAll(values []*rcommon.PolicySpec_ResourceIdentity_LabelInfo) *FilterBuilder {
	pathSelector := NewPolicyFieldPathBuilder().Spec().ResourceIdentity().Labels()
	itemValues := make([]Policy_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewPolicyFieldPathBuilder().Spec().ResourceIdentity().Labels().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderSpecResourceIdentityLabels) compare(op gotenfilter.CompareOperator, value []*rcommon.PolicySpec_ResourceIdentity_LabelInfo) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Policy_FieldPathValue: NewPolicyFieldPathBuilder().Spec().ResourceIdentity().Labels().WithValue(value),
	})
}

func (b *filterCndBuilderSpecResourceIdentityLabels) Key() *filterCndBuilderSpecResourceIdentityLabelsKey {
	return &filterCndBuilderSpecResourceIdentityLabelsKey{builder: b.builder}
}

func (b *filterCndBuilderSpecResourceIdentityLabels) Contexts() *filterCndBuilderSpecResourceIdentityLabelsContexts {
	return &filterCndBuilderSpecResourceIdentityLabelsContexts{builder: b.builder}
}

func (b *filterCndBuilderSpecResourceIdentityLabels) MappedNameSegment() *filterCndBuilderSpecResourceIdentityLabelsMappedNameSegment {
	return &filterCndBuilderSpecResourceIdentityLabelsMappedNameSegment{builder: b.builder}
}

type filterCndBuilderSpecResourceIdentityLabelsKey struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecResourceIdentityLabelsKey) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().ResourceIdentity().Labels().Key().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecResourceIdentityLabelsKey) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().ResourceIdentity().Labels().Key().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecResourceIdentityLabelsKey) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPolicyFieldPathBuilder().Spec().ResourceIdentity().Labels().Key().FieldPath(),
	})
}

func (b *filterCndBuilderSpecResourceIdentityLabelsKey) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPolicyFieldPathBuilder().Spec().ResourceIdentity().Labels().Key().FieldPath(),
	})
}

func (b *filterCndBuilderSpecResourceIdentityLabelsKey) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Policy_FieldPathValue: NewPolicyFieldPathBuilder().Spec().ResourceIdentity().Labels().Key().WithValue(value),
	})
}

type filterCndBuilderSpecResourceIdentityLabelsContexts struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderSpecResourceIdentityLabelsContexts) Eq(value []rcommon.PolicySpec_ResourceIdentity_LabelInfo_UsageContext) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderSpecResourceIdentityLabelsContexts) Neq(value []rcommon.PolicySpec_ResourceIdentity_LabelInfo_UsageContext) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderSpecResourceIdentityLabelsContexts) Gt(value []rcommon.PolicySpec_ResourceIdentity_LabelInfo_UsageContext) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderSpecResourceIdentityLabelsContexts) Gte(value []rcommon.PolicySpec_ResourceIdentity_LabelInfo_UsageContext) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderSpecResourceIdentityLabelsContexts) Lt(value []rcommon.PolicySpec_ResourceIdentity_LabelInfo_UsageContext) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderSpecResourceIdentityLabelsContexts) Lte(value []rcommon.PolicySpec_ResourceIdentity_LabelInfo_UsageContext) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderSpecResourceIdentityLabelsContexts) In(values [][]rcommon.PolicySpec_ResourceIdentity_LabelInfo_UsageContext) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().ResourceIdentity().Labels().Contexts().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecResourceIdentityLabelsContexts) NotIn(values [][]rcommon.PolicySpec_ResourceIdentity_LabelInfo_UsageContext) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().ResourceIdentity().Labels().Contexts().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecResourceIdentityLabelsContexts) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPolicyFieldPathBuilder().Spec().ResourceIdentity().Labels().Contexts().FieldPath(),
	})
}

func (b *filterCndBuilderSpecResourceIdentityLabelsContexts) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPolicyFieldPathBuilder().Spec().ResourceIdentity().Labels().Contexts().FieldPath(),
	})
}

func (b *filterCndBuilderSpecResourceIdentityLabelsContexts) Contains(value rcommon.PolicySpec_ResourceIdentity_LabelInfo_UsageContext) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewPolicyFieldPathBuilder().Spec().ResourceIdentity().Labels().Contexts().FieldPath(),
		Value:     NewPolicyFieldPathBuilder().Spec().ResourceIdentity().Labels().Contexts().WithItemValue(value),
	})
}

func (b *filterCndBuilderSpecResourceIdentityLabelsContexts) ContainsAnyOf(values []rcommon.PolicySpec_ResourceIdentity_LabelInfo_UsageContext) *FilterBuilder {
	pathSelector := NewPolicyFieldPathBuilder().Spec().ResourceIdentity().Labels().Contexts()
	itemValues := make([]Policy_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewPolicyFieldPathBuilder().Spec().ResourceIdentity().Labels().Contexts().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderSpecResourceIdentityLabelsContexts) ContainsAll(values []rcommon.PolicySpec_ResourceIdentity_LabelInfo_UsageContext) *FilterBuilder {
	pathSelector := NewPolicyFieldPathBuilder().Spec().ResourceIdentity().Labels().Contexts()
	itemValues := make([]Policy_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewPolicyFieldPathBuilder().Spec().ResourceIdentity().Labels().Contexts().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderSpecResourceIdentityLabelsContexts) compare(op gotenfilter.CompareOperator, value []rcommon.PolicySpec_ResourceIdentity_LabelInfo_UsageContext) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Policy_FieldPathValue: NewPolicyFieldPathBuilder().Spec().ResourceIdentity().Labels().Contexts().WithValue(value),
	})
}

type filterCndBuilderSpecResourceIdentityLabelsMappedNameSegment struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecResourceIdentityLabelsMappedNameSegment) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().ResourceIdentity().Labels().MappedNameSegment().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecResourceIdentityLabelsMappedNameSegment) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().ResourceIdentity().Labels().MappedNameSegment().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecResourceIdentityLabelsMappedNameSegment) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPolicyFieldPathBuilder().Spec().ResourceIdentity().Labels().MappedNameSegment().FieldPath(),
	})
}

func (b *filterCndBuilderSpecResourceIdentityLabelsMappedNameSegment) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPolicyFieldPathBuilder().Spec().ResourceIdentity().Labels().MappedNameSegment().FieldPath(),
	})
}

func (b *filterCndBuilderSpecResourceIdentityLabelsMappedNameSegment) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Policy_FieldPathValue: NewPolicyFieldPathBuilder().Spec().ResourceIdentity().Labels().MappedNameSegment().WithValue(value),
	})
}

type filterCndBuilderSpecResourceIdentityNamePatterns struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecResourceIdentityNamePatterns) In(values [][]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().ResourceIdentity().NamePatterns().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecResourceIdentityNamePatterns) NotIn(values [][]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().ResourceIdentity().NamePatterns().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecResourceIdentityNamePatterns) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPolicyFieldPathBuilder().Spec().ResourceIdentity().NamePatterns().FieldPath(),
	})
}

func (b *filterCndBuilderSpecResourceIdentityNamePatterns) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPolicyFieldPathBuilder().Spec().ResourceIdentity().NamePatterns().FieldPath(),
	})
}

func (b *filterCndBuilderSpecResourceIdentityNamePatterns) Contains(value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewPolicyFieldPathBuilder().Spec().ResourceIdentity().NamePatterns().FieldPath(),
		Value:     NewPolicyFieldPathBuilder().Spec().ResourceIdentity().NamePatterns().WithItemValue(value),
	})
}

func (b *filterCndBuilderSpecResourceIdentityNamePatterns) ContainsAnyOf(values []string) *FilterBuilder {
	pathSelector := NewPolicyFieldPathBuilder().Spec().ResourceIdentity().NamePatterns()
	itemValues := make([]Policy_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewPolicyFieldPathBuilder().Spec().ResourceIdentity().NamePatterns().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderSpecResourceIdentityNamePatterns) ContainsAll(values []string) *FilterBuilder {
	pathSelector := NewPolicyFieldPathBuilder().Spec().ResourceIdentity().NamePatterns()
	itemValues := make([]Policy_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewPolicyFieldPathBuilder().Spec().ResourceIdentity().NamePatterns().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderSpecResourceIdentityNamePatterns) compare(op gotenfilter.CompareOperator, value []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Policy_FieldPathValue: NewPolicyFieldPathBuilder().Spec().ResourceIdentity().NamePatterns().WithValue(value),
	})
}

type filterCndBuilderSpecSupportingQueries struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderSpecSupportingQueries) Eq(value []*rcommon.PolicySpec_SupportingAlertQuery) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderSpecSupportingQueries) Neq(value []*rcommon.PolicySpec_SupportingAlertQuery) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderSpecSupportingQueries) Gt(value []*rcommon.PolicySpec_SupportingAlertQuery) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderSpecSupportingQueries) Gte(value []*rcommon.PolicySpec_SupportingAlertQuery) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderSpecSupportingQueries) Lt(value []*rcommon.PolicySpec_SupportingAlertQuery) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderSpecSupportingQueries) Lte(value []*rcommon.PolicySpec_SupportingAlertQuery) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderSpecSupportingQueries) In(values [][]*rcommon.PolicySpec_SupportingAlertQuery) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().SupportingQueries().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecSupportingQueries) NotIn(values [][]*rcommon.PolicySpec_SupportingAlertQuery) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().SupportingQueries().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecSupportingQueries) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPolicyFieldPathBuilder().Spec().SupportingQueries().FieldPath(),
	})
}

func (b *filterCndBuilderSpecSupportingQueries) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPolicyFieldPathBuilder().Spec().SupportingQueries().FieldPath(),
	})
}

func (b *filterCndBuilderSpecSupportingQueries) Contains(value *rcommon.PolicySpec_SupportingAlertQuery) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewPolicyFieldPathBuilder().Spec().SupportingQueries().FieldPath(),
		Value:     NewPolicyFieldPathBuilder().Spec().SupportingQueries().WithItemValue(value),
	})
}

func (b *filterCndBuilderSpecSupportingQueries) ContainsAnyOf(values []*rcommon.PolicySpec_SupportingAlertQuery) *FilterBuilder {
	pathSelector := NewPolicyFieldPathBuilder().Spec().SupportingQueries()
	itemValues := make([]Policy_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewPolicyFieldPathBuilder().Spec().SupportingQueries().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderSpecSupportingQueries) ContainsAll(values []*rcommon.PolicySpec_SupportingAlertQuery) *FilterBuilder {
	pathSelector := NewPolicyFieldPathBuilder().Spec().SupportingQueries()
	itemValues := make([]Policy_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewPolicyFieldPathBuilder().Spec().SupportingQueries().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderSpecSupportingQueries) compare(op gotenfilter.CompareOperator, value []*rcommon.PolicySpec_SupportingAlertQuery) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Policy_FieldPathValue: NewPolicyFieldPathBuilder().Spec().SupportingQueries().WithValue(value),
	})
}

func (b *filterCndBuilderSpecSupportingQueries) TsQuery() *filterCndBuilderSpecSupportingQueriesTsQuery {
	return &filterCndBuilderSpecSupportingQueriesTsQuery{builder: b.builder}
}

func (b *filterCndBuilderSpecSupportingQueries) LogQuery() *filterCndBuilderSpecSupportingQueriesLogQuery {
	return &filterCndBuilderSpecSupportingQueriesLogQuery{builder: b.builder}
}

func (b *filterCndBuilderSpecSupportingQueries) RestGetQuery() *filterCndBuilderSpecSupportingQueriesRestGetQuery {
	return &filterCndBuilderSpecSupportingQueriesRestGetQuery{builder: b.builder}
}

func (b *filterCndBuilderSpecSupportingQueries) RestListQuery() *filterCndBuilderSpecSupportingQueriesRestListQuery {
	return &filterCndBuilderSpecSupportingQueriesRestListQuery{builder: b.builder}
}

type filterCndBuilderSpecSupportingQueriesTsQuery struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecSupportingQueriesTsQuery) In(values []*rcommon.PolicySpec_SupportingAlertQuery_TsQuery) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().SupportingQueries().TsQuery().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesTsQuery) NotIn(values []*rcommon.PolicySpec_SupportingAlertQuery_TsQuery) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().SupportingQueries().TsQuery().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesTsQuery) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPolicyFieldPathBuilder().Spec().SupportingQueries().TsQuery().FieldPath(),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesTsQuery) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPolicyFieldPathBuilder().Spec().SupportingQueries().TsQuery().FieldPath(),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesTsQuery) compare(op gotenfilter.CompareOperator, value *rcommon.PolicySpec_SupportingAlertQuery_TsQuery) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Policy_FieldPathValue: NewPolicyFieldPathBuilder().Spec().SupportingQueries().TsQuery().WithValue(value),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesTsQuery) Description() *filterCndBuilderSpecSupportingQueriesTsQueryDescription {
	return &filterCndBuilderSpecSupportingQueriesTsQueryDescription{builder: b.builder}
}

func (b *filterCndBuilderSpecSupportingQueriesTsQuery) FilterTemplate() *filterCndBuilderSpecSupportingQueriesTsQueryFilterTemplate {
	return &filterCndBuilderSpecSupportingQueriesTsQueryFilterTemplate{builder: b.builder}
}

func (b *filterCndBuilderSpecSupportingQueriesTsQuery) Aggregation() *filterCndBuilderSpecSupportingQueriesTsQueryAggregation {
	return &filterCndBuilderSpecSupportingQueriesTsQueryAggregation{builder: b.builder}
}

type filterCndBuilderSpecSupportingQueriesTsQueryDescription struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecSupportingQueriesTsQueryDescription) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().SupportingQueries().TsQuery().Description().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesTsQueryDescription) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().SupportingQueries().TsQuery().Description().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesTsQueryDescription) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPolicyFieldPathBuilder().Spec().SupportingQueries().TsQuery().Description().FieldPath(),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesTsQueryDescription) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPolicyFieldPathBuilder().Spec().SupportingQueries().TsQuery().Description().FieldPath(),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesTsQueryDescription) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Policy_FieldPathValue: NewPolicyFieldPathBuilder().Spec().SupportingQueries().TsQuery().Description().WithValue(value),
	})
}

type filterCndBuilderSpecSupportingQueriesTsQueryFilterTemplate struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecSupportingQueriesTsQueryFilterTemplate) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().SupportingQueries().TsQuery().FilterTemplate().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesTsQueryFilterTemplate) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().SupportingQueries().TsQuery().FilterTemplate().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesTsQueryFilterTemplate) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPolicyFieldPathBuilder().Spec().SupportingQueries().TsQuery().FilterTemplate().FieldPath(),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesTsQueryFilterTemplate) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPolicyFieldPathBuilder().Spec().SupportingQueries().TsQuery().FilterTemplate().FieldPath(),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesTsQueryFilterTemplate) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Policy_FieldPathValue: NewPolicyFieldPathBuilder().Spec().SupportingQueries().TsQuery().FilterTemplate().WithValue(value),
	})
}

type filterCndBuilderSpecSupportingQueriesTsQueryAggregation struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecSupportingQueriesTsQueryAggregation) In(values []*monitoring_common.Aggregation) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().SupportingQueries().TsQuery().Aggregation().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesTsQueryAggregation) NotIn(values []*monitoring_common.Aggregation) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().SupportingQueries().TsQuery().Aggregation().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesTsQueryAggregation) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPolicyFieldPathBuilder().Spec().SupportingQueries().TsQuery().Aggregation().FieldPath(),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesTsQueryAggregation) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPolicyFieldPathBuilder().Spec().SupportingQueries().TsQuery().Aggregation().FieldPath(),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesTsQueryAggregation) compare(op gotenfilter.CompareOperator, value *monitoring_common.Aggregation) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Policy_FieldPathValue: NewPolicyFieldPathBuilder().Spec().SupportingQueries().TsQuery().Aggregation().WithValue(value),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesTsQueryAggregation) AlignmentPeriod() *filterCndBuilderSpecSupportingQueriesTsQueryAggregationAlignmentPeriod {
	return &filterCndBuilderSpecSupportingQueriesTsQueryAggregationAlignmentPeriod{builder: b.builder}
}

func (b *filterCndBuilderSpecSupportingQueriesTsQueryAggregation) PerSeriesAligner() *filterCndBuilderSpecSupportingQueriesTsQueryAggregationPerSeriesAligner {
	return &filterCndBuilderSpecSupportingQueriesTsQueryAggregationPerSeriesAligner{builder: b.builder}
}

func (b *filterCndBuilderSpecSupportingQueriesTsQueryAggregation) CrossSeriesReducer() *filterCndBuilderSpecSupportingQueriesTsQueryAggregationCrossSeriesReducer {
	return &filterCndBuilderSpecSupportingQueriesTsQueryAggregationCrossSeriesReducer{builder: b.builder}
}

func (b *filterCndBuilderSpecSupportingQueriesTsQueryAggregation) GroupByFields() *filterCndBuilderSpecSupportingQueriesTsQueryAggregationGroupByFields {
	return &filterCndBuilderSpecSupportingQueriesTsQueryAggregationGroupByFields{builder: b.builder}
}

type filterCndBuilderSpecSupportingQueriesTsQueryAggregationAlignmentPeriod struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecSupportingQueriesTsQueryAggregationAlignmentPeriod) In(values []*durationpb.Duration) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().SupportingQueries().TsQuery().Aggregation().AlignmentPeriod().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesTsQueryAggregationAlignmentPeriod) NotIn(values []*durationpb.Duration) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().SupportingQueries().TsQuery().Aggregation().AlignmentPeriod().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesTsQueryAggregationAlignmentPeriod) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPolicyFieldPathBuilder().Spec().SupportingQueries().TsQuery().Aggregation().AlignmentPeriod().FieldPath(),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesTsQueryAggregationAlignmentPeriod) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPolicyFieldPathBuilder().Spec().SupportingQueries().TsQuery().Aggregation().AlignmentPeriod().FieldPath(),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesTsQueryAggregationAlignmentPeriod) compare(op gotenfilter.CompareOperator, value *durationpb.Duration) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Policy_FieldPathValue: NewPolicyFieldPathBuilder().Spec().SupportingQueries().TsQuery().Aggregation().AlignmentPeriod().WithValue(value),
	})
}

type filterCndBuilderSpecSupportingQueriesTsQueryAggregationPerSeriesAligner struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecSupportingQueriesTsQueryAggregationPerSeriesAligner) In(values []monitoring_common.Aggregation_Aligner) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().SupportingQueries().TsQuery().Aggregation().PerSeriesAligner().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesTsQueryAggregationPerSeriesAligner) NotIn(values []monitoring_common.Aggregation_Aligner) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().SupportingQueries().TsQuery().Aggregation().PerSeriesAligner().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesTsQueryAggregationPerSeriesAligner) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPolicyFieldPathBuilder().Spec().SupportingQueries().TsQuery().Aggregation().PerSeriesAligner().FieldPath(),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesTsQueryAggregationPerSeriesAligner) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPolicyFieldPathBuilder().Spec().SupportingQueries().TsQuery().Aggregation().PerSeriesAligner().FieldPath(),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesTsQueryAggregationPerSeriesAligner) compare(op gotenfilter.CompareOperator, value monitoring_common.Aggregation_Aligner) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Policy_FieldPathValue: NewPolicyFieldPathBuilder().Spec().SupportingQueries().TsQuery().Aggregation().PerSeriesAligner().WithValue(value),
	})
}

type filterCndBuilderSpecSupportingQueriesTsQueryAggregationCrossSeriesReducer struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecSupportingQueriesTsQueryAggregationCrossSeriesReducer) In(values []monitoring_common.Aggregation_Reducer) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().SupportingQueries().TsQuery().Aggregation().CrossSeriesReducer().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesTsQueryAggregationCrossSeriesReducer) NotIn(values []monitoring_common.Aggregation_Reducer) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().SupportingQueries().TsQuery().Aggregation().CrossSeriesReducer().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesTsQueryAggregationCrossSeriesReducer) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPolicyFieldPathBuilder().Spec().SupportingQueries().TsQuery().Aggregation().CrossSeriesReducer().FieldPath(),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesTsQueryAggregationCrossSeriesReducer) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPolicyFieldPathBuilder().Spec().SupportingQueries().TsQuery().Aggregation().CrossSeriesReducer().FieldPath(),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesTsQueryAggregationCrossSeriesReducer) compare(op gotenfilter.CompareOperator, value monitoring_common.Aggregation_Reducer) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Policy_FieldPathValue: NewPolicyFieldPathBuilder().Spec().SupportingQueries().TsQuery().Aggregation().CrossSeriesReducer().WithValue(value),
	})
}

type filterCndBuilderSpecSupportingQueriesTsQueryAggregationGroupByFields struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecSupportingQueriesTsQueryAggregationGroupByFields) In(values [][]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().SupportingQueries().TsQuery().Aggregation().GroupByFields().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesTsQueryAggregationGroupByFields) NotIn(values [][]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().SupportingQueries().TsQuery().Aggregation().GroupByFields().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesTsQueryAggregationGroupByFields) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPolicyFieldPathBuilder().Spec().SupportingQueries().TsQuery().Aggregation().GroupByFields().FieldPath(),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesTsQueryAggregationGroupByFields) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPolicyFieldPathBuilder().Spec().SupportingQueries().TsQuery().Aggregation().GroupByFields().FieldPath(),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesTsQueryAggregationGroupByFields) Contains(value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewPolicyFieldPathBuilder().Spec().SupportingQueries().TsQuery().Aggregation().GroupByFields().FieldPath(),
		Value:     NewPolicyFieldPathBuilder().Spec().SupportingQueries().TsQuery().Aggregation().GroupByFields().WithItemValue(value),
	})
}

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

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

func (b *filterCndBuilderSpecSupportingQueriesTsQueryAggregationGroupByFields) compare(op gotenfilter.CompareOperator, value []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Policy_FieldPathValue: NewPolicyFieldPathBuilder().Spec().SupportingQueries().TsQuery().Aggregation().GroupByFields().WithValue(value),
	})
}

type filterCndBuilderSpecSupportingQueriesLogQuery struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecSupportingQueriesLogQuery) In(values []*rcommon.PolicySpec_SupportingAlertQuery_LogQuery) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().SupportingQueries().LogQuery().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesLogQuery) NotIn(values []*rcommon.PolicySpec_SupportingAlertQuery_LogQuery) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().SupportingQueries().LogQuery().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesLogQuery) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPolicyFieldPathBuilder().Spec().SupportingQueries().LogQuery().FieldPath(),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesLogQuery) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPolicyFieldPathBuilder().Spec().SupportingQueries().LogQuery().FieldPath(),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesLogQuery) compare(op gotenfilter.CompareOperator, value *rcommon.PolicySpec_SupportingAlertQuery_LogQuery) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Policy_FieldPathValue: NewPolicyFieldPathBuilder().Spec().SupportingQueries().LogQuery().WithValue(value),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesLogQuery) Description() *filterCndBuilderSpecSupportingQueriesLogQueryDescription {
	return &filterCndBuilderSpecSupportingQueriesLogQueryDescription{builder: b.builder}
}

func (b *filterCndBuilderSpecSupportingQueriesLogQuery) FilterTemplate() *filterCndBuilderSpecSupportingQueriesLogQueryFilterTemplate {
	return &filterCndBuilderSpecSupportingQueriesLogQueryFilterTemplate{builder: b.builder}
}

type filterCndBuilderSpecSupportingQueriesLogQueryDescription struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecSupportingQueriesLogQueryDescription) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().SupportingQueries().LogQuery().Description().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesLogQueryDescription) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().SupportingQueries().LogQuery().Description().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesLogQueryDescription) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPolicyFieldPathBuilder().Spec().SupportingQueries().LogQuery().Description().FieldPath(),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesLogQueryDescription) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPolicyFieldPathBuilder().Spec().SupportingQueries().LogQuery().Description().FieldPath(),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesLogQueryDescription) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Policy_FieldPathValue: NewPolicyFieldPathBuilder().Spec().SupportingQueries().LogQuery().Description().WithValue(value),
	})
}

type filterCndBuilderSpecSupportingQueriesLogQueryFilterTemplate struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecSupportingQueriesLogQueryFilterTemplate) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().SupportingQueries().LogQuery().FilterTemplate().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesLogQueryFilterTemplate) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().SupportingQueries().LogQuery().FilterTemplate().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesLogQueryFilterTemplate) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPolicyFieldPathBuilder().Spec().SupportingQueries().LogQuery().FilterTemplate().FieldPath(),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesLogQueryFilterTemplate) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPolicyFieldPathBuilder().Spec().SupportingQueries().LogQuery().FilterTemplate().FieldPath(),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesLogQueryFilterTemplate) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Policy_FieldPathValue: NewPolicyFieldPathBuilder().Spec().SupportingQueries().LogQuery().FilterTemplate().WithValue(value),
	})
}

type filterCndBuilderSpecSupportingQueriesRestGetQuery struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecSupportingQueriesRestGetQuery) In(values []*rcommon.PolicySpec_SupportingAlertQuery_RestGetQuery) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().SupportingQueries().RestGetQuery().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesRestGetQuery) NotIn(values []*rcommon.PolicySpec_SupportingAlertQuery_RestGetQuery) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().SupportingQueries().RestGetQuery().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesRestGetQuery) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPolicyFieldPathBuilder().Spec().SupportingQueries().RestGetQuery().FieldPath(),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesRestGetQuery) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPolicyFieldPathBuilder().Spec().SupportingQueries().RestGetQuery().FieldPath(),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesRestGetQuery) compare(op gotenfilter.CompareOperator, value *rcommon.PolicySpec_SupportingAlertQuery_RestGetQuery) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Policy_FieldPathValue: NewPolicyFieldPathBuilder().Spec().SupportingQueries().RestGetQuery().WithValue(value),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesRestGetQuery) Description() *filterCndBuilderSpecSupportingQueriesRestGetQueryDescription {
	return &filterCndBuilderSpecSupportingQueriesRestGetQueryDescription{builder: b.builder}
}

func (b *filterCndBuilderSpecSupportingQueriesRestGetQuery) Endpoint() *filterCndBuilderSpecSupportingQueriesRestGetQueryEndpoint {
	return &filterCndBuilderSpecSupportingQueriesRestGetQueryEndpoint{builder: b.builder}
}

func (b *filterCndBuilderSpecSupportingQueriesRestGetQuery) PathTemplate() *filterCndBuilderSpecSupportingQueriesRestGetQueryPathTemplate {
	return &filterCndBuilderSpecSupportingQueriesRestGetQueryPathTemplate{builder: b.builder}
}

func (b *filterCndBuilderSpecSupportingQueriesRestGetQuery) View() *filterCndBuilderSpecSupportingQueriesRestGetQueryView {
	return &filterCndBuilderSpecSupportingQueriesRestGetQueryView{builder: b.builder}
}

func (b *filterCndBuilderSpecSupportingQueriesRestGetQuery) FieldMask() *filterCndBuilderSpecSupportingQueriesRestGetQueryFieldMask {
	return &filterCndBuilderSpecSupportingQueriesRestGetQueryFieldMask{builder: b.builder}
}

type filterCndBuilderSpecSupportingQueriesRestGetQueryDescription struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecSupportingQueriesRestGetQueryDescription) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().SupportingQueries().RestGetQuery().Description().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesRestGetQueryDescription) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().SupportingQueries().RestGetQuery().Description().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesRestGetQueryDescription) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPolicyFieldPathBuilder().Spec().SupportingQueries().RestGetQuery().Description().FieldPath(),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesRestGetQueryDescription) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPolicyFieldPathBuilder().Spec().SupportingQueries().RestGetQuery().Description().FieldPath(),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesRestGetQueryDescription) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Policy_FieldPathValue: NewPolicyFieldPathBuilder().Spec().SupportingQueries().RestGetQuery().Description().WithValue(value),
	})
}

type filterCndBuilderSpecSupportingQueriesRestGetQueryEndpoint struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecSupportingQueriesRestGetQueryEndpoint) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().SupportingQueries().RestGetQuery().Endpoint().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesRestGetQueryEndpoint) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().SupportingQueries().RestGetQuery().Endpoint().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesRestGetQueryEndpoint) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPolicyFieldPathBuilder().Spec().SupportingQueries().RestGetQuery().Endpoint().FieldPath(),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesRestGetQueryEndpoint) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPolicyFieldPathBuilder().Spec().SupportingQueries().RestGetQuery().Endpoint().FieldPath(),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesRestGetQueryEndpoint) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Policy_FieldPathValue: NewPolicyFieldPathBuilder().Spec().SupportingQueries().RestGetQuery().Endpoint().WithValue(value),
	})
}

type filterCndBuilderSpecSupportingQueriesRestGetQueryPathTemplate struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecSupportingQueriesRestGetQueryPathTemplate) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().SupportingQueries().RestGetQuery().PathTemplate().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesRestGetQueryPathTemplate) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().SupportingQueries().RestGetQuery().PathTemplate().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesRestGetQueryPathTemplate) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPolicyFieldPathBuilder().Spec().SupportingQueries().RestGetQuery().PathTemplate().FieldPath(),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesRestGetQueryPathTemplate) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPolicyFieldPathBuilder().Spec().SupportingQueries().RestGetQuery().PathTemplate().FieldPath(),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesRestGetQueryPathTemplate) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Policy_FieldPathValue: NewPolicyFieldPathBuilder().Spec().SupportingQueries().RestGetQuery().PathTemplate().WithValue(value),
	})
}

type filterCndBuilderSpecSupportingQueriesRestGetQueryView struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecSupportingQueriesRestGetQueryView) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().SupportingQueries().RestGetQuery().View().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesRestGetQueryView) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().SupportingQueries().RestGetQuery().View().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesRestGetQueryView) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPolicyFieldPathBuilder().Spec().SupportingQueries().RestGetQuery().View().FieldPath(),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesRestGetQueryView) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPolicyFieldPathBuilder().Spec().SupportingQueries().RestGetQuery().View().FieldPath(),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesRestGetQueryView) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Policy_FieldPathValue: NewPolicyFieldPathBuilder().Spec().SupportingQueries().RestGetQuery().View().WithValue(value),
	})
}

type filterCndBuilderSpecSupportingQueriesRestGetQueryFieldMask struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecSupportingQueriesRestGetQueryFieldMask) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().SupportingQueries().RestGetQuery().FieldMask().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesRestGetQueryFieldMask) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().SupportingQueries().RestGetQuery().FieldMask().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesRestGetQueryFieldMask) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPolicyFieldPathBuilder().Spec().SupportingQueries().RestGetQuery().FieldMask().FieldPath(),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesRestGetQueryFieldMask) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPolicyFieldPathBuilder().Spec().SupportingQueries().RestGetQuery().FieldMask().FieldPath(),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesRestGetQueryFieldMask) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Policy_FieldPathValue: NewPolicyFieldPathBuilder().Spec().SupportingQueries().RestGetQuery().FieldMask().WithValue(value),
	})
}

type filterCndBuilderSpecSupportingQueriesRestListQuery struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecSupportingQueriesRestListQuery) In(values []*rcommon.PolicySpec_SupportingAlertQuery_RestListQuery) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().SupportingQueries().RestListQuery().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesRestListQuery) NotIn(values []*rcommon.PolicySpec_SupportingAlertQuery_RestListQuery) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().SupportingQueries().RestListQuery().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesRestListQuery) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPolicyFieldPathBuilder().Spec().SupportingQueries().RestListQuery().FieldPath(),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesRestListQuery) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPolicyFieldPathBuilder().Spec().SupportingQueries().RestListQuery().FieldPath(),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesRestListQuery) compare(op gotenfilter.CompareOperator, value *rcommon.PolicySpec_SupportingAlertQuery_RestListQuery) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Policy_FieldPathValue: NewPolicyFieldPathBuilder().Spec().SupportingQueries().RestListQuery().WithValue(value),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesRestListQuery) Description() *filterCndBuilderSpecSupportingQueriesRestListQueryDescription {
	return &filterCndBuilderSpecSupportingQueriesRestListQueryDescription{builder: b.builder}
}

func (b *filterCndBuilderSpecSupportingQueriesRestListQuery) Endpoint() *filterCndBuilderSpecSupportingQueriesRestListQueryEndpoint {
	return &filterCndBuilderSpecSupportingQueriesRestListQueryEndpoint{builder: b.builder}
}

func (b *filterCndBuilderSpecSupportingQueriesRestListQuery) PathTemplate() *filterCndBuilderSpecSupportingQueriesRestListQueryPathTemplate {
	return &filterCndBuilderSpecSupportingQueriesRestListQueryPathTemplate{builder: b.builder}
}

func (b *filterCndBuilderSpecSupportingQueriesRestListQuery) View() *filterCndBuilderSpecSupportingQueriesRestListQueryView {
	return &filterCndBuilderSpecSupportingQueriesRestListQueryView{builder: b.builder}
}

func (b *filterCndBuilderSpecSupportingQueriesRestListQuery) FieldMask() *filterCndBuilderSpecSupportingQueriesRestListQueryFieldMask {
	return &filterCndBuilderSpecSupportingQueriesRestListQueryFieldMask{builder: b.builder}
}

func (b *filterCndBuilderSpecSupportingQueriesRestListQuery) FilterTemplate() *filterCndBuilderSpecSupportingQueriesRestListQueryFilterTemplate {
	return &filterCndBuilderSpecSupportingQueriesRestListQueryFilterTemplate{builder: b.builder}
}

type filterCndBuilderSpecSupportingQueriesRestListQueryDescription struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecSupportingQueriesRestListQueryDescription) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().SupportingQueries().RestListQuery().Description().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesRestListQueryDescription) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().SupportingQueries().RestListQuery().Description().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesRestListQueryDescription) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPolicyFieldPathBuilder().Spec().SupportingQueries().RestListQuery().Description().FieldPath(),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesRestListQueryDescription) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPolicyFieldPathBuilder().Spec().SupportingQueries().RestListQuery().Description().FieldPath(),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesRestListQueryDescription) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Policy_FieldPathValue: NewPolicyFieldPathBuilder().Spec().SupportingQueries().RestListQuery().Description().WithValue(value),
	})
}

type filterCndBuilderSpecSupportingQueriesRestListQueryEndpoint struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecSupportingQueriesRestListQueryEndpoint) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().SupportingQueries().RestListQuery().Endpoint().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesRestListQueryEndpoint) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().SupportingQueries().RestListQuery().Endpoint().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesRestListQueryEndpoint) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPolicyFieldPathBuilder().Spec().SupportingQueries().RestListQuery().Endpoint().FieldPath(),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesRestListQueryEndpoint) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPolicyFieldPathBuilder().Spec().SupportingQueries().RestListQuery().Endpoint().FieldPath(),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesRestListQueryEndpoint) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Policy_FieldPathValue: NewPolicyFieldPathBuilder().Spec().SupportingQueries().RestListQuery().Endpoint().WithValue(value),
	})
}

type filterCndBuilderSpecSupportingQueriesRestListQueryPathTemplate struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecSupportingQueriesRestListQueryPathTemplate) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().SupportingQueries().RestListQuery().PathTemplate().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesRestListQueryPathTemplate) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().SupportingQueries().RestListQuery().PathTemplate().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesRestListQueryPathTemplate) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPolicyFieldPathBuilder().Spec().SupportingQueries().RestListQuery().PathTemplate().FieldPath(),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesRestListQueryPathTemplate) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPolicyFieldPathBuilder().Spec().SupportingQueries().RestListQuery().PathTemplate().FieldPath(),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesRestListQueryPathTemplate) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Policy_FieldPathValue: NewPolicyFieldPathBuilder().Spec().SupportingQueries().RestListQuery().PathTemplate().WithValue(value),
	})
}

type filterCndBuilderSpecSupportingQueriesRestListQueryView struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecSupportingQueriesRestListQueryView) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().SupportingQueries().RestListQuery().View().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesRestListQueryView) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().SupportingQueries().RestListQuery().View().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesRestListQueryView) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPolicyFieldPathBuilder().Spec().SupportingQueries().RestListQuery().View().FieldPath(),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesRestListQueryView) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPolicyFieldPathBuilder().Spec().SupportingQueries().RestListQuery().View().FieldPath(),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesRestListQueryView) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Policy_FieldPathValue: NewPolicyFieldPathBuilder().Spec().SupportingQueries().RestListQuery().View().WithValue(value),
	})
}

type filterCndBuilderSpecSupportingQueriesRestListQueryFieldMask struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecSupportingQueriesRestListQueryFieldMask) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().SupportingQueries().RestListQuery().FieldMask().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesRestListQueryFieldMask) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().SupportingQueries().RestListQuery().FieldMask().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesRestListQueryFieldMask) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPolicyFieldPathBuilder().Spec().SupportingQueries().RestListQuery().FieldMask().FieldPath(),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesRestListQueryFieldMask) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPolicyFieldPathBuilder().Spec().SupportingQueries().RestListQuery().FieldMask().FieldPath(),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesRestListQueryFieldMask) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Policy_FieldPathValue: NewPolicyFieldPathBuilder().Spec().SupportingQueries().RestListQuery().FieldMask().WithValue(value),
	})
}

type filterCndBuilderSpecSupportingQueriesRestListQueryFilterTemplate struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecSupportingQueriesRestListQueryFilterTemplate) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().SupportingQueries().RestListQuery().FilterTemplate().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesRestListQueryFilterTemplate) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().SupportingQueries().RestListQuery().FilterTemplate().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesRestListQueryFilterTemplate) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPolicyFieldPathBuilder().Spec().SupportingQueries().RestListQuery().FilterTemplate().FieldPath(),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesRestListQueryFilterTemplate) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPolicyFieldPathBuilder().Spec().SupportingQueries().RestListQuery().FilterTemplate().FieldPath(),
	})
}

func (b *filterCndBuilderSpecSupportingQueriesRestListQueryFilterTemplate) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Policy_FieldPathValue: NewPolicyFieldPathBuilder().Spec().SupportingQueries().RestListQuery().FilterTemplate().WithValue(value),
	})
}

type filterCndBuilderSpecAiAgent struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecAiAgent) In(values []*rcommon.PolicySpec_AIAgentHandling) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().AiAgent().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecAiAgent) NotIn(values []*rcommon.PolicySpec_AIAgentHandling) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().AiAgent().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecAiAgent) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPolicyFieldPathBuilder().Spec().AiAgent().FieldPath(),
	})
}

func (b *filterCndBuilderSpecAiAgent) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPolicyFieldPathBuilder().Spec().AiAgent().FieldPath(),
	})
}

func (b *filterCndBuilderSpecAiAgent) compare(op gotenfilter.CompareOperator, value *rcommon.PolicySpec_AIAgentHandling) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Policy_FieldPathValue: NewPolicyFieldPathBuilder().Spec().AiAgent().WithValue(value),
	})
}

func (b *filterCndBuilderSpecAiAgent) Enabled() *filterCndBuilderSpecAiAgentEnabled {
	return &filterCndBuilderSpecAiAgentEnabled{builder: b.builder}
}

func (b *filterCndBuilderSpecAiAgent) EnabledConnectivity() *filterCndBuilderSpecAiAgentEnabledConnectivity {
	return &filterCndBuilderSpecAiAgentEnabledConnectivity{builder: b.builder}
}

func (b *filterCndBuilderSpecAiAgent) AutoAcceptRemediation() *filterCndBuilderSpecAiAgentAutoAcceptRemediation {
	return &filterCndBuilderSpecAiAgentAutoAcceptRemediation{builder: b.builder}
}

func (b *filterCndBuilderSpecAiAgent) EdgeConnectivity() *filterCndBuilderSpecAiAgentEdgeConnectivity {
	return &filterCndBuilderSpecAiAgentEdgeConnectivity{builder: b.builder}
}

func (b *filterCndBuilderSpecAiAgent) RemediationOptions() *filterCndBuilderSpecAiAgentRemediationOptions {
	return &filterCndBuilderSpecAiAgentRemediationOptions{builder: b.builder}
}

type filterCndBuilderSpecAiAgentEnabled struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecAiAgentEnabled) In(values []bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().AiAgent().Enabled().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecAiAgentEnabled) NotIn(values []bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().AiAgent().Enabled().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecAiAgentEnabled) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPolicyFieldPathBuilder().Spec().AiAgent().Enabled().FieldPath(),
	})
}

func (b *filterCndBuilderSpecAiAgentEnabled) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPolicyFieldPathBuilder().Spec().AiAgent().Enabled().FieldPath(),
	})
}

func (b *filterCndBuilderSpecAiAgentEnabled) compare(op gotenfilter.CompareOperator, value bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Policy_FieldPathValue: NewPolicyFieldPathBuilder().Spec().AiAgent().Enabled().WithValue(value),
	})
}

type filterCndBuilderSpecAiAgentEnabledConnectivity struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecAiAgentEnabledConnectivity) In(values []bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().AiAgent().EnabledConnectivity().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecAiAgentEnabledConnectivity) NotIn(values []bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().AiAgent().EnabledConnectivity().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecAiAgentEnabledConnectivity) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPolicyFieldPathBuilder().Spec().AiAgent().EnabledConnectivity().FieldPath(),
	})
}

func (b *filterCndBuilderSpecAiAgentEnabledConnectivity) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPolicyFieldPathBuilder().Spec().AiAgent().EnabledConnectivity().FieldPath(),
	})
}

func (b *filterCndBuilderSpecAiAgentEnabledConnectivity) compare(op gotenfilter.CompareOperator, value bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Policy_FieldPathValue: NewPolicyFieldPathBuilder().Spec().AiAgent().EnabledConnectivity().WithValue(value),
	})
}

type filterCndBuilderSpecAiAgentAutoAcceptRemediation struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecAiAgentAutoAcceptRemediation) In(values []bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().AiAgent().AutoAcceptRemediation().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecAiAgentAutoAcceptRemediation) NotIn(values []bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().AiAgent().AutoAcceptRemediation().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecAiAgentAutoAcceptRemediation) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPolicyFieldPathBuilder().Spec().AiAgent().AutoAcceptRemediation().FieldPath(),
	})
}

func (b *filterCndBuilderSpecAiAgentAutoAcceptRemediation) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPolicyFieldPathBuilder().Spec().AiAgent().AutoAcceptRemediation().FieldPath(),
	})
}

func (b *filterCndBuilderSpecAiAgentAutoAcceptRemediation) compare(op gotenfilter.CompareOperator, value bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Policy_FieldPathValue: NewPolicyFieldPathBuilder().Spec().AiAgent().AutoAcceptRemediation().WithValue(value),
	})
}

type filterCndBuilderSpecAiAgentEdgeConnectivity struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecAiAgentEdgeConnectivity) In(values []*rcommon.PolicySpec_AIAgentHandling_EdgeConnectivity) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().AiAgent().EdgeConnectivity().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecAiAgentEdgeConnectivity) NotIn(values []*rcommon.PolicySpec_AIAgentHandling_EdgeConnectivity) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().AiAgent().EdgeConnectivity().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecAiAgentEdgeConnectivity) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPolicyFieldPathBuilder().Spec().AiAgent().EdgeConnectivity().FieldPath(),
	})
}

func (b *filterCndBuilderSpecAiAgentEdgeConnectivity) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPolicyFieldPathBuilder().Spec().AiAgent().EdgeConnectivity().FieldPath(),
	})
}

func (b *filterCndBuilderSpecAiAgentEdgeConnectivity) compare(op gotenfilter.CompareOperator, value *rcommon.PolicySpec_AIAgentHandling_EdgeConnectivity) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Policy_FieldPathValue: NewPolicyFieldPathBuilder().Spec().AiAgent().EdgeConnectivity().WithValue(value),
	})
}

func (b *filterCndBuilderSpecAiAgentEdgeConnectivity) DeviceSsh() *filterCndBuilderSpecAiAgentEdgeConnectivityDeviceSsh {
	return &filterCndBuilderSpecAiAgentEdgeConnectivityDeviceSsh{builder: b.builder}
}

func (b *filterCndBuilderSpecAiAgentEdgeConnectivity) ProxiesSsh() *filterCndBuilderSpecAiAgentEdgeConnectivityProxiesSsh {
	return &filterCndBuilderSpecAiAgentEdgeConnectivityProxiesSsh{builder: b.builder}
}

func (b *filterCndBuilderSpecAiAgentEdgeConnectivity) PodSsh() *filterCndBuilderSpecAiAgentEdgeConnectivityPodSsh {
	return &filterCndBuilderSpecAiAgentEdgeConnectivityPodSsh{builder: b.builder}
}

func (b *filterCndBuilderSpecAiAgentEdgeConnectivity) AllowedBins() *filterCndBuilderSpecAiAgentEdgeConnectivityAllowedBins {
	return &filterCndBuilderSpecAiAgentEdgeConnectivityAllowedBins{builder: b.builder}
}

type filterCndBuilderSpecAiAgentEdgeConnectivityDeviceSsh struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecAiAgentEdgeConnectivityDeviceSsh) In(values []*rcommon.PolicySpec_AIAgentHandling_EdgeConnectivity_DeviceSSH) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().AiAgent().EdgeConnectivity().DeviceSsh().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecAiAgentEdgeConnectivityDeviceSsh) NotIn(values []*rcommon.PolicySpec_AIAgentHandling_EdgeConnectivity_DeviceSSH) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().AiAgent().EdgeConnectivity().DeviceSsh().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecAiAgentEdgeConnectivityDeviceSsh) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPolicyFieldPathBuilder().Spec().AiAgent().EdgeConnectivity().DeviceSsh().FieldPath(),
	})
}

func (b *filterCndBuilderSpecAiAgentEdgeConnectivityDeviceSsh) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPolicyFieldPathBuilder().Spec().AiAgent().EdgeConnectivity().DeviceSsh().FieldPath(),
	})
}

func (b *filterCndBuilderSpecAiAgentEdgeConnectivityDeviceSsh) compare(op gotenfilter.CompareOperator, value *rcommon.PolicySpec_AIAgentHandling_EdgeConnectivity_DeviceSSH) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Policy_FieldPathValue: NewPolicyFieldPathBuilder().Spec().AiAgent().EdgeConnectivity().DeviceSsh().WithValue(value),
	})
}

func (b *filterCndBuilderSpecAiAgentEdgeConnectivityDeviceSsh) ClientName() *filterCndBuilderSpecAiAgentEdgeConnectivityDeviceSshClientName {
	return &filterCndBuilderSpecAiAgentEdgeConnectivityDeviceSshClientName{builder: b.builder}
}

type filterCndBuilderSpecAiAgentEdgeConnectivityDeviceSshClientName struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecAiAgentEdgeConnectivityDeviceSshClientName) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().AiAgent().EdgeConnectivity().DeviceSsh().ClientName().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecAiAgentEdgeConnectivityDeviceSshClientName) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().AiAgent().EdgeConnectivity().DeviceSsh().ClientName().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecAiAgentEdgeConnectivityDeviceSshClientName) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPolicyFieldPathBuilder().Spec().AiAgent().EdgeConnectivity().DeviceSsh().ClientName().FieldPath(),
	})
}

func (b *filterCndBuilderSpecAiAgentEdgeConnectivityDeviceSshClientName) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPolicyFieldPathBuilder().Spec().AiAgent().EdgeConnectivity().DeviceSsh().ClientName().FieldPath(),
	})
}

func (b *filterCndBuilderSpecAiAgentEdgeConnectivityDeviceSshClientName) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Policy_FieldPathValue: NewPolicyFieldPathBuilder().Spec().AiAgent().EdgeConnectivity().DeviceSsh().ClientName().WithValue(value),
	})
}

type filterCndBuilderSpecAiAgentEdgeConnectivityProxiesSsh struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecAiAgentEdgeConnectivityProxiesSsh) In(values []*rcommon.PolicySpec_AIAgentHandling_EdgeConnectivity_ProxiesSSH) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().AiAgent().EdgeConnectivity().ProxiesSsh().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecAiAgentEdgeConnectivityProxiesSsh) NotIn(values []*rcommon.PolicySpec_AIAgentHandling_EdgeConnectivity_ProxiesSSH) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().AiAgent().EdgeConnectivity().ProxiesSsh().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecAiAgentEdgeConnectivityProxiesSsh) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPolicyFieldPathBuilder().Spec().AiAgent().EdgeConnectivity().ProxiesSsh().FieldPath(),
	})
}

func (b *filterCndBuilderSpecAiAgentEdgeConnectivityProxiesSsh) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPolicyFieldPathBuilder().Spec().AiAgent().EdgeConnectivity().ProxiesSsh().FieldPath(),
	})
}

func (b *filterCndBuilderSpecAiAgentEdgeConnectivityProxiesSsh) compare(op gotenfilter.CompareOperator, value *rcommon.PolicySpec_AIAgentHandling_EdgeConnectivity_ProxiesSSH) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Policy_FieldPathValue: NewPolicyFieldPathBuilder().Spec().AiAgent().EdgeConnectivity().ProxiesSsh().WithValue(value),
	})
}

func (b *filterCndBuilderSpecAiAgentEdgeConnectivityProxiesSsh) ServiceDomain() *filterCndBuilderSpecAiAgentEdgeConnectivityProxiesSshServiceDomain {
	return &filterCndBuilderSpecAiAgentEdgeConnectivityProxiesSshServiceDomain{builder: b.builder}
}

func (b *filterCndBuilderSpecAiAgentEdgeConnectivityProxiesSsh) ProviderNameTmpl() *filterCndBuilderSpecAiAgentEdgeConnectivityProxiesSshProviderNameTmpl {
	return &filterCndBuilderSpecAiAgentEdgeConnectivityProxiesSshProviderNameTmpl{builder: b.builder}
}

func (b *filterCndBuilderSpecAiAgentEdgeConnectivityProxiesSsh) ClientName() *filterCndBuilderSpecAiAgentEdgeConnectivityProxiesSshClientName {
	return &filterCndBuilderSpecAiAgentEdgeConnectivityProxiesSshClientName{builder: b.builder}
}

func (b *filterCndBuilderSpecAiAgentEdgeConnectivityProxiesSsh) ServiceName() *filterCndBuilderSpecAiAgentEdgeConnectivityProxiesSshServiceName {
	return &filterCndBuilderSpecAiAgentEdgeConnectivityProxiesSshServiceName{builder: b.builder}
}

type filterCndBuilderSpecAiAgentEdgeConnectivityProxiesSshServiceDomain struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecAiAgentEdgeConnectivityProxiesSshServiceDomain) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().AiAgent().EdgeConnectivity().ProxiesSsh().ServiceDomain().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecAiAgentEdgeConnectivityProxiesSshServiceDomain) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().AiAgent().EdgeConnectivity().ProxiesSsh().ServiceDomain().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecAiAgentEdgeConnectivityProxiesSshServiceDomain) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPolicyFieldPathBuilder().Spec().AiAgent().EdgeConnectivity().ProxiesSsh().ServiceDomain().FieldPath(),
	})
}

func (b *filterCndBuilderSpecAiAgentEdgeConnectivityProxiesSshServiceDomain) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPolicyFieldPathBuilder().Spec().AiAgent().EdgeConnectivity().ProxiesSsh().ServiceDomain().FieldPath(),
	})
}

func (b *filterCndBuilderSpecAiAgentEdgeConnectivityProxiesSshServiceDomain) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Policy_FieldPathValue: NewPolicyFieldPathBuilder().Spec().AiAgent().EdgeConnectivity().ProxiesSsh().ServiceDomain().WithValue(value),
	})
}

type filterCndBuilderSpecAiAgentEdgeConnectivityProxiesSshProviderNameTmpl struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecAiAgentEdgeConnectivityProxiesSshProviderNameTmpl) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().AiAgent().EdgeConnectivity().ProxiesSsh().ProviderNameTmpl().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecAiAgentEdgeConnectivityProxiesSshProviderNameTmpl) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().AiAgent().EdgeConnectivity().ProxiesSsh().ProviderNameTmpl().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecAiAgentEdgeConnectivityProxiesSshProviderNameTmpl) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPolicyFieldPathBuilder().Spec().AiAgent().EdgeConnectivity().ProxiesSsh().ProviderNameTmpl().FieldPath(),
	})
}

func (b *filterCndBuilderSpecAiAgentEdgeConnectivityProxiesSshProviderNameTmpl) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPolicyFieldPathBuilder().Spec().AiAgent().EdgeConnectivity().ProxiesSsh().ProviderNameTmpl().FieldPath(),
	})
}

func (b *filterCndBuilderSpecAiAgentEdgeConnectivityProxiesSshProviderNameTmpl) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Policy_FieldPathValue: NewPolicyFieldPathBuilder().Spec().AiAgent().EdgeConnectivity().ProxiesSsh().ProviderNameTmpl().WithValue(value),
	})
}

type filterCndBuilderSpecAiAgentEdgeConnectivityProxiesSshClientName struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecAiAgentEdgeConnectivityProxiesSshClientName) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().AiAgent().EdgeConnectivity().ProxiesSsh().ClientName().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecAiAgentEdgeConnectivityProxiesSshClientName) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().AiAgent().EdgeConnectivity().ProxiesSsh().ClientName().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecAiAgentEdgeConnectivityProxiesSshClientName) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPolicyFieldPathBuilder().Spec().AiAgent().EdgeConnectivity().ProxiesSsh().ClientName().FieldPath(),
	})
}

func (b *filterCndBuilderSpecAiAgentEdgeConnectivityProxiesSshClientName) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPolicyFieldPathBuilder().Spec().AiAgent().EdgeConnectivity().ProxiesSsh().ClientName().FieldPath(),
	})
}

func (b *filterCndBuilderSpecAiAgentEdgeConnectivityProxiesSshClientName) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Policy_FieldPathValue: NewPolicyFieldPathBuilder().Spec().AiAgent().EdgeConnectivity().ProxiesSsh().ClientName().WithValue(value),
	})
}

type filterCndBuilderSpecAiAgentEdgeConnectivityProxiesSshServiceName struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecAiAgentEdgeConnectivityProxiesSshServiceName) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().AiAgent().EdgeConnectivity().ProxiesSsh().ServiceName().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecAiAgentEdgeConnectivityProxiesSshServiceName) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().AiAgent().EdgeConnectivity().ProxiesSsh().ServiceName().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecAiAgentEdgeConnectivityProxiesSshServiceName) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPolicyFieldPathBuilder().Spec().AiAgent().EdgeConnectivity().ProxiesSsh().ServiceName().FieldPath(),
	})
}

func (b *filterCndBuilderSpecAiAgentEdgeConnectivityProxiesSshServiceName) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPolicyFieldPathBuilder().Spec().AiAgent().EdgeConnectivity().ProxiesSsh().ServiceName().FieldPath(),
	})
}

func (b *filterCndBuilderSpecAiAgentEdgeConnectivityProxiesSshServiceName) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Policy_FieldPathValue: NewPolicyFieldPathBuilder().Spec().AiAgent().EdgeConnectivity().ProxiesSsh().ServiceName().WithValue(value),
	})
}

type filterCndBuilderSpecAiAgentEdgeConnectivityPodSsh struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecAiAgentEdgeConnectivityPodSsh) In(values []*rcommon.PolicySpec_AIAgentHandling_EdgeConnectivity_PodSSH) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().AiAgent().EdgeConnectivity().PodSsh().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecAiAgentEdgeConnectivityPodSsh) NotIn(values []*rcommon.PolicySpec_AIAgentHandling_EdgeConnectivity_PodSSH) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().AiAgent().EdgeConnectivity().PodSsh().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecAiAgentEdgeConnectivityPodSsh) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPolicyFieldPathBuilder().Spec().AiAgent().EdgeConnectivity().PodSsh().FieldPath(),
	})
}

func (b *filterCndBuilderSpecAiAgentEdgeConnectivityPodSsh) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPolicyFieldPathBuilder().Spec().AiAgent().EdgeConnectivity().PodSsh().FieldPath(),
	})
}

func (b *filterCndBuilderSpecAiAgentEdgeConnectivityPodSsh) compare(op gotenfilter.CompareOperator, value *rcommon.PolicySpec_AIAgentHandling_EdgeConnectivity_PodSSH) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Policy_FieldPathValue: NewPolicyFieldPathBuilder().Spec().AiAgent().EdgeConnectivity().PodSsh().WithValue(value),
	})
}

func (b *filterCndBuilderSpecAiAgentEdgeConnectivityPodSsh) ClientName() *filterCndBuilderSpecAiAgentEdgeConnectivityPodSshClientName {
	return &filterCndBuilderSpecAiAgentEdgeConnectivityPodSshClientName{builder: b.builder}
}

func (b *filterCndBuilderSpecAiAgentEdgeConnectivityPodSsh) Username() *filterCndBuilderSpecAiAgentEdgeConnectivityPodSshUsername {
	return &filterCndBuilderSpecAiAgentEdgeConnectivityPodSshUsername{builder: b.builder}
}

type filterCndBuilderSpecAiAgentEdgeConnectivityPodSshClientName struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecAiAgentEdgeConnectivityPodSshClientName) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().AiAgent().EdgeConnectivity().PodSsh().ClientName().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecAiAgentEdgeConnectivityPodSshClientName) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().AiAgent().EdgeConnectivity().PodSsh().ClientName().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecAiAgentEdgeConnectivityPodSshClientName) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPolicyFieldPathBuilder().Spec().AiAgent().EdgeConnectivity().PodSsh().ClientName().FieldPath(),
	})
}

func (b *filterCndBuilderSpecAiAgentEdgeConnectivityPodSshClientName) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPolicyFieldPathBuilder().Spec().AiAgent().EdgeConnectivity().PodSsh().ClientName().FieldPath(),
	})
}

func (b *filterCndBuilderSpecAiAgentEdgeConnectivityPodSshClientName) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Policy_FieldPathValue: NewPolicyFieldPathBuilder().Spec().AiAgent().EdgeConnectivity().PodSsh().ClientName().WithValue(value),
	})
}

type filterCndBuilderSpecAiAgentEdgeConnectivityPodSshUsername struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecAiAgentEdgeConnectivityPodSshUsername) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().AiAgent().EdgeConnectivity().PodSsh().Username().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecAiAgentEdgeConnectivityPodSshUsername) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().AiAgent().EdgeConnectivity().PodSsh().Username().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecAiAgentEdgeConnectivityPodSshUsername) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPolicyFieldPathBuilder().Spec().AiAgent().EdgeConnectivity().PodSsh().Username().FieldPath(),
	})
}

func (b *filterCndBuilderSpecAiAgentEdgeConnectivityPodSshUsername) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPolicyFieldPathBuilder().Spec().AiAgent().EdgeConnectivity().PodSsh().Username().FieldPath(),
	})
}

func (b *filterCndBuilderSpecAiAgentEdgeConnectivityPodSshUsername) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Policy_FieldPathValue: NewPolicyFieldPathBuilder().Spec().AiAgent().EdgeConnectivity().PodSsh().Username().WithValue(value),
	})
}

type filterCndBuilderSpecAiAgentEdgeConnectivityAllowedBins struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecAiAgentEdgeConnectivityAllowedBins) In(values [][]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().AiAgent().EdgeConnectivity().AllowedBins().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecAiAgentEdgeConnectivityAllowedBins) NotIn(values [][]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().AiAgent().EdgeConnectivity().AllowedBins().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecAiAgentEdgeConnectivityAllowedBins) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPolicyFieldPathBuilder().Spec().AiAgent().EdgeConnectivity().AllowedBins().FieldPath(),
	})
}

func (b *filterCndBuilderSpecAiAgentEdgeConnectivityAllowedBins) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPolicyFieldPathBuilder().Spec().AiAgent().EdgeConnectivity().AllowedBins().FieldPath(),
	})
}

func (b *filterCndBuilderSpecAiAgentEdgeConnectivityAllowedBins) Contains(value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewPolicyFieldPathBuilder().Spec().AiAgent().EdgeConnectivity().AllowedBins().FieldPath(),
		Value:     NewPolicyFieldPathBuilder().Spec().AiAgent().EdgeConnectivity().AllowedBins().WithItemValue(value),
	})
}

func (b *filterCndBuilderSpecAiAgentEdgeConnectivityAllowedBins) ContainsAnyOf(values []string) *FilterBuilder {
	pathSelector := NewPolicyFieldPathBuilder().Spec().AiAgent().EdgeConnectivity().AllowedBins()
	itemValues := make([]Policy_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewPolicyFieldPathBuilder().Spec().AiAgent().EdgeConnectivity().AllowedBins().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderSpecAiAgentEdgeConnectivityAllowedBins) ContainsAll(values []string) *FilterBuilder {
	pathSelector := NewPolicyFieldPathBuilder().Spec().AiAgent().EdgeConnectivity().AllowedBins()
	itemValues := make([]Policy_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewPolicyFieldPathBuilder().Spec().AiAgent().EdgeConnectivity().AllowedBins().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderSpecAiAgentEdgeConnectivityAllowedBins) compare(op gotenfilter.CompareOperator, value []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Policy_FieldPathValue: NewPolicyFieldPathBuilder().Spec().AiAgent().EdgeConnectivity().AllowedBins().WithValue(value),
	})
}

type filterCndBuilderSpecAiAgentRemediationOptions struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecAiAgentRemediationOptions) In(values [][]*rcommon.PolicySpec_AIAgentHandling_Remediation) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().AiAgent().RemediationOptions().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecAiAgentRemediationOptions) NotIn(values [][]*rcommon.PolicySpec_AIAgentHandling_Remediation) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().AiAgent().RemediationOptions().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecAiAgentRemediationOptions) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPolicyFieldPathBuilder().Spec().AiAgent().RemediationOptions().FieldPath(),
	})
}

func (b *filterCndBuilderSpecAiAgentRemediationOptions) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPolicyFieldPathBuilder().Spec().AiAgent().RemediationOptions().FieldPath(),
	})
}

func (b *filterCndBuilderSpecAiAgentRemediationOptions) Contains(value *rcommon.PolicySpec_AIAgentHandling_Remediation) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewPolicyFieldPathBuilder().Spec().AiAgent().RemediationOptions().FieldPath(),
		Value:     NewPolicyFieldPathBuilder().Spec().AiAgent().RemediationOptions().WithItemValue(value),
	})
}

func (b *filterCndBuilderSpecAiAgentRemediationOptions) ContainsAnyOf(values []*rcommon.PolicySpec_AIAgentHandling_Remediation) *FilterBuilder {
	pathSelector := NewPolicyFieldPathBuilder().Spec().AiAgent().RemediationOptions()
	itemValues := make([]Policy_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewPolicyFieldPathBuilder().Spec().AiAgent().RemediationOptions().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderSpecAiAgentRemediationOptions) ContainsAll(values []*rcommon.PolicySpec_AIAgentHandling_Remediation) *FilterBuilder {
	pathSelector := NewPolicyFieldPathBuilder().Spec().AiAgent().RemediationOptions()
	itemValues := make([]Policy_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewPolicyFieldPathBuilder().Spec().AiAgent().RemediationOptions().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderSpecAiAgentRemediationOptions) compare(op gotenfilter.CompareOperator, value []*rcommon.PolicySpec_AIAgentHandling_Remediation) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Policy_FieldPathValue: NewPolicyFieldPathBuilder().Spec().AiAgent().RemediationOptions().WithValue(value),
	})
}

func (b *filterCndBuilderSpecAiAgentRemediationOptions) FixInSsh() *filterCndBuilderSpecAiAgentRemediationOptionsFixInSsh {
	return &filterCndBuilderSpecAiAgentRemediationOptionsFixInSsh{builder: b.builder}
}

func (b *filterCndBuilderSpecAiAgentRemediationOptions) Reboot() *filterCndBuilderSpecAiAgentRemediationOptionsReboot {
	return &filterCndBuilderSpecAiAgentRemediationOptionsReboot{builder: b.builder}
}

type filterCndBuilderSpecAiAgentRemediationOptionsFixInSsh struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecAiAgentRemediationOptionsFixInSsh) In(values []*rcommon.PolicySpec_AIAgentHandling_Remediation_FixInSSH) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().AiAgent().RemediationOptions().FixInSsh().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecAiAgentRemediationOptionsFixInSsh) NotIn(values []*rcommon.PolicySpec_AIAgentHandling_Remediation_FixInSSH) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().AiAgent().RemediationOptions().FixInSsh().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecAiAgentRemediationOptionsFixInSsh) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPolicyFieldPathBuilder().Spec().AiAgent().RemediationOptions().FixInSsh().FieldPath(),
	})
}

func (b *filterCndBuilderSpecAiAgentRemediationOptionsFixInSsh) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPolicyFieldPathBuilder().Spec().AiAgent().RemediationOptions().FixInSsh().FieldPath(),
	})
}

func (b *filterCndBuilderSpecAiAgentRemediationOptionsFixInSsh) compare(op gotenfilter.CompareOperator, value *rcommon.PolicySpec_AIAgentHandling_Remediation_FixInSSH) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Policy_FieldPathValue: NewPolicyFieldPathBuilder().Spec().AiAgent().RemediationOptions().FixInSsh().WithValue(value),
	})
}

type filterCndBuilderSpecAiAgentRemediationOptionsReboot struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecAiAgentRemediationOptionsReboot) In(values []*rcommon.PolicySpec_AIAgentHandling_Remediation_Reboot) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().AiAgent().RemediationOptions().Reboot().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecAiAgentRemediationOptionsReboot) NotIn(values []*rcommon.PolicySpec_AIAgentHandling_Remediation_Reboot) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().Spec().AiAgent().RemediationOptions().Reboot().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecAiAgentRemediationOptionsReboot) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPolicyFieldPathBuilder().Spec().AiAgent().RemediationOptions().Reboot().FieldPath(),
	})
}

func (b *filterCndBuilderSpecAiAgentRemediationOptionsReboot) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPolicyFieldPathBuilder().Spec().AiAgent().RemediationOptions().Reboot().FieldPath(),
	})
}

func (b *filterCndBuilderSpecAiAgentRemediationOptionsReboot) compare(op gotenfilter.CompareOperator, value *rcommon.PolicySpec_AIAgentHandling_Remediation_Reboot) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Policy_FieldPathValue: NewPolicyFieldPathBuilder().Spec().AiAgent().RemediationOptions().Reboot().WithValue(value),
	})
}

type filterCndBuilderTemplateSource struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderTemplateSource) Eq(value *Policy_TemplateSource) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderTemplateSource) Neq(value *Policy_TemplateSource) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderTemplateSource) Gt(value *Policy_TemplateSource) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderTemplateSource) Gte(value *Policy_TemplateSource) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderTemplateSource) Lt(value *Policy_TemplateSource) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderTemplateSource) Lte(value *Policy_TemplateSource) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderTemplateSource) In(values []*Policy_TemplateSource) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().TemplateSource().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderTemplateSource) NotIn(values []*Policy_TemplateSource) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().TemplateSource().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderTemplateSource) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPolicyFieldPathBuilder().TemplateSource().FieldPath(),
	})
}

func (b *filterCndBuilderTemplateSource) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPolicyFieldPathBuilder().TemplateSource().FieldPath(),
	})
}

func (b *filterCndBuilderTemplateSource) compare(op gotenfilter.CompareOperator, value *Policy_TemplateSource) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Policy_FieldPathValue: NewPolicyFieldPathBuilder().TemplateSource().WithValue(value),
	})
}

func (b *filterCndBuilderTemplateSource) Template() *filterCndBuilderTemplateSourceTemplate {
	return &filterCndBuilderTemplateSourceTemplate{builder: b.builder}
}

func (b *filterCndBuilderTemplateSource) UpdatedFields() *filterCndBuilderTemplateSourceUpdatedFields {
	return &filterCndBuilderTemplateSourceUpdatedFields{builder: b.builder}
}

type filterCndBuilderTemplateSourceTemplate struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderTemplateSourceTemplate) Eq(value *policy_template.Reference) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderTemplateSourceTemplate) Neq(value *policy_template.Reference) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderTemplateSourceTemplate) Gt(value *policy_template.Reference) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderTemplateSourceTemplate) Gte(value *policy_template.Reference) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderTemplateSourceTemplate) Lt(value *policy_template.Reference) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderTemplateSourceTemplate) Lte(value *policy_template.Reference) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderTemplateSourceTemplate) In(values []*policy_template.Reference) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().TemplateSource().Template().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderTemplateSourceTemplate) NotIn(values []*policy_template.Reference) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().TemplateSource().Template().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderTemplateSourceTemplate) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPolicyFieldPathBuilder().TemplateSource().Template().FieldPath(),
	})
}

func (b *filterCndBuilderTemplateSourceTemplate) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPolicyFieldPathBuilder().TemplateSource().Template().FieldPath(),
	})
}

func (b *filterCndBuilderTemplateSourceTemplate) compare(op gotenfilter.CompareOperator, value *policy_template.Reference) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Policy_FieldPathValue: NewPolicyFieldPathBuilder().TemplateSource().Template().WithValue(value),
	})
}

type filterCndBuilderTemplateSourceUpdatedFields struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderTemplateSourceUpdatedFields) Eq(value *fieldmaskpb.FieldMask) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderTemplateSourceUpdatedFields) Neq(value *fieldmaskpb.FieldMask) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderTemplateSourceUpdatedFields) Gt(value *fieldmaskpb.FieldMask) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderTemplateSourceUpdatedFields) Gte(value *fieldmaskpb.FieldMask) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderTemplateSourceUpdatedFields) Lt(value *fieldmaskpb.FieldMask) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderTemplateSourceUpdatedFields) Lte(value *fieldmaskpb.FieldMask) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderTemplateSourceUpdatedFields) In(values []*fieldmaskpb.FieldMask) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().TemplateSource().UpdatedFields().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderTemplateSourceUpdatedFields) NotIn(values []*fieldmaskpb.FieldMask) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().TemplateSource().UpdatedFields().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderTemplateSourceUpdatedFields) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPolicyFieldPathBuilder().TemplateSource().UpdatedFields().FieldPath(),
	})
}

func (b *filterCndBuilderTemplateSourceUpdatedFields) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPolicyFieldPathBuilder().TemplateSource().UpdatedFields().FieldPath(),
	})
}

func (b *filterCndBuilderTemplateSourceUpdatedFields) compare(op gotenfilter.CompareOperator, value *fieldmaskpb.FieldMask) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Policy_FieldPathValue: NewPolicyFieldPathBuilder().TemplateSource().UpdatedFields().WithValue(value),
	})
}

type filterCndBuilderNotificationChannels struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderNotificationChannels) In(values [][]*notification_channel.Reference) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().NotificationChannels().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderNotificationChannels) NotIn(values [][]*notification_channel.Reference) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Policy_FieldPathArrayOfValues: NewPolicyFieldPathBuilder().NotificationChannels().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderNotificationChannels) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPolicyFieldPathBuilder().NotificationChannels().FieldPath(),
	})
}

func (b *filterCndBuilderNotificationChannels) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPolicyFieldPathBuilder().NotificationChannels().FieldPath(),
	})
}

func (b *filterCndBuilderNotificationChannels) Contains(value *notification_channel.Reference) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewPolicyFieldPathBuilder().NotificationChannels().FieldPath(),
		Value:     NewPolicyFieldPathBuilder().NotificationChannels().WithItemValue(value),
	})
}

func (b *filterCndBuilderNotificationChannels) ContainsAnyOf(values []*notification_channel.Reference) *FilterBuilder {
	pathSelector := NewPolicyFieldPathBuilder().NotificationChannels()
	itemValues := make([]Policy_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewPolicyFieldPathBuilder().NotificationChannels().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderNotificationChannels) ContainsAll(values []*notification_channel.Reference) *FilterBuilder {
	pathSelector := NewPolicyFieldPathBuilder().NotificationChannels()
	itemValues := make([]Policy_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewPolicyFieldPathBuilder().NotificationChannels().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderNotificationChannels) compare(op gotenfilter.CompareOperator, value []*notification_channel.Reference) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Policy_FieldPathValue: NewPolicyFieldPathBuilder().NotificationChannels().WithValue(value),
	})
}