github.com/cloudwan/edgelq-sdk@v1.15.4/iam/resources/v1/role/role.pb.filterbuilder.go

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

package role

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

// proto imports
import (
	attestation_domain "github.com/cloudwan/edgelq-sdk/iam/resources/v1/attestation_domain"
	iam_common "github.com/cloudwan/edgelq-sdk/iam/resources/v1/common"
	condition "github.com/cloudwan/edgelq-sdk/iam/resources/v1/condition"
	organization "github.com/cloudwan/edgelq-sdk/iam/resources/v1/organization"
	permission "github.com/cloudwan/edgelq-sdk/iam/resources/v1/permission"
	project "github.com/cloudwan/edgelq-sdk/iam/resources/v1/project"
	meta_common "github.com/cloudwan/goten-sdk/meta-service/resources/v1/common"
	meta_service "github.com/cloudwan/goten-sdk/meta-service/resources/v1/service"
	meta "github.com/cloudwan/goten-sdk/types/meta"
	multi_region_policy "github.com/cloudwan/goten-sdk/types/multi_region_policy"
	structpb "google.golang.org/protobuf/types/known/structpb"
	timestamppb "google.golang.org/protobuf/types/known/timestamppb"
)

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

// make sure we're using proto imports
var (
	_ = &attestation_domain.AttestationDomain{}
	_ = &iam_common.PCR{}
	_ = &condition.Condition{}
	_ = &organization.Organization{}
	_ = &permission.Permission{}
	_ = &project.Project{}
	_ = &structpb.Struct{}
	_ = &timestamppb.Timestamp{}
	_ = &meta_common.LabelledDomain{}
	_ = &meta_service.Service{}
	_ = &meta.Meta{}
	_ = &multi_region_policy.MultiRegionPolicy{}
)

type FilterBuilderOrCondition interface {
	_IsRoleFilterBuilderOrCondition()
}

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

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

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

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

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

func (b *filterCndBuilderAnyPath) Contains(value interface{}) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: b.fp,
		Value:     b.fp.WithIArrayItemValue(value),
	})
}

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

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

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

type filterCndBuilder struct {
	builder *FilterBuilder
}

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

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

func (b *filterCndBuilder) DisplayName() *filterCndBuilderDisplayName {
	return &filterCndBuilderDisplayName{builder: b.builder}
}

func (b *filterCndBuilder) Description() *filterCndBuilderDescription {
	return &filterCndBuilderDescription{builder: b.builder}
}

func (b *filterCndBuilder) Category() *filterCndBuilderCategory {
	return &filterCndBuilderCategory{builder: b.builder}
}

func (b *filterCndBuilder) ScopeParams() *filterCndBuilderScopeParams {
	return &filterCndBuilderScopeParams{builder: b.builder}
}

func (b *filterCndBuilder) ConstValues() *filterCndBuilderConstValues {
	return &filterCndBuilderConstValues{builder: b.builder}
}

func (b *filterCndBuilder) DefaultValues() *filterCndBuilderDefaultValues {
	return &filterCndBuilderDefaultValues{builder: b.builder}
}

func (b *filterCndBuilder) Grants() *filterCndBuilderGrants {
	return &filterCndBuilderGrants{builder: b.builder}
}

func (b *filterCndBuilder) OwnedObjects() *filterCndBuilderOwnedObjects {
	return &filterCndBuilderOwnedObjects{builder: b.builder}
}

func (b *filterCndBuilder) Services() *filterCndBuilderServices {
	return &filterCndBuilderServices{builder: b.builder}
}

func (b *filterCndBuilder) RbSpecGeneration() *filterCndBuilderRbSpecGeneration {
	return &filterCndBuilderRbSpecGeneration{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{
		Role_FieldPathArrayOfValues: NewRoleFieldPathBuilder().Name().WithArrayOfValues(values),
	})
}

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

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

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

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

type filterCndBuilderMetadata struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

type filterCndBuilderMetadataCreateTime struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

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

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

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

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

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

type filterCndBuilderMetadataUpdateTime struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

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

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

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

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

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

type filterCndBuilderMetadataDeleteTime struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

type filterCndBuilderMetadataOwnerReferences struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func (b *filterCndBuilderMetadataOwnerReferences) UnsetOnDelete() *filterCndBuilderMetadataOwnerReferencesUnsetOnDelete {
	return &filterCndBuilderMetadataOwnerReferencesUnsetOnDelete{builder: b.builder}
}

type filterCndBuilderMetadataOwnerReferencesKind struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

type filterCndBuilderMetadataOwnerReferencesRequiresOwnerReference struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

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

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

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

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

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

type filterCndBuilderMetadataOwnerReferencesUnsetOnDelete struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

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

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

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

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

func (b *filterCndBuilderMetadataOwnerReferencesUnsetOnDelete) compare(op gotenfilter.CompareOperator, value bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:            op,
		Role_FieldPathValue: NewRoleFieldPathBuilder().Metadata().OwnerReferences().UnsetOnDelete().WithValue(value),
	})
}

type filterCndBuilderMetadataShards struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

type filterCndBuilderMetadataSyncing struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

type filterCndBuilderMetadataLifecycle struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

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

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

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

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

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

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

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

type filterCndBuilderMetadataLifecycleState struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

type filterCndBuilderMetadataServices struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

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

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

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

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

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

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

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

type filterCndBuilderMetadataServicesOwningService struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

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

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

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

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

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

type filterCndBuilderMetadataServicesAllowedServices struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

type filterCndBuilderDisplayName struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

type filterCndBuilderCategory struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderCategory) Eq(value Role_Category) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderCategory) Neq(value Role_Category) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderCategory) Gt(value Role_Category) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderCategory) Gte(value Role_Category) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderCategory) Lt(value Role_Category) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderCategory) Lte(value Role_Category) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderCategory) In(values []Role_Category) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Role_FieldPathArrayOfValues: NewRoleFieldPathBuilder().Category().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderCategory) NotIn(values []Role_Category) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Role_FieldPathArrayOfValues: NewRoleFieldPathBuilder().Category().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderCategory) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewRoleFieldPathBuilder().Category().FieldPath(),
	})
}

func (b *filterCndBuilderCategory) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewRoleFieldPathBuilder().Category().FieldPath(),
	})
}

func (b *filterCndBuilderCategory) compare(op gotenfilter.CompareOperator, value Role_Category) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:            op,
		Role_FieldPathValue: NewRoleFieldPathBuilder().Category().WithValue(value),
	})
}

type filterCndBuilderScopeParams struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderScopeParams) In(values [][]*Role_ScopeParamType) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Role_FieldPathArrayOfValues: NewRoleFieldPathBuilder().ScopeParams().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderScopeParams) NotIn(values [][]*Role_ScopeParamType) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Role_FieldPathArrayOfValues: NewRoleFieldPathBuilder().ScopeParams().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderScopeParams) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewRoleFieldPathBuilder().ScopeParams().FieldPath(),
	})
}

func (b *filterCndBuilderScopeParams) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewRoleFieldPathBuilder().ScopeParams().FieldPath(),
	})
}

func (b *filterCndBuilderScopeParams) Contains(value *Role_ScopeParamType) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewRoleFieldPathBuilder().ScopeParams().FieldPath(),
		Value:     NewRoleFieldPathBuilder().ScopeParams().WithItemValue(value),
	})
}

func (b *filterCndBuilderScopeParams) ContainsAnyOf(values []*Role_ScopeParamType) *FilterBuilder {
	pathSelector := NewRoleFieldPathBuilder().ScopeParams()
	itemValues := make([]Role_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewRoleFieldPathBuilder().ScopeParams().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderScopeParams) ContainsAll(values []*Role_ScopeParamType) *FilterBuilder {
	pathSelector := NewRoleFieldPathBuilder().ScopeParams()
	itemValues := make([]Role_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewRoleFieldPathBuilder().ScopeParams().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderScopeParams) compare(op gotenfilter.CompareOperator, value []*Role_ScopeParamType) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:            op,
		Role_FieldPathValue: NewRoleFieldPathBuilder().ScopeParams().WithValue(value),
	})
}

func (b *filterCndBuilderScopeParams) Name() *filterCndBuilderScopeParamsName {
	return &filterCndBuilderScopeParamsName{builder: b.builder}
}

func (b *filterCndBuilderScopeParams) Type() *filterCndBuilderScopeParamsType {
	return &filterCndBuilderScopeParamsType{builder: b.builder}
}

type filterCndBuilderScopeParamsName struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderScopeParamsName) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Role_FieldPathArrayOfValues: NewRoleFieldPathBuilder().ScopeParams().Name().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderScopeParamsName) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Role_FieldPathArrayOfValues: NewRoleFieldPathBuilder().ScopeParams().Name().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderScopeParamsName) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewRoleFieldPathBuilder().ScopeParams().Name().FieldPath(),
	})
}

func (b *filterCndBuilderScopeParamsName) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewRoleFieldPathBuilder().ScopeParams().Name().FieldPath(),
	})
}

func (b *filterCndBuilderScopeParamsName) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:            op,
		Role_FieldPathValue: NewRoleFieldPathBuilder().ScopeParams().Name().WithValue(value),
	})
}

type filterCndBuilderScopeParamsType struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderScopeParamsType) Eq(value Role_ScopeParamType_Type) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderScopeParamsType) Neq(value Role_ScopeParamType_Type) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderScopeParamsType) Gt(value Role_ScopeParamType_Type) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderScopeParamsType) Gte(value Role_ScopeParamType_Type) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderScopeParamsType) Lt(value Role_ScopeParamType_Type) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderScopeParamsType) Lte(value Role_ScopeParamType_Type) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderScopeParamsType) In(values []Role_ScopeParamType_Type) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Role_FieldPathArrayOfValues: NewRoleFieldPathBuilder().ScopeParams().Type().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderScopeParamsType) NotIn(values []Role_ScopeParamType_Type) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Role_FieldPathArrayOfValues: NewRoleFieldPathBuilder().ScopeParams().Type().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderScopeParamsType) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewRoleFieldPathBuilder().ScopeParams().Type().FieldPath(),
	})
}

func (b *filterCndBuilderScopeParamsType) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewRoleFieldPathBuilder().ScopeParams().Type().FieldPath(),
	})
}

func (b *filterCndBuilderScopeParamsType) compare(op gotenfilter.CompareOperator, value Role_ScopeParamType_Type) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:            op,
		Role_FieldPathValue: NewRoleFieldPathBuilder().ScopeParams().Type().WithValue(value),
	})
}

type filterCndBuilderConstValues struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderConstValues) In(values [][]*ScopeParam) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Role_FieldPathArrayOfValues: NewRoleFieldPathBuilder().ConstValues().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderConstValues) NotIn(values [][]*ScopeParam) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Role_FieldPathArrayOfValues: NewRoleFieldPathBuilder().ConstValues().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderConstValues) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewRoleFieldPathBuilder().ConstValues().FieldPath(),
	})
}

func (b *filterCndBuilderConstValues) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewRoleFieldPathBuilder().ConstValues().FieldPath(),
	})
}

func (b *filterCndBuilderConstValues) Contains(value *ScopeParam) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewRoleFieldPathBuilder().ConstValues().FieldPath(),
		Value:     NewRoleFieldPathBuilder().ConstValues().WithItemValue(value),
	})
}

func (b *filterCndBuilderConstValues) ContainsAnyOf(values []*ScopeParam) *FilterBuilder {
	pathSelector := NewRoleFieldPathBuilder().ConstValues()
	itemValues := make([]Role_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewRoleFieldPathBuilder().ConstValues().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderConstValues) ContainsAll(values []*ScopeParam) *FilterBuilder {
	pathSelector := NewRoleFieldPathBuilder().ConstValues()
	itemValues := make([]Role_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewRoleFieldPathBuilder().ConstValues().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderConstValues) compare(op gotenfilter.CompareOperator, value []*ScopeParam) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:            op,
		Role_FieldPathValue: NewRoleFieldPathBuilder().ConstValues().WithValue(value),
	})
}

func (b *filterCndBuilderConstValues) Name() *filterCndBuilderConstValuesName {
	return &filterCndBuilderConstValuesName{builder: b.builder}
}

func (b *filterCndBuilderConstValues) String_() *filterCndBuilderConstValuesString {
	return &filterCndBuilderConstValuesString{builder: b.builder}
}

func (b *filterCndBuilderConstValues) Strings() *filterCndBuilderConstValuesStrings {
	return &filterCndBuilderConstValuesStrings{builder: b.builder}
}

func (b *filterCndBuilderConstValues) ValueFrom() *filterCndBuilderConstValuesValueFrom {
	return &filterCndBuilderConstValuesValueFrom{builder: b.builder}
}

type filterCndBuilderConstValuesName struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderConstValuesName) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Role_FieldPathArrayOfValues: NewRoleFieldPathBuilder().ConstValues().Name().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderConstValuesName) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Role_FieldPathArrayOfValues: NewRoleFieldPathBuilder().ConstValues().Name().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderConstValuesName) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewRoleFieldPathBuilder().ConstValues().Name().FieldPath(),
	})
}

func (b *filterCndBuilderConstValuesName) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewRoleFieldPathBuilder().ConstValues().Name().FieldPath(),
	})
}

func (b *filterCndBuilderConstValuesName) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:            op,
		Role_FieldPathValue: NewRoleFieldPathBuilder().ConstValues().Name().WithValue(value),
	})
}

type filterCndBuilderConstValuesString struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderConstValuesString) Eq(value *ScopeParam_StringValue) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderConstValuesString) Neq(value *ScopeParam_StringValue) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderConstValuesString) Gt(value *ScopeParam_StringValue) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderConstValuesString) Gte(value *ScopeParam_StringValue) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderConstValuesString) Lt(value *ScopeParam_StringValue) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderConstValuesString) Lte(value *ScopeParam_StringValue) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderConstValuesString) In(values []*ScopeParam_StringValue) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Role_FieldPathArrayOfValues: NewRoleFieldPathBuilder().ConstValues().String_().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderConstValuesString) NotIn(values []*ScopeParam_StringValue) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Role_FieldPathArrayOfValues: NewRoleFieldPathBuilder().ConstValues().String_().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderConstValuesString) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewRoleFieldPathBuilder().ConstValues().String_().FieldPath(),
	})
}

func (b *filterCndBuilderConstValuesString) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewRoleFieldPathBuilder().ConstValues().String_().FieldPath(),
	})
}

func (b *filterCndBuilderConstValuesString) compare(op gotenfilter.CompareOperator, value *ScopeParam_StringValue) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:            op,
		Role_FieldPathValue: NewRoleFieldPathBuilder().ConstValues().String_().WithValue(value),
	})
}

func (b *filterCndBuilderConstValuesString) Value() *filterCndBuilderConstValuesStringValue {
	return &filterCndBuilderConstValuesStringValue{builder: b.builder}
}

type filterCndBuilderConstValuesStringValue struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderConstValuesStringValue) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Role_FieldPathArrayOfValues: NewRoleFieldPathBuilder().ConstValues().String_().Value().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderConstValuesStringValue) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Role_FieldPathArrayOfValues: NewRoleFieldPathBuilder().ConstValues().String_().Value().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderConstValuesStringValue) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewRoleFieldPathBuilder().ConstValues().String_().Value().FieldPath(),
	})
}

func (b *filterCndBuilderConstValuesStringValue) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewRoleFieldPathBuilder().ConstValues().String_().Value().FieldPath(),
	})
}

func (b *filterCndBuilderConstValuesStringValue) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:            op,
		Role_FieldPathValue: NewRoleFieldPathBuilder().ConstValues().String_().Value().WithValue(value),
	})
}

type filterCndBuilderConstValuesStrings struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderConstValuesStrings) Eq(value *ScopeParam_ArrayOfStringsValue) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderConstValuesStrings) Neq(value *ScopeParam_ArrayOfStringsValue) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderConstValuesStrings) Gt(value *ScopeParam_ArrayOfStringsValue) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderConstValuesStrings) Gte(value *ScopeParam_ArrayOfStringsValue) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderConstValuesStrings) Lt(value *ScopeParam_ArrayOfStringsValue) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderConstValuesStrings) Lte(value *ScopeParam_ArrayOfStringsValue) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderConstValuesStrings) In(values []*ScopeParam_ArrayOfStringsValue) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Role_FieldPathArrayOfValues: NewRoleFieldPathBuilder().ConstValues().Strings().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderConstValuesStrings) NotIn(values []*ScopeParam_ArrayOfStringsValue) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Role_FieldPathArrayOfValues: NewRoleFieldPathBuilder().ConstValues().Strings().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderConstValuesStrings) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewRoleFieldPathBuilder().ConstValues().Strings().FieldPath(),
	})
}

func (b *filterCndBuilderConstValuesStrings) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewRoleFieldPathBuilder().ConstValues().Strings().FieldPath(),
	})
}

func (b *filterCndBuilderConstValuesStrings) compare(op gotenfilter.CompareOperator, value *ScopeParam_ArrayOfStringsValue) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:            op,
		Role_FieldPathValue: NewRoleFieldPathBuilder().ConstValues().Strings().WithValue(value),
	})
}

func (b *filterCndBuilderConstValuesStrings) Values() *filterCndBuilderConstValuesStringsValues {
	return &filterCndBuilderConstValuesStringsValues{builder: b.builder}
}

type filterCndBuilderConstValuesStringsValues struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderConstValuesStringsValues) In(values [][]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Role_FieldPathArrayOfValues: NewRoleFieldPathBuilder().ConstValues().Strings().Values().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderConstValuesStringsValues) NotIn(values [][]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Role_FieldPathArrayOfValues: NewRoleFieldPathBuilder().ConstValues().Strings().Values().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderConstValuesStringsValues) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewRoleFieldPathBuilder().ConstValues().Strings().Values().FieldPath(),
	})
}

func (b *filterCndBuilderConstValuesStringsValues) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewRoleFieldPathBuilder().ConstValues().Strings().Values().FieldPath(),
	})
}

func (b *filterCndBuilderConstValuesStringsValues) Contains(value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewRoleFieldPathBuilder().ConstValues().Strings().Values().FieldPath(),
		Value:     NewRoleFieldPathBuilder().ConstValues().Strings().Values().WithItemValue(value),
	})
}

func (b *filterCndBuilderConstValuesStringsValues) ContainsAnyOf(values []string) *FilterBuilder {
	pathSelector := NewRoleFieldPathBuilder().ConstValues().Strings().Values()
	itemValues := make([]Role_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewRoleFieldPathBuilder().ConstValues().Strings().Values().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderConstValuesStringsValues) ContainsAll(values []string) *FilterBuilder {
	pathSelector := NewRoleFieldPathBuilder().ConstValues().Strings().Values()
	itemValues := make([]Role_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewRoleFieldPathBuilder().ConstValues().Strings().Values().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderConstValuesStringsValues) compare(op gotenfilter.CompareOperator, value []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:            op,
		Role_FieldPathValue: NewRoleFieldPathBuilder().ConstValues().Strings().Values().WithValue(value),
	})
}

type filterCndBuilderConstValuesValueFrom struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderConstValuesValueFrom) Eq(value *ScopeParam_FromValue) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderConstValuesValueFrom) Neq(value *ScopeParam_FromValue) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderConstValuesValueFrom) Gt(value *ScopeParam_FromValue) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderConstValuesValueFrom) Gte(value *ScopeParam_FromValue) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderConstValuesValueFrom) Lt(value *ScopeParam_FromValue) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderConstValuesValueFrom) Lte(value *ScopeParam_FromValue) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderConstValuesValueFrom) In(values []*ScopeParam_FromValue) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Role_FieldPathArrayOfValues: NewRoleFieldPathBuilder().ConstValues().ValueFrom().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderConstValuesValueFrom) NotIn(values []*ScopeParam_FromValue) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Role_FieldPathArrayOfValues: NewRoleFieldPathBuilder().ConstValues().ValueFrom().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderConstValuesValueFrom) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewRoleFieldPathBuilder().ConstValues().ValueFrom().FieldPath(),
	})
}

func (b *filterCndBuilderConstValuesValueFrom) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewRoleFieldPathBuilder().ConstValues().ValueFrom().FieldPath(),
	})
}

func (b *filterCndBuilderConstValuesValueFrom) compare(op gotenfilter.CompareOperator, value *ScopeParam_FromValue) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:            op,
		Role_FieldPathValue: NewRoleFieldPathBuilder().ConstValues().ValueFrom().WithValue(value),
	})
}

func (b *filterCndBuilderConstValuesValueFrom) Source() *filterCndBuilderConstValuesValueFromSource {
	return &filterCndBuilderConstValuesValueFromSource{builder: b.builder}
}

func (b *filterCndBuilderConstValuesValueFrom) Path() *filterCndBuilderConstValuesValueFromPath {
	return &filterCndBuilderConstValuesValueFromPath{builder: b.builder}
}

type filterCndBuilderConstValuesValueFromSource struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderConstValuesValueFromSource) Eq(value ScopeParam_FromValue_Source) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderConstValuesValueFromSource) Neq(value ScopeParam_FromValue_Source) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderConstValuesValueFromSource) Gt(value ScopeParam_FromValue_Source) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderConstValuesValueFromSource) Gte(value ScopeParam_FromValue_Source) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderConstValuesValueFromSource) Lt(value ScopeParam_FromValue_Source) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderConstValuesValueFromSource) Lte(value ScopeParam_FromValue_Source) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderConstValuesValueFromSource) In(values []ScopeParam_FromValue_Source) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Role_FieldPathArrayOfValues: NewRoleFieldPathBuilder().ConstValues().ValueFrom().Source().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderConstValuesValueFromSource) NotIn(values []ScopeParam_FromValue_Source) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Role_FieldPathArrayOfValues: NewRoleFieldPathBuilder().ConstValues().ValueFrom().Source().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderConstValuesValueFromSource) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewRoleFieldPathBuilder().ConstValues().ValueFrom().Source().FieldPath(),
	})
}

func (b *filterCndBuilderConstValuesValueFromSource) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewRoleFieldPathBuilder().ConstValues().ValueFrom().Source().FieldPath(),
	})
}

func (b *filterCndBuilderConstValuesValueFromSource) compare(op gotenfilter.CompareOperator, value ScopeParam_FromValue_Source) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:            op,
		Role_FieldPathValue: NewRoleFieldPathBuilder().ConstValues().ValueFrom().Source().WithValue(value),
	})
}

type filterCndBuilderConstValuesValueFromPath struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderConstValuesValueFromPath) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Role_FieldPathArrayOfValues: NewRoleFieldPathBuilder().ConstValues().ValueFrom().Path().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderConstValuesValueFromPath) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Role_FieldPathArrayOfValues: NewRoleFieldPathBuilder().ConstValues().ValueFrom().Path().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderConstValuesValueFromPath) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewRoleFieldPathBuilder().ConstValues().ValueFrom().Path().FieldPath(),
	})
}

func (b *filterCndBuilderConstValuesValueFromPath) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewRoleFieldPathBuilder().ConstValues().ValueFrom().Path().FieldPath(),
	})
}

func (b *filterCndBuilderConstValuesValueFromPath) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:            op,
		Role_FieldPathValue: NewRoleFieldPathBuilder().ConstValues().ValueFrom().Path().WithValue(value),
	})
}

type filterCndBuilderDefaultValues struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderDefaultValues) In(values [][]*ScopeParam) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Role_FieldPathArrayOfValues: NewRoleFieldPathBuilder().DefaultValues().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderDefaultValues) NotIn(values [][]*ScopeParam) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Role_FieldPathArrayOfValues: NewRoleFieldPathBuilder().DefaultValues().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderDefaultValues) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewRoleFieldPathBuilder().DefaultValues().FieldPath(),
	})
}

func (b *filterCndBuilderDefaultValues) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewRoleFieldPathBuilder().DefaultValues().FieldPath(),
	})
}

func (b *filterCndBuilderDefaultValues) Contains(value *ScopeParam) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewRoleFieldPathBuilder().DefaultValues().FieldPath(),
		Value:     NewRoleFieldPathBuilder().DefaultValues().WithItemValue(value),
	})
}

func (b *filterCndBuilderDefaultValues) ContainsAnyOf(values []*ScopeParam) *FilterBuilder {
	pathSelector := NewRoleFieldPathBuilder().DefaultValues()
	itemValues := make([]Role_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewRoleFieldPathBuilder().DefaultValues().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderDefaultValues) ContainsAll(values []*ScopeParam) *FilterBuilder {
	pathSelector := NewRoleFieldPathBuilder().DefaultValues()
	itemValues := make([]Role_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewRoleFieldPathBuilder().DefaultValues().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderDefaultValues) compare(op gotenfilter.CompareOperator, value []*ScopeParam) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:            op,
		Role_FieldPathValue: NewRoleFieldPathBuilder().DefaultValues().WithValue(value),
	})
}

func (b *filterCndBuilderDefaultValues) Name() *filterCndBuilderDefaultValuesName {
	return &filterCndBuilderDefaultValuesName{builder: b.builder}
}

func (b *filterCndBuilderDefaultValues) String_() *filterCndBuilderDefaultValuesString {
	return &filterCndBuilderDefaultValuesString{builder: b.builder}
}

func (b *filterCndBuilderDefaultValues) Strings() *filterCndBuilderDefaultValuesStrings {
	return &filterCndBuilderDefaultValuesStrings{builder: b.builder}
}

func (b *filterCndBuilderDefaultValues) ValueFrom() *filterCndBuilderDefaultValuesValueFrom {
	return &filterCndBuilderDefaultValuesValueFrom{builder: b.builder}
}

type filterCndBuilderDefaultValuesName struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderDefaultValuesName) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Role_FieldPathArrayOfValues: NewRoleFieldPathBuilder().DefaultValues().Name().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderDefaultValuesName) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Role_FieldPathArrayOfValues: NewRoleFieldPathBuilder().DefaultValues().Name().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderDefaultValuesName) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewRoleFieldPathBuilder().DefaultValues().Name().FieldPath(),
	})
}

func (b *filterCndBuilderDefaultValuesName) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewRoleFieldPathBuilder().DefaultValues().Name().FieldPath(),
	})
}

func (b *filterCndBuilderDefaultValuesName) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:            op,
		Role_FieldPathValue: NewRoleFieldPathBuilder().DefaultValues().Name().WithValue(value),
	})
}

type filterCndBuilderDefaultValuesString struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderDefaultValuesString) Eq(value *ScopeParam_StringValue) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderDefaultValuesString) Neq(value *ScopeParam_StringValue) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderDefaultValuesString) Gt(value *ScopeParam_StringValue) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderDefaultValuesString) Gte(value *ScopeParam_StringValue) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderDefaultValuesString) Lt(value *ScopeParam_StringValue) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderDefaultValuesString) Lte(value *ScopeParam_StringValue) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderDefaultValuesString) In(values []*ScopeParam_StringValue) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Role_FieldPathArrayOfValues: NewRoleFieldPathBuilder().DefaultValues().String_().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderDefaultValuesString) NotIn(values []*ScopeParam_StringValue) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Role_FieldPathArrayOfValues: NewRoleFieldPathBuilder().DefaultValues().String_().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderDefaultValuesString) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewRoleFieldPathBuilder().DefaultValues().String_().FieldPath(),
	})
}

func (b *filterCndBuilderDefaultValuesString) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewRoleFieldPathBuilder().DefaultValues().String_().FieldPath(),
	})
}

func (b *filterCndBuilderDefaultValuesString) compare(op gotenfilter.CompareOperator, value *ScopeParam_StringValue) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:            op,
		Role_FieldPathValue: NewRoleFieldPathBuilder().DefaultValues().String_().WithValue(value),
	})
}

func (b *filterCndBuilderDefaultValuesString) Value() *filterCndBuilderDefaultValuesStringValue {
	return &filterCndBuilderDefaultValuesStringValue{builder: b.builder}
}

type filterCndBuilderDefaultValuesStringValue struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderDefaultValuesStringValue) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Role_FieldPathArrayOfValues: NewRoleFieldPathBuilder().DefaultValues().String_().Value().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderDefaultValuesStringValue) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Role_FieldPathArrayOfValues: NewRoleFieldPathBuilder().DefaultValues().String_().Value().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderDefaultValuesStringValue) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewRoleFieldPathBuilder().DefaultValues().String_().Value().FieldPath(),
	})
}

func (b *filterCndBuilderDefaultValuesStringValue) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewRoleFieldPathBuilder().DefaultValues().String_().Value().FieldPath(),
	})
}

func (b *filterCndBuilderDefaultValuesStringValue) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:            op,
		Role_FieldPathValue: NewRoleFieldPathBuilder().DefaultValues().String_().Value().WithValue(value),
	})
}

type filterCndBuilderDefaultValuesStrings struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderDefaultValuesStrings) Eq(value *ScopeParam_ArrayOfStringsValue) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderDefaultValuesStrings) Neq(value *ScopeParam_ArrayOfStringsValue) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderDefaultValuesStrings) Gt(value *ScopeParam_ArrayOfStringsValue) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderDefaultValuesStrings) Gte(value *ScopeParam_ArrayOfStringsValue) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderDefaultValuesStrings) Lt(value *ScopeParam_ArrayOfStringsValue) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderDefaultValuesStrings) Lte(value *ScopeParam_ArrayOfStringsValue) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderDefaultValuesStrings) In(values []*ScopeParam_ArrayOfStringsValue) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Role_FieldPathArrayOfValues: NewRoleFieldPathBuilder().DefaultValues().Strings().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderDefaultValuesStrings) NotIn(values []*ScopeParam_ArrayOfStringsValue) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Role_FieldPathArrayOfValues: NewRoleFieldPathBuilder().DefaultValues().Strings().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderDefaultValuesStrings) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewRoleFieldPathBuilder().DefaultValues().Strings().FieldPath(),
	})
}

func (b *filterCndBuilderDefaultValuesStrings) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewRoleFieldPathBuilder().DefaultValues().Strings().FieldPath(),
	})
}

func (b *filterCndBuilderDefaultValuesStrings) compare(op gotenfilter.CompareOperator, value *ScopeParam_ArrayOfStringsValue) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:            op,
		Role_FieldPathValue: NewRoleFieldPathBuilder().DefaultValues().Strings().WithValue(value),
	})
}

func (b *filterCndBuilderDefaultValuesStrings) Values() *filterCndBuilderDefaultValuesStringsValues {
	return &filterCndBuilderDefaultValuesStringsValues{builder: b.builder}
}

type filterCndBuilderDefaultValuesStringsValues struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderDefaultValuesStringsValues) In(values [][]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Role_FieldPathArrayOfValues: NewRoleFieldPathBuilder().DefaultValues().Strings().Values().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderDefaultValuesStringsValues) NotIn(values [][]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Role_FieldPathArrayOfValues: NewRoleFieldPathBuilder().DefaultValues().Strings().Values().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderDefaultValuesStringsValues) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewRoleFieldPathBuilder().DefaultValues().Strings().Values().FieldPath(),
	})
}

func (b *filterCndBuilderDefaultValuesStringsValues) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewRoleFieldPathBuilder().DefaultValues().Strings().Values().FieldPath(),
	})
}

func (b *filterCndBuilderDefaultValuesStringsValues) Contains(value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewRoleFieldPathBuilder().DefaultValues().Strings().Values().FieldPath(),
		Value:     NewRoleFieldPathBuilder().DefaultValues().Strings().Values().WithItemValue(value),
	})
}

func (b *filterCndBuilderDefaultValuesStringsValues) ContainsAnyOf(values []string) *FilterBuilder {
	pathSelector := NewRoleFieldPathBuilder().DefaultValues().Strings().Values()
	itemValues := make([]Role_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewRoleFieldPathBuilder().DefaultValues().Strings().Values().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderDefaultValuesStringsValues) ContainsAll(values []string) *FilterBuilder {
	pathSelector := NewRoleFieldPathBuilder().DefaultValues().Strings().Values()
	itemValues := make([]Role_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewRoleFieldPathBuilder().DefaultValues().Strings().Values().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderDefaultValuesStringsValues) compare(op gotenfilter.CompareOperator, value []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:            op,
		Role_FieldPathValue: NewRoleFieldPathBuilder().DefaultValues().Strings().Values().WithValue(value),
	})
}

type filterCndBuilderDefaultValuesValueFrom struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderDefaultValuesValueFrom) Eq(value *ScopeParam_FromValue) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderDefaultValuesValueFrom) Neq(value *ScopeParam_FromValue) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderDefaultValuesValueFrom) Gt(value *ScopeParam_FromValue) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderDefaultValuesValueFrom) Gte(value *ScopeParam_FromValue) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderDefaultValuesValueFrom) Lt(value *ScopeParam_FromValue) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderDefaultValuesValueFrom) Lte(value *ScopeParam_FromValue) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderDefaultValuesValueFrom) In(values []*ScopeParam_FromValue) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Role_FieldPathArrayOfValues: NewRoleFieldPathBuilder().DefaultValues().ValueFrom().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderDefaultValuesValueFrom) NotIn(values []*ScopeParam_FromValue) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Role_FieldPathArrayOfValues: NewRoleFieldPathBuilder().DefaultValues().ValueFrom().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderDefaultValuesValueFrom) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewRoleFieldPathBuilder().DefaultValues().ValueFrom().FieldPath(),
	})
}

func (b *filterCndBuilderDefaultValuesValueFrom) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewRoleFieldPathBuilder().DefaultValues().ValueFrom().FieldPath(),
	})
}

func (b *filterCndBuilderDefaultValuesValueFrom) compare(op gotenfilter.CompareOperator, value *ScopeParam_FromValue) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:            op,
		Role_FieldPathValue: NewRoleFieldPathBuilder().DefaultValues().ValueFrom().WithValue(value),
	})
}

func (b *filterCndBuilderDefaultValuesValueFrom) Source() *filterCndBuilderDefaultValuesValueFromSource {
	return &filterCndBuilderDefaultValuesValueFromSource{builder: b.builder}
}

func (b *filterCndBuilderDefaultValuesValueFrom) Path() *filterCndBuilderDefaultValuesValueFromPath {
	return &filterCndBuilderDefaultValuesValueFromPath{builder: b.builder}
}

type filterCndBuilderDefaultValuesValueFromSource struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderDefaultValuesValueFromSource) Eq(value ScopeParam_FromValue_Source) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderDefaultValuesValueFromSource) Neq(value ScopeParam_FromValue_Source) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderDefaultValuesValueFromSource) Gt(value ScopeParam_FromValue_Source) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderDefaultValuesValueFromSource) Gte(value ScopeParam_FromValue_Source) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderDefaultValuesValueFromSource) Lt(value ScopeParam_FromValue_Source) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderDefaultValuesValueFromSource) Lte(value ScopeParam_FromValue_Source) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderDefaultValuesValueFromSource) In(values []ScopeParam_FromValue_Source) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Role_FieldPathArrayOfValues: NewRoleFieldPathBuilder().DefaultValues().ValueFrom().Source().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderDefaultValuesValueFromSource) NotIn(values []ScopeParam_FromValue_Source) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Role_FieldPathArrayOfValues: NewRoleFieldPathBuilder().DefaultValues().ValueFrom().Source().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderDefaultValuesValueFromSource) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewRoleFieldPathBuilder().DefaultValues().ValueFrom().Source().FieldPath(),
	})
}

func (b *filterCndBuilderDefaultValuesValueFromSource) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewRoleFieldPathBuilder().DefaultValues().ValueFrom().Source().FieldPath(),
	})
}

func (b *filterCndBuilderDefaultValuesValueFromSource) compare(op gotenfilter.CompareOperator, value ScopeParam_FromValue_Source) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:            op,
		Role_FieldPathValue: NewRoleFieldPathBuilder().DefaultValues().ValueFrom().Source().WithValue(value),
	})
}

type filterCndBuilderDefaultValuesValueFromPath struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderDefaultValuesValueFromPath) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Role_FieldPathArrayOfValues: NewRoleFieldPathBuilder().DefaultValues().ValueFrom().Path().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderDefaultValuesValueFromPath) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Role_FieldPathArrayOfValues: NewRoleFieldPathBuilder().DefaultValues().ValueFrom().Path().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderDefaultValuesValueFromPath) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewRoleFieldPathBuilder().DefaultValues().ValueFrom().Path().FieldPath(),
	})
}

func (b *filterCndBuilderDefaultValuesValueFromPath) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewRoleFieldPathBuilder().DefaultValues().ValueFrom().Path().FieldPath(),
	})
}

func (b *filterCndBuilderDefaultValuesValueFromPath) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:            op,
		Role_FieldPathValue: NewRoleFieldPathBuilder().DefaultValues().ValueFrom().Path().WithValue(value),
	})
}

type filterCndBuilderGrants struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderGrants) In(values [][]*Role_Grant) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Role_FieldPathArrayOfValues: NewRoleFieldPathBuilder().Grants().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderGrants) NotIn(values [][]*Role_Grant) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Role_FieldPathArrayOfValues: NewRoleFieldPathBuilder().Grants().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderGrants) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewRoleFieldPathBuilder().Grants().FieldPath(),
	})
}

func (b *filterCndBuilderGrants) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewRoleFieldPathBuilder().Grants().FieldPath(),
	})
}

func (b *filterCndBuilderGrants) Contains(value *Role_Grant) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewRoleFieldPathBuilder().Grants().FieldPath(),
		Value:     NewRoleFieldPathBuilder().Grants().WithItemValue(value),
	})
}

func (b *filterCndBuilderGrants) ContainsAnyOf(values []*Role_Grant) *FilterBuilder {
	pathSelector := NewRoleFieldPathBuilder().Grants()
	itemValues := make([]Role_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewRoleFieldPathBuilder().Grants().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderGrants) ContainsAll(values []*Role_Grant) *FilterBuilder {
	pathSelector := NewRoleFieldPathBuilder().Grants()
	itemValues := make([]Role_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewRoleFieldPathBuilder().Grants().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderGrants) compare(op gotenfilter.CompareOperator, value []*Role_Grant) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:            op,
		Role_FieldPathValue: NewRoleFieldPathBuilder().Grants().WithValue(value),
	})
}

func (b *filterCndBuilderGrants) SubScope() *filterCndBuilderGrantsSubScope {
	return &filterCndBuilderGrantsSubScope{builder: b.builder}
}

func (b *filterCndBuilderGrants) Permissions() *filterCndBuilderGrantsPermissions {
	return &filterCndBuilderGrantsPermissions{builder: b.builder}
}

func (b *filterCndBuilderGrants) ResourceFieldConditions() *filterCndBuilderGrantsResourceFieldConditions {
	return &filterCndBuilderGrantsResourceFieldConditions{builder: b.builder}
}

func (b *filterCndBuilderGrants) RequestFieldConditions() *filterCndBuilderGrantsRequestFieldConditions {
	return &filterCndBuilderGrantsRequestFieldConditions{builder: b.builder}
}

func (b *filterCndBuilderGrants) ExecutableConditions() *filterCndBuilderGrantsExecutableConditions {
	return &filterCndBuilderGrantsExecutableConditions{builder: b.builder}
}

type filterCndBuilderGrantsSubScope struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderGrantsSubScope) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Role_FieldPathArrayOfValues: NewRoleFieldPathBuilder().Grants().SubScope().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderGrantsSubScope) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Role_FieldPathArrayOfValues: NewRoleFieldPathBuilder().Grants().SubScope().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderGrantsSubScope) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewRoleFieldPathBuilder().Grants().SubScope().FieldPath(),
	})
}

func (b *filterCndBuilderGrantsSubScope) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewRoleFieldPathBuilder().Grants().SubScope().FieldPath(),
	})
}

func (b *filterCndBuilderGrantsSubScope) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:            op,
		Role_FieldPathValue: NewRoleFieldPathBuilder().Grants().SubScope().WithValue(value),
	})
}

type filterCndBuilderGrantsPermissions struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderGrantsPermissions) In(values [][]*permission.Reference) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Role_FieldPathArrayOfValues: NewRoleFieldPathBuilder().Grants().Permissions().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderGrantsPermissions) NotIn(values [][]*permission.Reference) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Role_FieldPathArrayOfValues: NewRoleFieldPathBuilder().Grants().Permissions().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderGrantsPermissions) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewRoleFieldPathBuilder().Grants().Permissions().FieldPath(),
	})
}

func (b *filterCndBuilderGrantsPermissions) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewRoleFieldPathBuilder().Grants().Permissions().FieldPath(),
	})
}

func (b *filterCndBuilderGrantsPermissions) Contains(value *permission.Reference) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewRoleFieldPathBuilder().Grants().Permissions().FieldPath(),
		Value:     NewRoleFieldPathBuilder().Grants().Permissions().WithItemValue(value),
	})
}

func (b *filterCndBuilderGrantsPermissions) ContainsAnyOf(values []*permission.Reference) *FilterBuilder {
	pathSelector := NewRoleFieldPathBuilder().Grants().Permissions()
	itemValues := make([]Role_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewRoleFieldPathBuilder().Grants().Permissions().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderGrantsPermissions) ContainsAll(values []*permission.Reference) *FilterBuilder {
	pathSelector := NewRoleFieldPathBuilder().Grants().Permissions()
	itemValues := make([]Role_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewRoleFieldPathBuilder().Grants().Permissions().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderGrantsPermissions) compare(op gotenfilter.CompareOperator, value []*permission.Reference) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:            op,
		Role_FieldPathValue: NewRoleFieldPathBuilder().Grants().Permissions().WithValue(value),
	})
}

type filterCndBuilderGrantsResourceFieldConditions struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderGrantsResourceFieldConditions) In(values [][]*Role_Grant_FieldCondition) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Role_FieldPathArrayOfValues: NewRoleFieldPathBuilder().Grants().ResourceFieldConditions().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderGrantsResourceFieldConditions) NotIn(values [][]*Role_Grant_FieldCondition) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Role_FieldPathArrayOfValues: NewRoleFieldPathBuilder().Grants().ResourceFieldConditions().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderGrantsResourceFieldConditions) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewRoleFieldPathBuilder().Grants().ResourceFieldConditions().FieldPath(),
	})
}

func (b *filterCndBuilderGrantsResourceFieldConditions) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewRoleFieldPathBuilder().Grants().ResourceFieldConditions().FieldPath(),
	})
}

func (b *filterCndBuilderGrantsResourceFieldConditions) Contains(value *Role_Grant_FieldCondition) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewRoleFieldPathBuilder().Grants().ResourceFieldConditions().FieldPath(),
		Value:     NewRoleFieldPathBuilder().Grants().ResourceFieldConditions().WithItemValue(value),
	})
}

func (b *filterCndBuilderGrantsResourceFieldConditions) ContainsAnyOf(values []*Role_Grant_FieldCondition) *FilterBuilder {
	pathSelector := NewRoleFieldPathBuilder().Grants().ResourceFieldConditions()
	itemValues := make([]Role_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewRoleFieldPathBuilder().Grants().ResourceFieldConditions().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderGrantsResourceFieldConditions) ContainsAll(values []*Role_Grant_FieldCondition) *FilterBuilder {
	pathSelector := NewRoleFieldPathBuilder().Grants().ResourceFieldConditions()
	itemValues := make([]Role_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewRoleFieldPathBuilder().Grants().ResourceFieldConditions().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderGrantsResourceFieldConditions) compare(op gotenfilter.CompareOperator, value []*Role_Grant_FieldCondition) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:            op,
		Role_FieldPathValue: NewRoleFieldPathBuilder().Grants().ResourceFieldConditions().WithValue(value),
	})
}

func (b *filterCndBuilderGrantsResourceFieldConditions) Path() *filterCndBuilderGrantsResourceFieldConditionsPath {
	return &filterCndBuilderGrantsResourceFieldConditionsPath{builder: b.builder}
}

func (b *filterCndBuilderGrantsResourceFieldConditions) Value() *filterCndBuilderGrantsResourceFieldConditionsValue {
	return &filterCndBuilderGrantsResourceFieldConditionsValue{builder: b.builder}
}

type filterCndBuilderGrantsResourceFieldConditionsPath struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderGrantsResourceFieldConditionsPath) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Role_FieldPathArrayOfValues: NewRoleFieldPathBuilder().Grants().ResourceFieldConditions().Path().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderGrantsResourceFieldConditionsPath) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Role_FieldPathArrayOfValues: NewRoleFieldPathBuilder().Grants().ResourceFieldConditions().Path().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderGrantsResourceFieldConditionsPath) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewRoleFieldPathBuilder().Grants().ResourceFieldConditions().Path().FieldPath(),
	})
}

func (b *filterCndBuilderGrantsResourceFieldConditionsPath) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewRoleFieldPathBuilder().Grants().ResourceFieldConditions().Path().FieldPath(),
	})
}

func (b *filterCndBuilderGrantsResourceFieldConditionsPath) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:            op,
		Role_FieldPathValue: NewRoleFieldPathBuilder().Grants().ResourceFieldConditions().Path().WithValue(value),
	})
}

type filterCndBuilderGrantsResourceFieldConditionsValue struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderGrantsResourceFieldConditionsValue) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Role_FieldPathArrayOfValues: NewRoleFieldPathBuilder().Grants().ResourceFieldConditions().Value().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderGrantsResourceFieldConditionsValue) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Role_FieldPathArrayOfValues: NewRoleFieldPathBuilder().Grants().ResourceFieldConditions().Value().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderGrantsResourceFieldConditionsValue) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewRoleFieldPathBuilder().Grants().ResourceFieldConditions().Value().FieldPath(),
	})
}

func (b *filterCndBuilderGrantsResourceFieldConditionsValue) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewRoleFieldPathBuilder().Grants().ResourceFieldConditions().Value().FieldPath(),
	})
}

func (b *filterCndBuilderGrantsResourceFieldConditionsValue) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:            op,
		Role_FieldPathValue: NewRoleFieldPathBuilder().Grants().ResourceFieldConditions().Value().WithValue(value),
	})
}

type filterCndBuilderGrantsRequestFieldConditions struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderGrantsRequestFieldConditions) In(values [][]*Role_Grant_FieldCondition) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Role_FieldPathArrayOfValues: NewRoleFieldPathBuilder().Grants().RequestFieldConditions().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderGrantsRequestFieldConditions) NotIn(values [][]*Role_Grant_FieldCondition) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Role_FieldPathArrayOfValues: NewRoleFieldPathBuilder().Grants().RequestFieldConditions().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderGrantsRequestFieldConditions) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewRoleFieldPathBuilder().Grants().RequestFieldConditions().FieldPath(),
	})
}

func (b *filterCndBuilderGrantsRequestFieldConditions) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewRoleFieldPathBuilder().Grants().RequestFieldConditions().FieldPath(),
	})
}

func (b *filterCndBuilderGrantsRequestFieldConditions) Contains(value *Role_Grant_FieldCondition) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewRoleFieldPathBuilder().Grants().RequestFieldConditions().FieldPath(),
		Value:     NewRoleFieldPathBuilder().Grants().RequestFieldConditions().WithItemValue(value),
	})
}

func (b *filterCndBuilderGrantsRequestFieldConditions) ContainsAnyOf(values []*Role_Grant_FieldCondition) *FilterBuilder {
	pathSelector := NewRoleFieldPathBuilder().Grants().RequestFieldConditions()
	itemValues := make([]Role_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewRoleFieldPathBuilder().Grants().RequestFieldConditions().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderGrantsRequestFieldConditions) ContainsAll(values []*Role_Grant_FieldCondition) *FilterBuilder {
	pathSelector := NewRoleFieldPathBuilder().Grants().RequestFieldConditions()
	itemValues := make([]Role_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewRoleFieldPathBuilder().Grants().RequestFieldConditions().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderGrantsRequestFieldConditions) compare(op gotenfilter.CompareOperator, value []*Role_Grant_FieldCondition) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:            op,
		Role_FieldPathValue: NewRoleFieldPathBuilder().Grants().RequestFieldConditions().WithValue(value),
	})
}

func (b *filterCndBuilderGrantsRequestFieldConditions) Path() *filterCndBuilderGrantsRequestFieldConditionsPath {
	return &filterCndBuilderGrantsRequestFieldConditionsPath{builder: b.builder}
}

func (b *filterCndBuilderGrantsRequestFieldConditions) Value() *filterCndBuilderGrantsRequestFieldConditionsValue {
	return &filterCndBuilderGrantsRequestFieldConditionsValue{builder: b.builder}
}

type filterCndBuilderGrantsRequestFieldConditionsPath struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderGrantsRequestFieldConditionsPath) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Role_FieldPathArrayOfValues: NewRoleFieldPathBuilder().Grants().RequestFieldConditions().Path().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderGrantsRequestFieldConditionsPath) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Role_FieldPathArrayOfValues: NewRoleFieldPathBuilder().Grants().RequestFieldConditions().Path().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderGrantsRequestFieldConditionsPath) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewRoleFieldPathBuilder().Grants().RequestFieldConditions().Path().FieldPath(),
	})
}

func (b *filterCndBuilderGrantsRequestFieldConditionsPath) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewRoleFieldPathBuilder().Grants().RequestFieldConditions().Path().FieldPath(),
	})
}

func (b *filterCndBuilderGrantsRequestFieldConditionsPath) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:            op,
		Role_FieldPathValue: NewRoleFieldPathBuilder().Grants().RequestFieldConditions().Path().WithValue(value),
	})
}

type filterCndBuilderGrantsRequestFieldConditionsValue struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderGrantsRequestFieldConditionsValue) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Role_FieldPathArrayOfValues: NewRoleFieldPathBuilder().Grants().RequestFieldConditions().Value().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderGrantsRequestFieldConditionsValue) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Role_FieldPathArrayOfValues: NewRoleFieldPathBuilder().Grants().RequestFieldConditions().Value().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderGrantsRequestFieldConditionsValue) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewRoleFieldPathBuilder().Grants().RequestFieldConditions().Value().FieldPath(),
	})
}

func (b *filterCndBuilderGrantsRequestFieldConditionsValue) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewRoleFieldPathBuilder().Grants().RequestFieldConditions().Value().FieldPath(),
	})
}

func (b *filterCndBuilderGrantsRequestFieldConditionsValue) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:            op,
		Role_FieldPathValue: NewRoleFieldPathBuilder().Grants().RequestFieldConditions().Value().WithValue(value),
	})
}

type filterCndBuilderGrantsExecutableConditions struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderGrantsExecutableConditions) Eq(value []*condition.ExecutableCondition) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderGrantsExecutableConditions) Neq(value []*condition.ExecutableCondition) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderGrantsExecutableConditions) Gt(value []*condition.ExecutableCondition) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderGrantsExecutableConditions) Gte(value []*condition.ExecutableCondition) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderGrantsExecutableConditions) Lt(value []*condition.ExecutableCondition) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderGrantsExecutableConditions) Lte(value []*condition.ExecutableCondition) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderGrantsExecutableConditions) In(values [][]*condition.ExecutableCondition) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Role_FieldPathArrayOfValues: NewRoleFieldPathBuilder().Grants().ExecutableConditions().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderGrantsExecutableConditions) NotIn(values [][]*condition.ExecutableCondition) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Role_FieldPathArrayOfValues: NewRoleFieldPathBuilder().Grants().ExecutableConditions().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderGrantsExecutableConditions) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewRoleFieldPathBuilder().Grants().ExecutableConditions().FieldPath(),
	})
}

func (b *filterCndBuilderGrantsExecutableConditions) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewRoleFieldPathBuilder().Grants().ExecutableConditions().FieldPath(),
	})
}

func (b *filterCndBuilderGrantsExecutableConditions) Contains(value *condition.ExecutableCondition) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewRoleFieldPathBuilder().Grants().ExecutableConditions().FieldPath(),
		Value:     NewRoleFieldPathBuilder().Grants().ExecutableConditions().WithItemValue(value),
	})
}

func (b *filterCndBuilderGrantsExecutableConditions) ContainsAnyOf(values []*condition.ExecutableCondition) *FilterBuilder {
	pathSelector := NewRoleFieldPathBuilder().Grants().ExecutableConditions()
	itemValues := make([]Role_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewRoleFieldPathBuilder().Grants().ExecutableConditions().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderGrantsExecutableConditions) ContainsAll(values []*condition.ExecutableCondition) *FilterBuilder {
	pathSelector := NewRoleFieldPathBuilder().Grants().ExecutableConditions()
	itemValues := make([]Role_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewRoleFieldPathBuilder().Grants().ExecutableConditions().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderGrantsExecutableConditions) compare(op gotenfilter.CompareOperator, value []*condition.ExecutableCondition) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:            op,
		Role_FieldPathValue: NewRoleFieldPathBuilder().Grants().ExecutableConditions().WithValue(value),
	})
}

func (b *filterCndBuilderGrantsExecutableConditions) Condition() *filterCndBuilderGrantsExecutableConditionsCondition {
	return &filterCndBuilderGrantsExecutableConditionsCondition{builder: b.builder}
}

func (b *filterCndBuilderGrantsExecutableConditions) Params() *filterCndBuilderGrantsExecutableConditionsParams {
	return &filterCndBuilderGrantsExecutableConditionsParams{builder: b.builder}
}

type filterCndBuilderGrantsExecutableConditionsCondition struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderGrantsExecutableConditionsCondition) In(values []*condition.Reference) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Role_FieldPathArrayOfValues: NewRoleFieldPathBuilder().Grants().ExecutableConditions().Condition().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderGrantsExecutableConditionsCondition) NotIn(values []*condition.Reference) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Role_FieldPathArrayOfValues: NewRoleFieldPathBuilder().Grants().ExecutableConditions().Condition().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderGrantsExecutableConditionsCondition) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewRoleFieldPathBuilder().Grants().ExecutableConditions().Condition().FieldPath(),
	})
}

func (b *filterCndBuilderGrantsExecutableConditionsCondition) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewRoleFieldPathBuilder().Grants().ExecutableConditions().Condition().FieldPath(),
	})
}

func (b *filterCndBuilderGrantsExecutableConditionsCondition) compare(op gotenfilter.CompareOperator, value *condition.Reference) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:            op,
		Role_FieldPathValue: NewRoleFieldPathBuilder().Grants().ExecutableConditions().Condition().WithValue(value),
	})
}

type filterCndBuilderGrantsExecutableConditionsParams struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderGrantsExecutableConditionsParams) Eq(value *structpb.Struct) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderGrantsExecutableConditionsParams) Neq(value *structpb.Struct) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderGrantsExecutableConditionsParams) Gt(value *structpb.Struct) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderGrantsExecutableConditionsParams) Gte(value *structpb.Struct) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderGrantsExecutableConditionsParams) Lt(value *structpb.Struct) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderGrantsExecutableConditionsParams) Lte(value *structpb.Struct) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderGrantsExecutableConditionsParams) In(values []*structpb.Struct) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Role_FieldPathArrayOfValues: NewRoleFieldPathBuilder().Grants().ExecutableConditions().Params().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderGrantsExecutableConditionsParams) NotIn(values []*structpb.Struct) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Role_FieldPathArrayOfValues: NewRoleFieldPathBuilder().Grants().ExecutableConditions().Params().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderGrantsExecutableConditionsParams) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewRoleFieldPathBuilder().Grants().ExecutableConditions().Params().FieldPath(),
	})
}

func (b *filterCndBuilderGrantsExecutableConditionsParams) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewRoleFieldPathBuilder().Grants().ExecutableConditions().Params().FieldPath(),
	})
}

func (b *filterCndBuilderGrantsExecutableConditionsParams) compare(op gotenfilter.CompareOperator, value *structpb.Struct) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:            op,
		Role_FieldPathValue: NewRoleFieldPathBuilder().Grants().ExecutableConditions().Params().WithValue(value),
	})
}

type filterCndBuilderOwnedObjects struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderOwnedObjects) In(values [][]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Role_FieldPathArrayOfValues: NewRoleFieldPathBuilder().OwnedObjects().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderOwnedObjects) NotIn(values [][]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Role_FieldPathArrayOfValues: NewRoleFieldPathBuilder().OwnedObjects().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderOwnedObjects) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewRoleFieldPathBuilder().OwnedObjects().FieldPath(),
	})
}

func (b *filterCndBuilderOwnedObjects) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewRoleFieldPathBuilder().OwnedObjects().FieldPath(),
	})
}

func (b *filterCndBuilderOwnedObjects) Contains(value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewRoleFieldPathBuilder().OwnedObjects().FieldPath(),
		Value:     NewRoleFieldPathBuilder().OwnedObjects().WithItemValue(value),
	})
}

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

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

func (b *filterCndBuilderOwnedObjects) compare(op gotenfilter.CompareOperator, value []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:            op,
		Role_FieldPathValue: NewRoleFieldPathBuilder().OwnedObjects().WithValue(value),
	})
}

type filterCndBuilderServices struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderServices) In(values [][]*meta_service.Reference) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Role_FieldPathArrayOfValues: NewRoleFieldPathBuilder().Services().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderServices) NotIn(values [][]*meta_service.Reference) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Role_FieldPathArrayOfValues: NewRoleFieldPathBuilder().Services().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderServices) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewRoleFieldPathBuilder().Services().FieldPath(),
	})
}

func (b *filterCndBuilderServices) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewRoleFieldPathBuilder().Services().FieldPath(),
	})
}

func (b *filterCndBuilderServices) Contains(value *meta_service.Reference) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewRoleFieldPathBuilder().Services().FieldPath(),
		Value:     NewRoleFieldPathBuilder().Services().WithItemValue(value),
	})
}

func (b *filterCndBuilderServices) ContainsAnyOf(values []*meta_service.Reference) *FilterBuilder {
	pathSelector := NewRoleFieldPathBuilder().Services()
	itemValues := make([]Role_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewRoleFieldPathBuilder().Services().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderServices) ContainsAll(values []*meta_service.Reference) *FilterBuilder {
	pathSelector := NewRoleFieldPathBuilder().Services()
	itemValues := make([]Role_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewRoleFieldPathBuilder().Services().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderServices) compare(op gotenfilter.CompareOperator, value []*meta_service.Reference) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:            op,
		Role_FieldPathValue: NewRoleFieldPathBuilder().Services().WithValue(value),
	})
}

type filterCndBuilderRbSpecGeneration struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderRbSpecGeneration) In(values []int64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Role_FieldPathArrayOfValues: NewRoleFieldPathBuilder().RbSpecGeneration().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderRbSpecGeneration) NotIn(values []int64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Role_FieldPathArrayOfValues: NewRoleFieldPathBuilder().RbSpecGeneration().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderRbSpecGeneration) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewRoleFieldPathBuilder().RbSpecGeneration().FieldPath(),
	})
}

func (b *filterCndBuilderRbSpecGeneration) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewRoleFieldPathBuilder().RbSpecGeneration().FieldPath(),
	})
}

func (b *filterCndBuilderRbSpecGeneration) compare(op gotenfilter.CompareOperator, value int64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:            op,
		Role_FieldPathValue: NewRoleFieldPathBuilder().RbSpecGeneration().WithValue(value),
	})
}