quality_profile.pb.filterbuilder.go

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

package quality_profile

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

// proto imports
import (
	ntt_meta "github.com/cloudwan/edgelq-sdk/common/types/meta"
	multi_region_policy "github.com/cloudwan/edgelq-sdk/common/types/multi_region_policy"
	monitoring_common "github.com/cloudwan/edgelq-sdk/monitoring/common/v3"
	project "github.com/cloudwan/watchdog-sdk/resources/v1alpha2/project"
	duration "github.com/golang/protobuf/ptypes/duration"
	timestamp "github.com/golang/protobuf/ptypes/timestamp"
)

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

// make sure we're using proto imports
var (
	_ = &ntt_meta.Meta{}
	_ = &multi_region_policy.MultiRegionPolicy{}
	_ = &monitoring_common.LabelDescriptor{}
	_ = &duration.Duration{}
	_ = &timestamp.Timestamp{}
	_ = &project.Project{}
)

type FilterBuilderOrCondition interface {
	_IsQualityProfileFilterBuilderOrCondition()
}

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

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

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

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

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

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

type filterCndBuilder struct {
	builder *FilterBuilder
}

func (b *filterCndBuilder) Name() *filterCndBuilderName {
	return &filterCndBuilderName{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) SourceProject() *filterCndBuilderSourceProject {
	return &filterCndBuilderSourceProject{builder: b.builder}
}

func (b *filterCndBuilder) Profiles() *filterCndBuilderProfiles {
	return &filterCndBuilderProfiles{builder: b.builder}
}

func (b *filterCndBuilder) Metadata() *filterCndBuilderMetadata {
	return &filterCndBuilderMetadata{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{
		QualityProfile_FieldPathArrayOfValues: NewQualityProfileFieldPathBuilder().Name().WithArrayOfValues(values),
	})
}

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

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

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

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

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

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

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

func (b *filterCndBuilderDisplayName) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                      op,
		QualityProfile_FieldPathValue: NewQualityProfileFieldPathBuilder().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{
		QualityProfile_FieldPathArrayOfValues: NewQualityProfileFieldPathBuilder().Description().WithArrayOfValues(values),
	})
}

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

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

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

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

type filterCndBuilderSourceProject struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSourceProject) In(values []*project.Reference) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		QualityProfile_FieldPathArrayOfValues: NewQualityProfileFieldPathBuilder().SourceProject().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSourceProject) NotIn(values []*project.Reference) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		QualityProfile_FieldPathArrayOfValues: NewQualityProfileFieldPathBuilder().SourceProject().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSourceProject) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewQualityProfileFieldPathBuilder().SourceProject().FieldPath(),
	})
}

func (b *filterCndBuilderSourceProject) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewQualityProfileFieldPathBuilder().SourceProject().FieldPath(),
	})
}

func (b *filterCndBuilderSourceProject) compare(op gotenfilter.CompareOperator, value *project.Reference) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                      op,
		QualityProfile_FieldPathValue: NewQualityProfileFieldPathBuilder().SourceProject().WithValue(value),
	})
}

type filterCndBuilderProfiles struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderProfiles) In(values [][]*Profile) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		QualityProfile_FieldPathArrayOfValues: NewQualityProfileFieldPathBuilder().Profiles().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderProfiles) NotIn(values [][]*Profile) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		QualityProfile_FieldPathArrayOfValues: NewQualityProfileFieldPathBuilder().Profiles().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderProfiles) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewQualityProfileFieldPathBuilder().Profiles().FieldPath(),
	})
}

func (b *filterCndBuilderProfiles) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewQualityProfileFieldPathBuilder().Profiles().FieldPath(),
	})
}

func (b *filterCndBuilderProfiles) Contains(value *Profile) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewQualityProfileFieldPathBuilder().Profiles().FieldPath(),
		Value:     NewQualityProfileFieldPathBuilder().Profiles().WithItemValue(value),
	})
}

func (b *filterCndBuilderProfiles) ContainsAnyOf(values []*Profile) *FilterBuilder {
	pathSelector := NewQualityProfileFieldPathBuilder().Profiles()
	itemValues := make([]QualityProfile_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewQualityProfileFieldPathBuilder().Profiles().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderProfiles) ContainsAll(values []*Profile) *FilterBuilder {
	pathSelector := NewQualityProfileFieldPathBuilder().Profiles()
	itemValues := make([]QualityProfile_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewQualityProfileFieldPathBuilder().Profiles().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderProfiles) compare(op gotenfilter.CompareOperator, value []*Profile) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                      op,
		QualityProfile_FieldPathValue: NewQualityProfileFieldPathBuilder().Profiles().WithValue(value),
	})
}

func (b *filterCndBuilderProfiles) DisplayName() *filterCndBuilderProfilesDisplayName {
	return &filterCndBuilderProfilesDisplayName{builder: b.builder}
}

func (b *filterCndBuilderProfiles) Description() *filterCndBuilderProfilesDescription {
	return &filterCndBuilderProfilesDescription{builder: b.builder}
}

func (b *filterCndBuilderProfiles) Filter() *filterCndBuilderProfilesFilter {
	return &filterCndBuilderProfilesFilter{builder: b.builder}
}

func (b *filterCndBuilderProfiles) MetricThresholds() *filterCndBuilderProfilesMetricThresholds {
	return &filterCndBuilderProfilesMetricThresholds{builder: b.builder}
}

func (b *filterCndBuilderProfiles) Overrides() *filterCndBuilderProfilesOverrides {
	return &filterCndBuilderProfilesOverrides{builder: b.builder}
}

type filterCndBuilderProfilesDisplayName struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderProfilesDisplayName) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		QualityProfile_FieldPathArrayOfValues: NewQualityProfileFieldPathBuilder().Profiles().DisplayName().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderProfilesDisplayName) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		QualityProfile_FieldPathArrayOfValues: NewQualityProfileFieldPathBuilder().Profiles().DisplayName().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderProfilesDisplayName) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewQualityProfileFieldPathBuilder().Profiles().DisplayName().FieldPath(),
	})
}

func (b *filterCndBuilderProfilesDisplayName) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewQualityProfileFieldPathBuilder().Profiles().DisplayName().FieldPath(),
	})
}

func (b *filterCndBuilderProfilesDisplayName) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                      op,
		QualityProfile_FieldPathValue: NewQualityProfileFieldPathBuilder().Profiles().DisplayName().WithValue(value),
	})
}

type filterCndBuilderProfilesDescription struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderProfilesDescription) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		QualityProfile_FieldPathArrayOfValues: NewQualityProfileFieldPathBuilder().Profiles().Description().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderProfilesDescription) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		QualityProfile_FieldPathArrayOfValues: NewQualityProfileFieldPathBuilder().Profiles().Description().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderProfilesDescription) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewQualityProfileFieldPathBuilder().Profiles().Description().FieldPath(),
	})
}

func (b *filterCndBuilderProfilesDescription) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewQualityProfileFieldPathBuilder().Profiles().Description().FieldPath(),
	})
}

func (b *filterCndBuilderProfilesDescription) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                      op,
		QualityProfile_FieldPathValue: NewQualityProfileFieldPathBuilder().Profiles().Description().WithValue(value),
	})
}

type filterCndBuilderProfilesFilter struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderProfilesFilter) Eq(value *Profile_Filter) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderProfilesFilter) Neq(value *Profile_Filter) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderProfilesFilter) Gt(value *Profile_Filter) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderProfilesFilter) Gte(value *Profile_Filter) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderProfilesFilter) Lt(value *Profile_Filter) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderProfilesFilter) Lte(value *Profile_Filter) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderProfilesFilter) In(values []*Profile_Filter) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		QualityProfile_FieldPathArrayOfValues: NewQualityProfileFieldPathBuilder().Profiles().Filter().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderProfilesFilter) NotIn(values []*Profile_Filter) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		QualityProfile_FieldPathArrayOfValues: NewQualityProfileFieldPathBuilder().Profiles().Filter().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderProfilesFilter) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewQualityProfileFieldPathBuilder().Profiles().Filter().FieldPath(),
	})
}

func (b *filterCndBuilderProfilesFilter) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewQualityProfileFieldPathBuilder().Profiles().Filter().FieldPath(),
	})
}

func (b *filterCndBuilderProfilesFilter) compare(op gotenfilter.CompareOperator, value *Profile_Filter) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                      op,
		QualityProfile_FieldPathValue: NewQualityProfileFieldPathBuilder().Profiles().Filter().WithValue(value),
	})
}

func (b *filterCndBuilderProfilesFilter) SourceLocations() *filterCndBuilderProfilesFilterSourceLocations {
	return &filterCndBuilderProfilesFilterSourceLocations{builder: b.builder}
}

func (b *filterCndBuilderProfilesFilter) SourceAsnNames() *filterCndBuilderProfilesFilterSourceAsnNames {
	return &filterCndBuilderProfilesFilterSourceAsnNames{builder: b.builder}
}

func (b *filterCndBuilderProfilesFilter) Targets() *filterCndBuilderProfilesFilterTargets {
	return &filterCndBuilderProfilesFilterTargets{builder: b.builder}
}

type filterCndBuilderProfilesFilterSourceLocations struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderProfilesFilterSourceLocations) In(values [][]*Profile_Location) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		QualityProfile_FieldPathArrayOfValues: NewQualityProfileFieldPathBuilder().Profiles().Filter().SourceLocations().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderProfilesFilterSourceLocations) NotIn(values [][]*Profile_Location) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		QualityProfile_FieldPathArrayOfValues: NewQualityProfileFieldPathBuilder().Profiles().Filter().SourceLocations().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderProfilesFilterSourceLocations) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewQualityProfileFieldPathBuilder().Profiles().Filter().SourceLocations().FieldPath(),
	})
}

func (b *filterCndBuilderProfilesFilterSourceLocations) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewQualityProfileFieldPathBuilder().Profiles().Filter().SourceLocations().FieldPath(),
	})
}

func (b *filterCndBuilderProfilesFilterSourceLocations) Contains(value *Profile_Location) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewQualityProfileFieldPathBuilder().Profiles().Filter().SourceLocations().FieldPath(),
		Value:     NewQualityProfileFieldPathBuilder().Profiles().Filter().SourceLocations().WithItemValue(value),
	})
}

func (b *filterCndBuilderProfilesFilterSourceLocations) ContainsAnyOf(values []*Profile_Location) *FilterBuilder {
	pathSelector := NewQualityProfileFieldPathBuilder().Profiles().Filter().SourceLocations()
	itemValues := make([]QualityProfile_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewQualityProfileFieldPathBuilder().Profiles().Filter().SourceLocations().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderProfilesFilterSourceLocations) ContainsAll(values []*Profile_Location) *FilterBuilder {
	pathSelector := NewQualityProfileFieldPathBuilder().Profiles().Filter().SourceLocations()
	itemValues := make([]QualityProfile_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewQualityProfileFieldPathBuilder().Profiles().Filter().SourceLocations().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderProfilesFilterSourceLocations) compare(op gotenfilter.CompareOperator, value []*Profile_Location) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                      op,
		QualityProfile_FieldPathValue: NewQualityProfileFieldPathBuilder().Profiles().Filter().SourceLocations().WithValue(value),
	})
}

func (b *filterCndBuilderProfilesFilterSourceLocations) CountryName() *filterCndBuilderProfilesFilterSourceLocationsCountryName {
	return &filterCndBuilderProfilesFilterSourceLocationsCountryName{builder: b.builder}
}

func (b *filterCndBuilderProfilesFilterSourceLocations) AdministrativeAreaLevel1Name() *filterCndBuilderProfilesFilterSourceLocationsAdministrativeAreaLevel1Name {
	return &filterCndBuilderProfilesFilterSourceLocationsAdministrativeAreaLevel1Name{builder: b.builder}
}

func (b *filterCndBuilderProfilesFilterSourceLocations) AdministrativeAreaLevel2Name() *filterCndBuilderProfilesFilterSourceLocationsAdministrativeAreaLevel2Name {
	return &filterCndBuilderProfilesFilterSourceLocationsAdministrativeAreaLevel2Name{builder: b.builder}
}

func (b *filterCndBuilderProfilesFilterSourceLocations) AdministrativeAreaLevel3Name() *filterCndBuilderProfilesFilterSourceLocationsAdministrativeAreaLevel3Name {
	return &filterCndBuilderProfilesFilterSourceLocationsAdministrativeAreaLevel3Name{builder: b.builder}
}

type filterCndBuilderProfilesFilterSourceLocationsCountryName struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderProfilesFilterSourceLocationsCountryName) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		QualityProfile_FieldPathArrayOfValues: NewQualityProfileFieldPathBuilder().Profiles().Filter().SourceLocations().CountryName().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderProfilesFilterSourceLocationsCountryName) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		QualityProfile_FieldPathArrayOfValues: NewQualityProfileFieldPathBuilder().Profiles().Filter().SourceLocations().CountryName().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderProfilesFilterSourceLocationsCountryName) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewQualityProfileFieldPathBuilder().Profiles().Filter().SourceLocations().CountryName().FieldPath(),
	})
}

func (b *filterCndBuilderProfilesFilterSourceLocationsCountryName) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewQualityProfileFieldPathBuilder().Profiles().Filter().SourceLocations().CountryName().FieldPath(),
	})
}

func (b *filterCndBuilderProfilesFilterSourceLocationsCountryName) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                      op,
		QualityProfile_FieldPathValue: NewQualityProfileFieldPathBuilder().Profiles().Filter().SourceLocations().CountryName().WithValue(value),
	})
}

type filterCndBuilderProfilesFilterSourceLocationsAdministrativeAreaLevel1Name struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderProfilesFilterSourceLocationsAdministrativeAreaLevel1Name) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		QualityProfile_FieldPathArrayOfValues: NewQualityProfileFieldPathBuilder().Profiles().Filter().SourceLocations().AdministrativeAreaLevel1Name().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderProfilesFilterSourceLocationsAdministrativeAreaLevel1Name) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		QualityProfile_FieldPathArrayOfValues: NewQualityProfileFieldPathBuilder().Profiles().Filter().SourceLocations().AdministrativeAreaLevel1Name().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderProfilesFilterSourceLocationsAdministrativeAreaLevel1Name) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewQualityProfileFieldPathBuilder().Profiles().Filter().SourceLocations().AdministrativeAreaLevel1Name().FieldPath(),
	})
}

func (b *filterCndBuilderProfilesFilterSourceLocationsAdministrativeAreaLevel1Name) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewQualityProfileFieldPathBuilder().Profiles().Filter().SourceLocations().AdministrativeAreaLevel1Name().FieldPath(),
	})
}

func (b *filterCndBuilderProfilesFilterSourceLocationsAdministrativeAreaLevel1Name) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                      op,
		QualityProfile_FieldPathValue: NewQualityProfileFieldPathBuilder().Profiles().Filter().SourceLocations().AdministrativeAreaLevel1Name().WithValue(value),
	})
}

type filterCndBuilderProfilesFilterSourceLocationsAdministrativeAreaLevel2Name struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderProfilesFilterSourceLocationsAdministrativeAreaLevel2Name) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		QualityProfile_FieldPathArrayOfValues: NewQualityProfileFieldPathBuilder().Profiles().Filter().SourceLocations().AdministrativeAreaLevel2Name().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderProfilesFilterSourceLocationsAdministrativeAreaLevel2Name) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		QualityProfile_FieldPathArrayOfValues: NewQualityProfileFieldPathBuilder().Profiles().Filter().SourceLocations().AdministrativeAreaLevel2Name().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderProfilesFilterSourceLocationsAdministrativeAreaLevel2Name) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewQualityProfileFieldPathBuilder().Profiles().Filter().SourceLocations().AdministrativeAreaLevel2Name().FieldPath(),
	})
}

func (b *filterCndBuilderProfilesFilterSourceLocationsAdministrativeAreaLevel2Name) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewQualityProfileFieldPathBuilder().Profiles().Filter().SourceLocations().AdministrativeAreaLevel2Name().FieldPath(),
	})
}

func (b *filterCndBuilderProfilesFilterSourceLocationsAdministrativeAreaLevel2Name) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                      op,
		QualityProfile_FieldPathValue: NewQualityProfileFieldPathBuilder().Profiles().Filter().SourceLocations().AdministrativeAreaLevel2Name().WithValue(value),
	})
}

type filterCndBuilderProfilesFilterSourceLocationsAdministrativeAreaLevel3Name struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderProfilesFilterSourceLocationsAdministrativeAreaLevel3Name) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		QualityProfile_FieldPathArrayOfValues: NewQualityProfileFieldPathBuilder().Profiles().Filter().SourceLocations().AdministrativeAreaLevel3Name().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderProfilesFilterSourceLocationsAdministrativeAreaLevel3Name) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		QualityProfile_FieldPathArrayOfValues: NewQualityProfileFieldPathBuilder().Profiles().Filter().SourceLocations().AdministrativeAreaLevel3Name().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderProfilesFilterSourceLocationsAdministrativeAreaLevel3Name) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewQualityProfileFieldPathBuilder().Profiles().Filter().SourceLocations().AdministrativeAreaLevel3Name().FieldPath(),
	})
}

func (b *filterCndBuilderProfilesFilterSourceLocationsAdministrativeAreaLevel3Name) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewQualityProfileFieldPathBuilder().Profiles().Filter().SourceLocations().AdministrativeAreaLevel3Name().FieldPath(),
	})
}

func (b *filterCndBuilderProfilesFilterSourceLocationsAdministrativeAreaLevel3Name) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                      op,
		QualityProfile_FieldPathValue: NewQualityProfileFieldPathBuilder().Profiles().Filter().SourceLocations().AdministrativeAreaLevel3Name().WithValue(value),
	})
}

type filterCndBuilderProfilesFilterSourceAsnNames struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderProfilesFilterSourceAsnNames) In(values [][]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		QualityProfile_FieldPathArrayOfValues: NewQualityProfileFieldPathBuilder().Profiles().Filter().SourceAsnNames().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderProfilesFilterSourceAsnNames) NotIn(values [][]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		QualityProfile_FieldPathArrayOfValues: NewQualityProfileFieldPathBuilder().Profiles().Filter().SourceAsnNames().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderProfilesFilterSourceAsnNames) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewQualityProfileFieldPathBuilder().Profiles().Filter().SourceAsnNames().FieldPath(),
	})
}

func (b *filterCndBuilderProfilesFilterSourceAsnNames) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewQualityProfileFieldPathBuilder().Profiles().Filter().SourceAsnNames().FieldPath(),
	})
}

func (b *filterCndBuilderProfilesFilterSourceAsnNames) Contains(value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewQualityProfileFieldPathBuilder().Profiles().Filter().SourceAsnNames().FieldPath(),
		Value:     NewQualityProfileFieldPathBuilder().Profiles().Filter().SourceAsnNames().WithItemValue(value),
	})
}

func (b *filterCndBuilderProfilesFilterSourceAsnNames) ContainsAnyOf(values []string) *FilterBuilder {
	pathSelector := NewQualityProfileFieldPathBuilder().Profiles().Filter().SourceAsnNames()
	itemValues := make([]QualityProfile_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewQualityProfileFieldPathBuilder().Profiles().Filter().SourceAsnNames().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderProfilesFilterSourceAsnNames) ContainsAll(values []string) *FilterBuilder {
	pathSelector := NewQualityProfileFieldPathBuilder().Profiles().Filter().SourceAsnNames()
	itemValues := make([]QualityProfile_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewQualityProfileFieldPathBuilder().Profiles().Filter().SourceAsnNames().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderProfilesFilterSourceAsnNames) compare(op gotenfilter.CompareOperator, value []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                      op,
		QualityProfile_FieldPathValue: NewQualityProfileFieldPathBuilder().Profiles().Filter().SourceAsnNames().WithValue(value),
	})
}

type filterCndBuilderProfilesFilterTargets struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderProfilesFilterTargets) In(values [][]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		QualityProfile_FieldPathArrayOfValues: NewQualityProfileFieldPathBuilder().Profiles().Filter().Targets().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderProfilesFilterTargets) NotIn(values [][]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		QualityProfile_FieldPathArrayOfValues: NewQualityProfileFieldPathBuilder().Profiles().Filter().Targets().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderProfilesFilterTargets) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewQualityProfileFieldPathBuilder().Profiles().Filter().Targets().FieldPath(),
	})
}

func (b *filterCndBuilderProfilesFilterTargets) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewQualityProfileFieldPathBuilder().Profiles().Filter().Targets().FieldPath(),
	})
}

func (b *filterCndBuilderProfilesFilterTargets) Contains(value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewQualityProfileFieldPathBuilder().Profiles().Filter().Targets().FieldPath(),
		Value:     NewQualityProfileFieldPathBuilder().Profiles().Filter().Targets().WithItemValue(value),
	})
}

func (b *filterCndBuilderProfilesFilterTargets) ContainsAnyOf(values []string) *FilterBuilder {
	pathSelector := NewQualityProfileFieldPathBuilder().Profiles().Filter().Targets()
	itemValues := make([]QualityProfile_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewQualityProfileFieldPathBuilder().Profiles().Filter().Targets().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderProfilesFilterTargets) ContainsAll(values []string) *FilterBuilder {
	pathSelector := NewQualityProfileFieldPathBuilder().Profiles().Filter().Targets()
	itemValues := make([]QualityProfile_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewQualityProfileFieldPathBuilder().Profiles().Filter().Targets().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderProfilesFilterTargets) compare(op gotenfilter.CompareOperator, value []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                      op,
		QualityProfile_FieldPathValue: NewQualityProfileFieldPathBuilder().Profiles().Filter().Targets().WithValue(value),
	})
}

type filterCndBuilderProfilesMetricThresholds struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderProfilesMetricThresholds) In(values [][]*Profile_MetricThreshold) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		QualityProfile_FieldPathArrayOfValues: NewQualityProfileFieldPathBuilder().Profiles().MetricThresholds().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderProfilesMetricThresholds) NotIn(values [][]*Profile_MetricThreshold) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		QualityProfile_FieldPathArrayOfValues: NewQualityProfileFieldPathBuilder().Profiles().MetricThresholds().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderProfilesMetricThresholds) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewQualityProfileFieldPathBuilder().Profiles().MetricThresholds().FieldPath(),
	})
}

func (b *filterCndBuilderProfilesMetricThresholds) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewQualityProfileFieldPathBuilder().Profiles().MetricThresholds().FieldPath(),
	})
}

func (b *filterCndBuilderProfilesMetricThresholds) Contains(value *Profile_MetricThreshold) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewQualityProfileFieldPathBuilder().Profiles().MetricThresholds().FieldPath(),
		Value:     NewQualityProfileFieldPathBuilder().Profiles().MetricThresholds().WithItemValue(value),
	})
}

func (b *filterCndBuilderProfilesMetricThresholds) ContainsAnyOf(values []*Profile_MetricThreshold) *FilterBuilder {
	pathSelector := NewQualityProfileFieldPathBuilder().Profiles().MetricThresholds()
	itemValues := make([]QualityProfile_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewQualityProfileFieldPathBuilder().Profiles().MetricThresholds().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderProfilesMetricThresholds) ContainsAll(values []*Profile_MetricThreshold) *FilterBuilder {
	pathSelector := NewQualityProfileFieldPathBuilder().Profiles().MetricThresholds()
	itemValues := make([]QualityProfile_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewQualityProfileFieldPathBuilder().Profiles().MetricThresholds().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderProfilesMetricThresholds) compare(op gotenfilter.CompareOperator, value []*Profile_MetricThreshold) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                      op,
		QualityProfile_FieldPathValue: NewQualityProfileFieldPathBuilder().Profiles().MetricThresholds().WithValue(value),
	})
}

func (b *filterCndBuilderProfilesMetricThresholds) AggregationReducer() *filterCndBuilderProfilesMetricThresholdsAggregationReducer {
	return &filterCndBuilderProfilesMetricThresholdsAggregationReducer{builder: b.builder}
}

func (b *filterCndBuilderProfilesMetricThresholds) MetricType() *filterCndBuilderProfilesMetricThresholdsMetricType {
	return &filterCndBuilderProfilesMetricThresholdsMetricType{builder: b.builder}
}

func (b *filterCndBuilderProfilesMetricThresholds) Value() *filterCndBuilderProfilesMetricThresholdsValue {
	return &filterCndBuilderProfilesMetricThresholdsValue{builder: b.builder}
}

type filterCndBuilderProfilesMetricThresholdsAggregationReducer struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderProfilesMetricThresholdsAggregationReducer) In(values []monitoring_common.Aggregation_Reducer) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		QualityProfile_FieldPathArrayOfValues: NewQualityProfileFieldPathBuilder().Profiles().MetricThresholds().AggregationReducer().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderProfilesMetricThresholdsAggregationReducer) NotIn(values []monitoring_common.Aggregation_Reducer) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		QualityProfile_FieldPathArrayOfValues: NewQualityProfileFieldPathBuilder().Profiles().MetricThresholds().AggregationReducer().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderProfilesMetricThresholdsAggregationReducer) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewQualityProfileFieldPathBuilder().Profiles().MetricThresholds().AggregationReducer().FieldPath(),
	})
}

func (b *filterCndBuilderProfilesMetricThresholdsAggregationReducer) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewQualityProfileFieldPathBuilder().Profiles().MetricThresholds().AggregationReducer().FieldPath(),
	})
}

func (b *filterCndBuilderProfilesMetricThresholdsAggregationReducer) compare(op gotenfilter.CompareOperator, value monitoring_common.Aggregation_Reducer) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                      op,
		QualityProfile_FieldPathValue: NewQualityProfileFieldPathBuilder().Profiles().MetricThresholds().AggregationReducer().WithValue(value),
	})
}

type filterCndBuilderProfilesMetricThresholdsMetricType struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderProfilesMetricThresholdsMetricType) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		QualityProfile_FieldPathArrayOfValues: NewQualityProfileFieldPathBuilder().Profiles().MetricThresholds().MetricType().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderProfilesMetricThresholdsMetricType) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		QualityProfile_FieldPathArrayOfValues: NewQualityProfileFieldPathBuilder().Profiles().MetricThresholds().MetricType().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderProfilesMetricThresholdsMetricType) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewQualityProfileFieldPathBuilder().Profiles().MetricThresholds().MetricType().FieldPath(),
	})
}

func (b *filterCndBuilderProfilesMetricThresholdsMetricType) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewQualityProfileFieldPathBuilder().Profiles().MetricThresholds().MetricType().FieldPath(),
	})
}

func (b *filterCndBuilderProfilesMetricThresholdsMetricType) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                      op,
		QualityProfile_FieldPathValue: NewQualityProfileFieldPathBuilder().Profiles().MetricThresholds().MetricType().WithValue(value),
	})
}

type filterCndBuilderProfilesMetricThresholdsValue struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderProfilesMetricThresholdsValue) In(values []float64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		QualityProfile_FieldPathArrayOfValues: NewQualityProfileFieldPathBuilder().Profiles().MetricThresholds().Value().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderProfilesMetricThresholdsValue) NotIn(values []float64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		QualityProfile_FieldPathArrayOfValues: NewQualityProfileFieldPathBuilder().Profiles().MetricThresholds().Value().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderProfilesMetricThresholdsValue) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewQualityProfileFieldPathBuilder().Profiles().MetricThresholds().Value().FieldPath(),
	})
}

func (b *filterCndBuilderProfilesMetricThresholdsValue) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewQualityProfileFieldPathBuilder().Profiles().MetricThresholds().Value().FieldPath(),
	})
}

func (b *filterCndBuilderProfilesMetricThresholdsValue) compare(op gotenfilter.CompareOperator, value float64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                      op,
		QualityProfile_FieldPathValue: NewQualityProfileFieldPathBuilder().Profiles().MetricThresholds().Value().WithValue(value),
	})
}

type filterCndBuilderProfilesOverrides struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderProfilesOverrides) In(values [][]*Profile) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		QualityProfile_FieldPathArrayOfValues: NewQualityProfileFieldPathBuilder().Profiles().Overrides().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderProfilesOverrides) NotIn(values [][]*Profile) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		QualityProfile_FieldPathArrayOfValues: NewQualityProfileFieldPathBuilder().Profiles().Overrides().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderProfilesOverrides) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewQualityProfileFieldPathBuilder().Profiles().Overrides().FieldPath(),
	})
}

func (b *filterCndBuilderProfilesOverrides) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewQualityProfileFieldPathBuilder().Profiles().Overrides().FieldPath(),
	})
}

func (b *filterCndBuilderProfilesOverrides) Contains(value *Profile) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewQualityProfileFieldPathBuilder().Profiles().Overrides().FieldPath(),
		Value:     NewQualityProfileFieldPathBuilder().Profiles().Overrides().WithItemValue(value),
	})
}

func (b *filterCndBuilderProfilesOverrides) ContainsAnyOf(values []*Profile) *FilterBuilder {
	pathSelector := NewQualityProfileFieldPathBuilder().Profiles().Overrides()
	itemValues := make([]QualityProfile_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewQualityProfileFieldPathBuilder().Profiles().Overrides().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderProfilesOverrides) ContainsAll(values []*Profile) *FilterBuilder {
	pathSelector := NewQualityProfileFieldPathBuilder().Profiles().Overrides()
	itemValues := make([]QualityProfile_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewQualityProfileFieldPathBuilder().Profiles().Overrides().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderProfilesOverrides) compare(op gotenfilter.CompareOperator, value []*Profile) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                      op,
		QualityProfile_FieldPathValue: NewQualityProfileFieldPathBuilder().Profiles().Overrides().WithValue(value),
	})
}

type filterCndBuilderMetadata struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

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

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

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

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

func (b *filterCndBuilderMetadata) compare(op gotenfilter.CompareOperator, value *ntt_meta.Meta) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                      op,
		QualityProfile_FieldPathValue: NewQualityProfileFieldPathBuilder().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}
}

type filterCndBuilderMetadataCreateTime struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

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

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

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

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

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

type filterCndBuilderMetadataUpdateTime struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

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

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

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

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

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

type filterCndBuilderMetadataDeleteTime struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

type filterCndBuilderMetadataOwnerReferences struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

type filterCndBuilderMetadataOwnerReferencesKind struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

type filterCndBuilderMetadataOwnerReferencesBlockOwnerDeletion struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderMetadataOwnerReferencesBlockOwnerDeletion) In(values []bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		QualityProfile_FieldPathArrayOfValues: NewQualityProfileFieldPathBuilder().Metadata().OwnerReferences().BlockOwnerDeletion().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderMetadataOwnerReferencesBlockOwnerDeletion) NotIn(values []bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		QualityProfile_FieldPathArrayOfValues: NewQualityProfileFieldPathBuilder().Metadata().OwnerReferences().BlockOwnerDeletion().WithArrayOfValues(values),
	})
}

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

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

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

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

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

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

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

type filterCndBuilderMetadataShards struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

type filterCndBuilderMetadataSyncing struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

type filterCndBuilderMetadataLifecycle struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

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

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

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

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

func (b *filterCndBuilderMetadataLifecycle) compare(op gotenfilter.CompareOperator, value *ntt_meta.Lifecycle) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                      op,
		QualityProfile_FieldPathValue: NewQualityProfileFieldPathBuilder().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 ntt_meta.Lifecycle_State) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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