github.com/cloudwan/edgelq-sdk@v1.15.4/applications/resources/v1alpha2/pod/pod.pb.filterbuilder.go

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

package pod

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

// proto imports
import (
	common "github.com/cloudwan/edgelq-sdk/applications/resources/v1alpha2/common"
	distribution "github.com/cloudwan/edgelq-sdk/applications/resources/v1alpha2/distribution"
	project "github.com/cloudwan/edgelq-sdk/applications/resources/v1alpha2/project"
	devices_device "github.com/cloudwan/edgelq-sdk/devices/resources/v1alpha2/device"
	devices_project "github.com/cloudwan/edgelq-sdk/devices/resources/v1alpha2/project"
	iam_attestation_domain "github.com/cloudwan/edgelq-sdk/iam/resources/v1alpha2/attestation_domain"
	iam_iam_common "github.com/cloudwan/edgelq-sdk/iam/resources/v1alpha2/common"
	iam_organization "github.com/cloudwan/edgelq-sdk/iam/resources/v1alpha2/organization"
	iam_project "github.com/cloudwan/edgelq-sdk/iam/resources/v1alpha2/project"
	iam_service_account "github.com/cloudwan/edgelq-sdk/iam/resources/v1alpha2/service_account"
	meta_service "github.com/cloudwan/edgelq-sdk/meta/resources/v1alpha2/service"
	secrets_project "github.com/cloudwan/edgelq-sdk/secrets/resources/v1alpha2/project"
	secrets_secret "github.com/cloudwan/edgelq-sdk/secrets/resources/v1alpha2/secret"
	meta "github.com/cloudwan/goten-sdk/types/meta"
	multi_region_policy "github.com/cloudwan/goten-sdk/types/multi_region_policy"
	latlng "google.golang.org/genproto/googleapis/type/latlng"
	durationpb "google.golang.org/protobuf/types/known/durationpb"
	fieldmaskpb "google.golang.org/protobuf/types/known/fieldmaskpb"
	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 (
	_ = &common.PodSpec{}
	_ = &distribution.Distribution{}
	_ = &project.Project{}
	_ = &devices_device.Device{}
	_ = &devices_project.Project{}
	_ = &iam_attestation_domain.AttestationDomain{}
	_ = &iam_iam_common.PCR{}
	_ = &iam_organization.Organization{}
	_ = &iam_project.Project{}
	_ = &iam_service_account.ServiceAccount{}
	_ = &meta_service.Service{}
	_ = &secrets_project.Project{}
	_ = &secrets_secret.Secret{}
	_ = &durationpb.Duration{}
	_ = &fieldmaskpb.FieldMask{}
	_ = &timestamppb.Timestamp{}
	_ = &latlng.LatLng{}
	_ = &meta.Meta{}
	_ = &multi_region_policy.MultiRegionPolicy{}
)

type FilterBuilderOrCondition interface {
	_IsPodFilterBuilderOrCondition()
}

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

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

func (b *filterCndBuilderAnyPath) NotIn(values interface{}) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Pod_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([]Pod_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([]Pod_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,
		Pod_FieldPathValue: b.fp.WithIValue(value),
	})
}

type filterCndBuilder struct {
	builder *FilterBuilder
}

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

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

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

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

func (b *filterCndBuilder) Distribution() *filterCndBuilderDistribution {
	return &filterCndBuilderDistribution{builder: b.builder}
}

func (b *filterCndBuilder) Status() *filterCndBuilderStatus {
	return &filterCndBuilderStatus{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{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Name().WithArrayOfValues(values),
	})
}

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

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

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

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

type filterCndBuilderDisplayName struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

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

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

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

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

func (b *filterCndBuilderDisplayName) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:           op,
		Pod_FieldPathValue: NewPodFieldPathBuilder().DisplayName().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{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Metadata().WithArrayOfValues(values),
	})
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

type filterCndBuilderSpec struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpec) In(values []*common.PodSpec) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpec) NotIn(values []*common.PodSpec) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().WithArrayOfValues(values),
	})
}

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

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

func (b *filterCndBuilderSpec) compare(op gotenfilter.CompareOperator, value *common.PodSpec) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:           op,
		Pod_FieldPathValue: NewPodFieldPathBuilder().Spec().WithValue(value),
	})
}

func (b *filterCndBuilderSpec) Node() *filterCndBuilderSpecNode {
	return &filterCndBuilderSpecNode{builder: b.builder}
}

func (b *filterCndBuilderSpec) Containers() *filterCndBuilderSpecContainers {
	return &filterCndBuilderSpecContainers{builder: b.builder}
}

func (b *filterCndBuilderSpec) HostNetwork() *filterCndBuilderSpecHostNetwork {
	return &filterCndBuilderSpecHostNetwork{builder: b.builder}
}

func (b *filterCndBuilderSpec) RestartPolicy() *filterCndBuilderSpecRestartPolicy {
	return &filterCndBuilderSpecRestartPolicy{builder: b.builder}
}

func (b *filterCndBuilderSpec) ImagePullSecrets() *filterCndBuilderSpecImagePullSecrets {
	return &filterCndBuilderSpecImagePullSecrets{builder: b.builder}
}

func (b *filterCndBuilderSpec) Volumes() *filterCndBuilderSpecVolumes {
	return &filterCndBuilderSpecVolumes{builder: b.builder}
}

func (b *filterCndBuilderSpec) Compose() *filterCndBuilderSpecCompose {
	return &filterCndBuilderSpecCompose{builder: b.builder}
}

func (b *filterCndBuilderSpec) HostVolumeMounts() *filterCndBuilderSpecHostVolumeMounts {
	return &filterCndBuilderSpecHostVolumeMounts{builder: b.builder}
}

type filterCndBuilderSpecNode struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecNode) In(values []*devices_device.Reference) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Node().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecNode) NotIn(values []*devices_device.Reference) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Node().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecNode) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPodFieldPathBuilder().Spec().Node().FieldPath(),
	})
}

func (b *filterCndBuilderSpecNode) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPodFieldPathBuilder().Spec().Node().FieldPath(),
	})
}

func (b *filterCndBuilderSpecNode) compare(op gotenfilter.CompareOperator, value *devices_device.Reference) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:           op,
		Pod_FieldPathValue: NewPodFieldPathBuilder().Spec().Node().WithValue(value),
	})
}

type filterCndBuilderSpecContainers struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderSpecContainers) Eq(value []*common.PodSpec_Container) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderSpecContainers) Neq(value []*common.PodSpec_Container) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderSpecContainers) Gt(value []*common.PodSpec_Container) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderSpecContainers) Gte(value []*common.PodSpec_Container) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderSpecContainers) Lt(value []*common.PodSpec_Container) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderSpecContainers) Lte(value []*common.PodSpec_Container) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderSpecContainers) In(values [][]*common.PodSpec_Container) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Containers().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecContainers) NotIn(values [][]*common.PodSpec_Container) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Containers().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecContainers) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPodFieldPathBuilder().Spec().Containers().FieldPath(),
	})
}

func (b *filterCndBuilderSpecContainers) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPodFieldPathBuilder().Spec().Containers().FieldPath(),
	})
}

func (b *filterCndBuilderSpecContainers) Contains(value *common.PodSpec_Container) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewPodFieldPathBuilder().Spec().Containers().FieldPath(),
		Value:     NewPodFieldPathBuilder().Spec().Containers().WithItemValue(value),
	})
}

func (b *filterCndBuilderSpecContainers) ContainsAnyOf(values []*common.PodSpec_Container) *FilterBuilder {
	pathSelector := NewPodFieldPathBuilder().Spec().Containers()
	itemValues := make([]Pod_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewPodFieldPathBuilder().Spec().Containers().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderSpecContainers) ContainsAll(values []*common.PodSpec_Container) *FilterBuilder {
	pathSelector := NewPodFieldPathBuilder().Spec().Containers()
	itemValues := make([]Pod_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewPodFieldPathBuilder().Spec().Containers().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderSpecContainers) compare(op gotenfilter.CompareOperator, value []*common.PodSpec_Container) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:           op,
		Pod_FieldPathValue: NewPodFieldPathBuilder().Spec().Containers().WithValue(value),
	})
}

func (b *filterCndBuilderSpecContainers) Args() *filterCndBuilderSpecContainersArgs {
	return &filterCndBuilderSpecContainersArgs{builder: b.builder}
}

func (b *filterCndBuilderSpecContainers) Command() *filterCndBuilderSpecContainersCommand {
	return &filterCndBuilderSpecContainersCommand{builder: b.builder}
}

func (b *filterCndBuilderSpecContainers) Env() *filterCndBuilderSpecContainersEnv {
	return &filterCndBuilderSpecContainersEnv{builder: b.builder}
}

func (b *filterCndBuilderSpecContainers) Image() *filterCndBuilderSpecContainersImage {
	return &filterCndBuilderSpecContainersImage{builder: b.builder}
}

func (b *filterCndBuilderSpecContainers) ImagePullPolicy() *filterCndBuilderSpecContainersImagePullPolicy {
	return &filterCndBuilderSpecContainersImagePullPolicy{builder: b.builder}
}

func (b *filterCndBuilderSpecContainers) Name() *filterCndBuilderSpecContainersName {
	return &filterCndBuilderSpecContainersName{builder: b.builder}
}

func (b *filterCndBuilderSpecContainers) Resources() *filterCndBuilderSpecContainersResources {
	return &filterCndBuilderSpecContainersResources{builder: b.builder}
}

func (b *filterCndBuilderSpecContainers) SecurityContext() *filterCndBuilderSpecContainersSecurityContext {
	return &filterCndBuilderSpecContainersSecurityContext{builder: b.builder}
}

func (b *filterCndBuilderSpecContainers) VolumeMounts() *filterCndBuilderSpecContainersVolumeMounts {
	return &filterCndBuilderSpecContainersVolumeMounts{builder: b.builder}
}

func (b *filterCndBuilderSpecContainers) EnvFrom() *filterCndBuilderSpecContainersEnvFrom {
	return &filterCndBuilderSpecContainersEnvFrom{builder: b.builder}
}

type filterCndBuilderSpecContainersArgs struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecContainersArgs) In(values [][]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Containers().Args().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecContainersArgs) NotIn(values [][]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Containers().Args().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecContainersArgs) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPodFieldPathBuilder().Spec().Containers().Args().FieldPath(),
	})
}

func (b *filterCndBuilderSpecContainersArgs) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPodFieldPathBuilder().Spec().Containers().Args().FieldPath(),
	})
}

func (b *filterCndBuilderSpecContainersArgs) Contains(value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewPodFieldPathBuilder().Spec().Containers().Args().FieldPath(),
		Value:     NewPodFieldPathBuilder().Spec().Containers().Args().WithItemValue(value),
	})
}

func (b *filterCndBuilderSpecContainersArgs) ContainsAnyOf(values []string) *FilterBuilder {
	pathSelector := NewPodFieldPathBuilder().Spec().Containers().Args()
	itemValues := make([]Pod_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewPodFieldPathBuilder().Spec().Containers().Args().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderSpecContainersArgs) ContainsAll(values []string) *FilterBuilder {
	pathSelector := NewPodFieldPathBuilder().Spec().Containers().Args()
	itemValues := make([]Pod_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewPodFieldPathBuilder().Spec().Containers().Args().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderSpecContainersArgs) compare(op gotenfilter.CompareOperator, value []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:           op,
		Pod_FieldPathValue: NewPodFieldPathBuilder().Spec().Containers().Args().WithValue(value),
	})
}

type filterCndBuilderSpecContainersCommand struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecContainersCommand) In(values [][]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Containers().Command().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecContainersCommand) NotIn(values [][]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Containers().Command().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecContainersCommand) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPodFieldPathBuilder().Spec().Containers().Command().FieldPath(),
	})
}

func (b *filterCndBuilderSpecContainersCommand) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPodFieldPathBuilder().Spec().Containers().Command().FieldPath(),
	})
}

func (b *filterCndBuilderSpecContainersCommand) Contains(value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewPodFieldPathBuilder().Spec().Containers().Command().FieldPath(),
		Value:     NewPodFieldPathBuilder().Spec().Containers().Command().WithItemValue(value),
	})
}

func (b *filterCndBuilderSpecContainersCommand) ContainsAnyOf(values []string) *FilterBuilder {
	pathSelector := NewPodFieldPathBuilder().Spec().Containers().Command()
	itemValues := make([]Pod_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewPodFieldPathBuilder().Spec().Containers().Command().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderSpecContainersCommand) ContainsAll(values []string) *FilterBuilder {
	pathSelector := NewPodFieldPathBuilder().Spec().Containers().Command()
	itemValues := make([]Pod_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewPodFieldPathBuilder().Spec().Containers().Command().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderSpecContainersCommand) compare(op gotenfilter.CompareOperator, value []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:           op,
		Pod_FieldPathValue: NewPodFieldPathBuilder().Spec().Containers().Command().WithValue(value),
	})
}

type filterCndBuilderSpecContainersEnv struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderSpecContainersEnv) Eq(value []*common.EnvVar) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderSpecContainersEnv) Neq(value []*common.EnvVar) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderSpecContainersEnv) Gt(value []*common.EnvVar) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderSpecContainersEnv) Gte(value []*common.EnvVar) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderSpecContainersEnv) Lt(value []*common.EnvVar) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderSpecContainersEnv) Lte(value []*common.EnvVar) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderSpecContainersEnv) In(values [][]*common.EnvVar) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Containers().Env().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecContainersEnv) NotIn(values [][]*common.EnvVar) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Containers().Env().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecContainersEnv) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPodFieldPathBuilder().Spec().Containers().Env().FieldPath(),
	})
}

func (b *filterCndBuilderSpecContainersEnv) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPodFieldPathBuilder().Spec().Containers().Env().FieldPath(),
	})
}

func (b *filterCndBuilderSpecContainersEnv) Contains(value *common.EnvVar) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewPodFieldPathBuilder().Spec().Containers().Env().FieldPath(),
		Value:     NewPodFieldPathBuilder().Spec().Containers().Env().WithItemValue(value),
	})
}

func (b *filterCndBuilderSpecContainersEnv) ContainsAnyOf(values []*common.EnvVar) *FilterBuilder {
	pathSelector := NewPodFieldPathBuilder().Spec().Containers().Env()
	itemValues := make([]Pod_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewPodFieldPathBuilder().Spec().Containers().Env().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderSpecContainersEnv) ContainsAll(values []*common.EnvVar) *FilterBuilder {
	pathSelector := NewPodFieldPathBuilder().Spec().Containers().Env()
	itemValues := make([]Pod_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewPodFieldPathBuilder().Spec().Containers().Env().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderSpecContainersEnv) compare(op gotenfilter.CompareOperator, value []*common.EnvVar) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:           op,
		Pod_FieldPathValue: NewPodFieldPathBuilder().Spec().Containers().Env().WithValue(value),
	})
}

func (b *filterCndBuilderSpecContainersEnv) Name() *filterCndBuilderSpecContainersEnvName {
	return &filterCndBuilderSpecContainersEnvName{builder: b.builder}
}

func (b *filterCndBuilderSpecContainersEnv) Value() *filterCndBuilderSpecContainersEnvValue {
	return &filterCndBuilderSpecContainersEnvValue{builder: b.builder}
}

func (b *filterCndBuilderSpecContainersEnv) ValueFrom() *filterCndBuilderSpecContainersEnvValueFrom {
	return &filterCndBuilderSpecContainersEnvValueFrom{builder: b.builder}
}

type filterCndBuilderSpecContainersEnvName struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecContainersEnvName) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Containers().Env().Name().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecContainersEnvName) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Containers().Env().Name().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecContainersEnvName) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPodFieldPathBuilder().Spec().Containers().Env().Name().FieldPath(),
	})
}

func (b *filterCndBuilderSpecContainersEnvName) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPodFieldPathBuilder().Spec().Containers().Env().Name().FieldPath(),
	})
}

func (b *filterCndBuilderSpecContainersEnvName) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:           op,
		Pod_FieldPathValue: NewPodFieldPathBuilder().Spec().Containers().Env().Name().WithValue(value),
	})
}

type filterCndBuilderSpecContainersEnvValue struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecContainersEnvValue) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Containers().Env().Value().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecContainersEnvValue) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Containers().Env().Value().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecContainersEnvValue) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPodFieldPathBuilder().Spec().Containers().Env().Value().FieldPath(),
	})
}

func (b *filterCndBuilderSpecContainersEnvValue) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPodFieldPathBuilder().Spec().Containers().Env().Value().FieldPath(),
	})
}

func (b *filterCndBuilderSpecContainersEnvValue) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:           op,
		Pod_FieldPathValue: NewPodFieldPathBuilder().Spec().Containers().Env().Value().WithValue(value),
	})
}

type filterCndBuilderSpecContainersEnvValueFrom struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecContainersEnvValueFrom) In(values []*common.EnvVarSource) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Containers().Env().ValueFrom().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecContainersEnvValueFrom) NotIn(values []*common.EnvVarSource) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Containers().Env().ValueFrom().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecContainersEnvValueFrom) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPodFieldPathBuilder().Spec().Containers().Env().ValueFrom().FieldPath(),
	})
}

func (b *filterCndBuilderSpecContainersEnvValueFrom) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPodFieldPathBuilder().Spec().Containers().Env().ValueFrom().FieldPath(),
	})
}

func (b *filterCndBuilderSpecContainersEnvValueFrom) compare(op gotenfilter.CompareOperator, value *common.EnvVarSource) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:           op,
		Pod_FieldPathValue: NewPodFieldPathBuilder().Spec().Containers().Env().ValueFrom().WithValue(value),
	})
}

func (b *filterCndBuilderSpecContainersEnvValueFrom) ConfigMapKeyRef() *filterCndBuilderSpecContainersEnvValueFromConfigMapKeyRef {
	return &filterCndBuilderSpecContainersEnvValueFromConfigMapKeyRef{builder: b.builder}
}

func (b *filterCndBuilderSpecContainersEnvValueFrom) SecretKeyRef() *filterCndBuilderSpecContainersEnvValueFromSecretKeyRef {
	return &filterCndBuilderSpecContainersEnvValueFromSecretKeyRef{builder: b.builder}
}

type filterCndBuilderSpecContainersEnvValueFromConfigMapKeyRef struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecContainersEnvValueFromConfigMapKeyRef) In(values []*common.ConfigMapKeySelector) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Containers().Env().ValueFrom().ConfigMapKeyRef().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecContainersEnvValueFromConfigMapKeyRef) NotIn(values []*common.ConfigMapKeySelector) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Containers().Env().ValueFrom().ConfigMapKeyRef().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecContainersEnvValueFromConfigMapKeyRef) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPodFieldPathBuilder().Spec().Containers().Env().ValueFrom().ConfigMapKeyRef().FieldPath(),
	})
}

func (b *filterCndBuilderSpecContainersEnvValueFromConfigMapKeyRef) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPodFieldPathBuilder().Spec().Containers().Env().ValueFrom().ConfigMapKeyRef().FieldPath(),
	})
}

func (b *filterCndBuilderSpecContainersEnvValueFromConfigMapKeyRef) compare(op gotenfilter.CompareOperator, value *common.ConfigMapKeySelector) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:           op,
		Pod_FieldPathValue: NewPodFieldPathBuilder().Spec().Containers().Env().ValueFrom().ConfigMapKeyRef().WithValue(value),
	})
}

func (b *filterCndBuilderSpecContainersEnvValueFromConfigMapKeyRef) Name() *filterCndBuilderSpecContainersEnvValueFromConfigMapKeyRefName {
	return &filterCndBuilderSpecContainersEnvValueFromConfigMapKeyRefName{builder: b.builder}
}

func (b *filterCndBuilderSpecContainersEnvValueFromConfigMapKeyRef) Key() *filterCndBuilderSpecContainersEnvValueFromConfigMapKeyRefKey {
	return &filterCndBuilderSpecContainersEnvValueFromConfigMapKeyRefKey{builder: b.builder}
}

func (b *filterCndBuilderSpecContainersEnvValueFromConfigMapKeyRef) Optional() *filterCndBuilderSpecContainersEnvValueFromConfigMapKeyRefOptional {
	return &filterCndBuilderSpecContainersEnvValueFromConfigMapKeyRefOptional{builder: b.builder}
}

type filterCndBuilderSpecContainersEnvValueFromConfigMapKeyRefName struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecContainersEnvValueFromConfigMapKeyRefName) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Containers().Env().ValueFrom().ConfigMapKeyRef().Name().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecContainersEnvValueFromConfigMapKeyRefName) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Containers().Env().ValueFrom().ConfigMapKeyRef().Name().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecContainersEnvValueFromConfigMapKeyRefName) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPodFieldPathBuilder().Spec().Containers().Env().ValueFrom().ConfigMapKeyRef().Name().FieldPath(),
	})
}

func (b *filterCndBuilderSpecContainersEnvValueFromConfigMapKeyRefName) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPodFieldPathBuilder().Spec().Containers().Env().ValueFrom().ConfigMapKeyRef().Name().FieldPath(),
	})
}

func (b *filterCndBuilderSpecContainersEnvValueFromConfigMapKeyRefName) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:           op,
		Pod_FieldPathValue: NewPodFieldPathBuilder().Spec().Containers().Env().ValueFrom().ConfigMapKeyRef().Name().WithValue(value),
	})
}

type filterCndBuilderSpecContainersEnvValueFromConfigMapKeyRefKey struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecContainersEnvValueFromConfigMapKeyRefKey) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Containers().Env().ValueFrom().ConfigMapKeyRef().Key().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecContainersEnvValueFromConfigMapKeyRefKey) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Containers().Env().ValueFrom().ConfigMapKeyRef().Key().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecContainersEnvValueFromConfigMapKeyRefKey) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPodFieldPathBuilder().Spec().Containers().Env().ValueFrom().ConfigMapKeyRef().Key().FieldPath(),
	})
}

func (b *filterCndBuilderSpecContainersEnvValueFromConfigMapKeyRefKey) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPodFieldPathBuilder().Spec().Containers().Env().ValueFrom().ConfigMapKeyRef().Key().FieldPath(),
	})
}

func (b *filterCndBuilderSpecContainersEnvValueFromConfigMapKeyRefKey) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:           op,
		Pod_FieldPathValue: NewPodFieldPathBuilder().Spec().Containers().Env().ValueFrom().ConfigMapKeyRef().Key().WithValue(value),
	})
}

type filterCndBuilderSpecContainersEnvValueFromConfigMapKeyRefOptional struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecContainersEnvValueFromConfigMapKeyRefOptional) In(values []bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Containers().Env().ValueFrom().ConfigMapKeyRef().Optional().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecContainersEnvValueFromConfigMapKeyRefOptional) NotIn(values []bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Containers().Env().ValueFrom().ConfigMapKeyRef().Optional().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecContainersEnvValueFromConfigMapKeyRefOptional) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPodFieldPathBuilder().Spec().Containers().Env().ValueFrom().ConfigMapKeyRef().Optional().FieldPath(),
	})
}

func (b *filterCndBuilderSpecContainersEnvValueFromConfigMapKeyRefOptional) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPodFieldPathBuilder().Spec().Containers().Env().ValueFrom().ConfigMapKeyRef().Optional().FieldPath(),
	})
}

func (b *filterCndBuilderSpecContainersEnvValueFromConfigMapKeyRefOptional) compare(op gotenfilter.CompareOperator, value bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:           op,
		Pod_FieldPathValue: NewPodFieldPathBuilder().Spec().Containers().Env().ValueFrom().ConfigMapKeyRef().Optional().WithValue(value),
	})
}

type filterCndBuilderSpecContainersEnvValueFromSecretKeyRef struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecContainersEnvValueFromSecretKeyRef) In(values []*common.SecretKeySelector) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Containers().Env().ValueFrom().SecretKeyRef().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecContainersEnvValueFromSecretKeyRef) NotIn(values []*common.SecretKeySelector) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Containers().Env().ValueFrom().SecretKeyRef().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecContainersEnvValueFromSecretKeyRef) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPodFieldPathBuilder().Spec().Containers().Env().ValueFrom().SecretKeyRef().FieldPath(),
	})
}

func (b *filterCndBuilderSpecContainersEnvValueFromSecretKeyRef) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPodFieldPathBuilder().Spec().Containers().Env().ValueFrom().SecretKeyRef().FieldPath(),
	})
}

func (b *filterCndBuilderSpecContainersEnvValueFromSecretKeyRef) compare(op gotenfilter.CompareOperator, value *common.SecretKeySelector) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:           op,
		Pod_FieldPathValue: NewPodFieldPathBuilder().Spec().Containers().Env().ValueFrom().SecretKeyRef().WithValue(value),
	})
}

func (b *filterCndBuilderSpecContainersEnvValueFromSecretKeyRef) Name() *filterCndBuilderSpecContainersEnvValueFromSecretKeyRefName {
	return &filterCndBuilderSpecContainersEnvValueFromSecretKeyRefName{builder: b.builder}
}

func (b *filterCndBuilderSpecContainersEnvValueFromSecretKeyRef) Key() *filterCndBuilderSpecContainersEnvValueFromSecretKeyRefKey {
	return &filterCndBuilderSpecContainersEnvValueFromSecretKeyRefKey{builder: b.builder}
}

func (b *filterCndBuilderSpecContainersEnvValueFromSecretKeyRef) Optional() *filterCndBuilderSpecContainersEnvValueFromSecretKeyRefOptional {
	return &filterCndBuilderSpecContainersEnvValueFromSecretKeyRefOptional{builder: b.builder}
}

type filterCndBuilderSpecContainersEnvValueFromSecretKeyRefName struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecContainersEnvValueFromSecretKeyRefName) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Containers().Env().ValueFrom().SecretKeyRef().Name().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecContainersEnvValueFromSecretKeyRefName) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Containers().Env().ValueFrom().SecretKeyRef().Name().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecContainersEnvValueFromSecretKeyRefName) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPodFieldPathBuilder().Spec().Containers().Env().ValueFrom().SecretKeyRef().Name().FieldPath(),
	})
}

func (b *filterCndBuilderSpecContainersEnvValueFromSecretKeyRefName) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPodFieldPathBuilder().Spec().Containers().Env().ValueFrom().SecretKeyRef().Name().FieldPath(),
	})
}

func (b *filterCndBuilderSpecContainersEnvValueFromSecretKeyRefName) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:           op,
		Pod_FieldPathValue: NewPodFieldPathBuilder().Spec().Containers().Env().ValueFrom().SecretKeyRef().Name().WithValue(value),
	})
}

type filterCndBuilderSpecContainersEnvValueFromSecretKeyRefKey struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecContainersEnvValueFromSecretKeyRefKey) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Containers().Env().ValueFrom().SecretKeyRef().Key().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecContainersEnvValueFromSecretKeyRefKey) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Containers().Env().ValueFrom().SecretKeyRef().Key().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecContainersEnvValueFromSecretKeyRefKey) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPodFieldPathBuilder().Spec().Containers().Env().ValueFrom().SecretKeyRef().Key().FieldPath(),
	})
}

func (b *filterCndBuilderSpecContainersEnvValueFromSecretKeyRefKey) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPodFieldPathBuilder().Spec().Containers().Env().ValueFrom().SecretKeyRef().Key().FieldPath(),
	})
}

func (b *filterCndBuilderSpecContainersEnvValueFromSecretKeyRefKey) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:           op,
		Pod_FieldPathValue: NewPodFieldPathBuilder().Spec().Containers().Env().ValueFrom().SecretKeyRef().Key().WithValue(value),
	})
}

type filterCndBuilderSpecContainersEnvValueFromSecretKeyRefOptional struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecContainersEnvValueFromSecretKeyRefOptional) In(values []bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Containers().Env().ValueFrom().SecretKeyRef().Optional().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecContainersEnvValueFromSecretKeyRefOptional) NotIn(values []bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Containers().Env().ValueFrom().SecretKeyRef().Optional().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecContainersEnvValueFromSecretKeyRefOptional) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPodFieldPathBuilder().Spec().Containers().Env().ValueFrom().SecretKeyRef().Optional().FieldPath(),
	})
}

func (b *filterCndBuilderSpecContainersEnvValueFromSecretKeyRefOptional) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPodFieldPathBuilder().Spec().Containers().Env().ValueFrom().SecretKeyRef().Optional().FieldPath(),
	})
}

func (b *filterCndBuilderSpecContainersEnvValueFromSecretKeyRefOptional) compare(op gotenfilter.CompareOperator, value bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:           op,
		Pod_FieldPathValue: NewPodFieldPathBuilder().Spec().Containers().Env().ValueFrom().SecretKeyRef().Optional().WithValue(value),
	})
}

type filterCndBuilderSpecContainersImage struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecContainersImage) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Containers().Image().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecContainersImage) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Containers().Image().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecContainersImage) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPodFieldPathBuilder().Spec().Containers().Image().FieldPath(),
	})
}

func (b *filterCndBuilderSpecContainersImage) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPodFieldPathBuilder().Spec().Containers().Image().FieldPath(),
	})
}

func (b *filterCndBuilderSpecContainersImage) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:           op,
		Pod_FieldPathValue: NewPodFieldPathBuilder().Spec().Containers().Image().WithValue(value),
	})
}

type filterCndBuilderSpecContainersImagePullPolicy struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecContainersImagePullPolicy) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Containers().ImagePullPolicy().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecContainersImagePullPolicy) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Containers().ImagePullPolicy().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecContainersImagePullPolicy) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPodFieldPathBuilder().Spec().Containers().ImagePullPolicy().FieldPath(),
	})
}

func (b *filterCndBuilderSpecContainersImagePullPolicy) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPodFieldPathBuilder().Spec().Containers().ImagePullPolicy().FieldPath(),
	})
}

func (b *filterCndBuilderSpecContainersImagePullPolicy) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:           op,
		Pod_FieldPathValue: NewPodFieldPathBuilder().Spec().Containers().ImagePullPolicy().WithValue(value),
	})
}

type filterCndBuilderSpecContainersName struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecContainersName) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Containers().Name().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecContainersName) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Containers().Name().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecContainersName) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPodFieldPathBuilder().Spec().Containers().Name().FieldPath(),
	})
}

func (b *filterCndBuilderSpecContainersName) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPodFieldPathBuilder().Spec().Containers().Name().FieldPath(),
	})
}

func (b *filterCndBuilderSpecContainersName) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:           op,
		Pod_FieldPathValue: NewPodFieldPathBuilder().Spec().Containers().Name().WithValue(value),
	})
}

type filterCndBuilderSpecContainersResources struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecContainersResources) In(values []*common.PodSpec_Container_ResourceRequirements) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Containers().Resources().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecContainersResources) NotIn(values []*common.PodSpec_Container_ResourceRequirements) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Containers().Resources().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecContainersResources) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPodFieldPathBuilder().Spec().Containers().Resources().FieldPath(),
	})
}

func (b *filterCndBuilderSpecContainersResources) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPodFieldPathBuilder().Spec().Containers().Resources().FieldPath(),
	})
}

func (b *filterCndBuilderSpecContainersResources) compare(op gotenfilter.CompareOperator, value *common.PodSpec_Container_ResourceRequirements) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:           op,
		Pod_FieldPathValue: NewPodFieldPathBuilder().Spec().Containers().Resources().WithValue(value),
	})
}

func (b *filterCndBuilderSpecContainersResources) Limits() *filterCndBuilderSpecContainersResourcesLimits {
	return &filterCndBuilderSpecContainersResourcesLimits{builder: b.builder}
}

func (b *filterCndBuilderSpecContainersResources) Requests() *filterCndBuilderSpecContainersResourcesRequests {
	return &filterCndBuilderSpecContainersResourcesRequests{builder: b.builder}
}

type filterCndBuilderSpecContainersResourcesLimits struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecContainersResourcesLimits) In(values []map[string]int64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Containers().Resources().Limits().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecContainersResourcesLimits) NotIn(values []map[string]int64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Containers().Resources().Limits().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecContainersResourcesLimits) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPodFieldPathBuilder().Spec().Containers().Resources().Limits().FieldPath(),
	})
}

func (b *filterCndBuilderSpecContainersResourcesLimits) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPodFieldPathBuilder().Spec().Containers().Resources().Limits().FieldPath(),
	})
}

func (b *filterCndBuilderSpecContainersResourcesLimits) compare(op gotenfilter.CompareOperator, value map[string]int64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:           op,
		Pod_FieldPathValue: NewPodFieldPathBuilder().Spec().Containers().Resources().Limits().WithValue(value),
	})
}

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

type mapFilterCndBuilderSpecContainersResourcesLimits struct {
	builder *FilterBuilder
	key     string
}

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

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

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

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

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

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

func (b *mapFilterCndBuilderSpecContainersResourcesLimits) In(values []int64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Containers().Resources().Limits().WithKey(b.key).WithArrayOfValues(values),
	})
}

func (b *mapFilterCndBuilderSpecContainersResourcesLimits) NotIn(values []int64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Containers().Resources().Limits().WithKey(b.key).WithArrayOfValues(values),
	})
}

func (b *mapFilterCndBuilderSpecContainersResourcesLimits) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPodFieldPathBuilder().Spec().Containers().Resources().Limits().WithKey(b.key).FieldPath(),
	})
}

func (b *mapFilterCndBuilderSpecContainersResourcesLimits) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPodFieldPathBuilder().Spec().Containers().Resources().Limits().WithKey(b.key).FieldPath(),
	})
}

func (b *mapFilterCndBuilderSpecContainersResourcesLimits) compare(op gotenfilter.CompareOperator, value int64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:           op,
		Pod_FieldPathValue: NewPodFieldPathBuilder().Spec().Containers().Resources().Limits().WithKey(b.key).WithValue(value),
	})
}

type filterCndBuilderSpecContainersResourcesRequests struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecContainersResourcesRequests) In(values []map[string]int64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Containers().Resources().Requests().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecContainersResourcesRequests) NotIn(values []map[string]int64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Containers().Resources().Requests().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecContainersResourcesRequests) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPodFieldPathBuilder().Spec().Containers().Resources().Requests().FieldPath(),
	})
}

func (b *filterCndBuilderSpecContainersResourcesRequests) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPodFieldPathBuilder().Spec().Containers().Resources().Requests().FieldPath(),
	})
}

func (b *filterCndBuilderSpecContainersResourcesRequests) compare(op gotenfilter.CompareOperator, value map[string]int64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:           op,
		Pod_FieldPathValue: NewPodFieldPathBuilder().Spec().Containers().Resources().Requests().WithValue(value),
	})
}

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

type mapFilterCndBuilderSpecContainersResourcesRequests struct {
	builder *FilterBuilder
	key     string
}

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

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

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

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

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

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

func (b *mapFilterCndBuilderSpecContainersResourcesRequests) In(values []int64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Containers().Resources().Requests().WithKey(b.key).WithArrayOfValues(values),
	})
}

func (b *mapFilterCndBuilderSpecContainersResourcesRequests) NotIn(values []int64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Containers().Resources().Requests().WithKey(b.key).WithArrayOfValues(values),
	})
}

func (b *mapFilterCndBuilderSpecContainersResourcesRequests) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPodFieldPathBuilder().Spec().Containers().Resources().Requests().WithKey(b.key).FieldPath(),
	})
}

func (b *mapFilterCndBuilderSpecContainersResourcesRequests) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPodFieldPathBuilder().Spec().Containers().Resources().Requests().WithKey(b.key).FieldPath(),
	})
}

func (b *mapFilterCndBuilderSpecContainersResourcesRequests) compare(op gotenfilter.CompareOperator, value int64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:           op,
		Pod_FieldPathValue: NewPodFieldPathBuilder().Spec().Containers().Resources().Requests().WithKey(b.key).WithValue(value),
	})
}

type filterCndBuilderSpecContainersSecurityContext struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecContainersSecurityContext) In(values []*common.SecurityContext) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Containers().SecurityContext().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecContainersSecurityContext) NotIn(values []*common.SecurityContext) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Containers().SecurityContext().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecContainersSecurityContext) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPodFieldPathBuilder().Spec().Containers().SecurityContext().FieldPath(),
	})
}

func (b *filterCndBuilderSpecContainersSecurityContext) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPodFieldPathBuilder().Spec().Containers().SecurityContext().FieldPath(),
	})
}

func (b *filterCndBuilderSpecContainersSecurityContext) compare(op gotenfilter.CompareOperator, value *common.SecurityContext) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:           op,
		Pod_FieldPathValue: NewPodFieldPathBuilder().Spec().Containers().SecurityContext().WithValue(value),
	})
}

func (b *filterCndBuilderSpecContainersSecurityContext) Privileged() *filterCndBuilderSpecContainersSecurityContextPrivileged {
	return &filterCndBuilderSpecContainersSecurityContextPrivileged{builder: b.builder}
}

type filterCndBuilderSpecContainersSecurityContextPrivileged struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecContainersSecurityContextPrivileged) In(values []bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Containers().SecurityContext().Privileged().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecContainersSecurityContextPrivileged) NotIn(values []bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Containers().SecurityContext().Privileged().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecContainersSecurityContextPrivileged) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPodFieldPathBuilder().Spec().Containers().SecurityContext().Privileged().FieldPath(),
	})
}

func (b *filterCndBuilderSpecContainersSecurityContextPrivileged) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPodFieldPathBuilder().Spec().Containers().SecurityContext().Privileged().FieldPath(),
	})
}

func (b *filterCndBuilderSpecContainersSecurityContextPrivileged) compare(op gotenfilter.CompareOperator, value bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:           op,
		Pod_FieldPathValue: NewPodFieldPathBuilder().Spec().Containers().SecurityContext().Privileged().WithValue(value),
	})
}

type filterCndBuilderSpecContainersVolumeMounts struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderSpecContainersVolumeMounts) Eq(value []*common.VolumeMount) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderSpecContainersVolumeMounts) Neq(value []*common.VolumeMount) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderSpecContainersVolumeMounts) Gt(value []*common.VolumeMount) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderSpecContainersVolumeMounts) Gte(value []*common.VolumeMount) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderSpecContainersVolumeMounts) Lt(value []*common.VolumeMount) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderSpecContainersVolumeMounts) Lte(value []*common.VolumeMount) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderSpecContainersVolumeMounts) In(values [][]*common.VolumeMount) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Containers().VolumeMounts().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecContainersVolumeMounts) NotIn(values [][]*common.VolumeMount) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Containers().VolumeMounts().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecContainersVolumeMounts) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPodFieldPathBuilder().Spec().Containers().VolumeMounts().FieldPath(),
	})
}

func (b *filterCndBuilderSpecContainersVolumeMounts) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPodFieldPathBuilder().Spec().Containers().VolumeMounts().FieldPath(),
	})
}

func (b *filterCndBuilderSpecContainersVolumeMounts) Contains(value *common.VolumeMount) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewPodFieldPathBuilder().Spec().Containers().VolumeMounts().FieldPath(),
		Value:     NewPodFieldPathBuilder().Spec().Containers().VolumeMounts().WithItemValue(value),
	})
}

func (b *filterCndBuilderSpecContainersVolumeMounts) ContainsAnyOf(values []*common.VolumeMount) *FilterBuilder {
	pathSelector := NewPodFieldPathBuilder().Spec().Containers().VolumeMounts()
	itemValues := make([]Pod_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewPodFieldPathBuilder().Spec().Containers().VolumeMounts().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderSpecContainersVolumeMounts) ContainsAll(values []*common.VolumeMount) *FilterBuilder {
	pathSelector := NewPodFieldPathBuilder().Spec().Containers().VolumeMounts()
	itemValues := make([]Pod_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewPodFieldPathBuilder().Spec().Containers().VolumeMounts().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderSpecContainersVolumeMounts) compare(op gotenfilter.CompareOperator, value []*common.VolumeMount) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:           op,
		Pod_FieldPathValue: NewPodFieldPathBuilder().Spec().Containers().VolumeMounts().WithValue(value),
	})
}

func (b *filterCndBuilderSpecContainersVolumeMounts) Name() *filterCndBuilderSpecContainersVolumeMountsName {
	return &filterCndBuilderSpecContainersVolumeMountsName{builder: b.builder}
}

func (b *filterCndBuilderSpecContainersVolumeMounts) ReadOnly() *filterCndBuilderSpecContainersVolumeMountsReadOnly {
	return &filterCndBuilderSpecContainersVolumeMountsReadOnly{builder: b.builder}
}

func (b *filterCndBuilderSpecContainersVolumeMounts) MountPath() *filterCndBuilderSpecContainersVolumeMountsMountPath {
	return &filterCndBuilderSpecContainersVolumeMountsMountPath{builder: b.builder}
}

func (b *filterCndBuilderSpecContainersVolumeMounts) SubPath() *filterCndBuilderSpecContainersVolumeMountsSubPath {
	return &filterCndBuilderSpecContainersVolumeMountsSubPath{builder: b.builder}
}

type filterCndBuilderSpecContainersVolumeMountsName struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecContainersVolumeMountsName) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Containers().VolumeMounts().Name().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecContainersVolumeMountsName) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Containers().VolumeMounts().Name().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecContainersVolumeMountsName) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPodFieldPathBuilder().Spec().Containers().VolumeMounts().Name().FieldPath(),
	})
}

func (b *filterCndBuilderSpecContainersVolumeMountsName) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPodFieldPathBuilder().Spec().Containers().VolumeMounts().Name().FieldPath(),
	})
}

func (b *filterCndBuilderSpecContainersVolumeMountsName) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:           op,
		Pod_FieldPathValue: NewPodFieldPathBuilder().Spec().Containers().VolumeMounts().Name().WithValue(value),
	})
}

type filterCndBuilderSpecContainersVolumeMountsReadOnly struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecContainersVolumeMountsReadOnly) In(values []bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Containers().VolumeMounts().ReadOnly().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecContainersVolumeMountsReadOnly) NotIn(values []bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Containers().VolumeMounts().ReadOnly().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecContainersVolumeMountsReadOnly) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPodFieldPathBuilder().Spec().Containers().VolumeMounts().ReadOnly().FieldPath(),
	})
}

func (b *filterCndBuilderSpecContainersVolumeMountsReadOnly) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPodFieldPathBuilder().Spec().Containers().VolumeMounts().ReadOnly().FieldPath(),
	})
}

func (b *filterCndBuilderSpecContainersVolumeMountsReadOnly) compare(op gotenfilter.CompareOperator, value bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:           op,
		Pod_FieldPathValue: NewPodFieldPathBuilder().Spec().Containers().VolumeMounts().ReadOnly().WithValue(value),
	})
}

type filterCndBuilderSpecContainersVolumeMountsMountPath struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecContainersVolumeMountsMountPath) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Containers().VolumeMounts().MountPath().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecContainersVolumeMountsMountPath) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Containers().VolumeMounts().MountPath().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecContainersVolumeMountsMountPath) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPodFieldPathBuilder().Spec().Containers().VolumeMounts().MountPath().FieldPath(),
	})
}

func (b *filterCndBuilderSpecContainersVolumeMountsMountPath) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPodFieldPathBuilder().Spec().Containers().VolumeMounts().MountPath().FieldPath(),
	})
}

func (b *filterCndBuilderSpecContainersVolumeMountsMountPath) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:           op,
		Pod_FieldPathValue: NewPodFieldPathBuilder().Spec().Containers().VolumeMounts().MountPath().WithValue(value),
	})
}

type filterCndBuilderSpecContainersVolumeMountsSubPath struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecContainersVolumeMountsSubPath) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Containers().VolumeMounts().SubPath().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecContainersVolumeMountsSubPath) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Containers().VolumeMounts().SubPath().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecContainersVolumeMountsSubPath) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPodFieldPathBuilder().Spec().Containers().VolumeMounts().SubPath().FieldPath(),
	})
}

func (b *filterCndBuilderSpecContainersVolumeMountsSubPath) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPodFieldPathBuilder().Spec().Containers().VolumeMounts().SubPath().FieldPath(),
	})
}

func (b *filterCndBuilderSpecContainersVolumeMountsSubPath) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:           op,
		Pod_FieldPathValue: NewPodFieldPathBuilder().Spec().Containers().VolumeMounts().SubPath().WithValue(value),
	})
}

type filterCndBuilderSpecContainersEnvFrom struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecContainersEnvFrom) In(values []*common.EnvFromSource) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Containers().EnvFrom().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecContainersEnvFrom) NotIn(values []*common.EnvFromSource) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Containers().EnvFrom().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecContainersEnvFrom) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPodFieldPathBuilder().Spec().Containers().EnvFrom().FieldPath(),
	})
}

func (b *filterCndBuilderSpecContainersEnvFrom) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPodFieldPathBuilder().Spec().Containers().EnvFrom().FieldPath(),
	})
}

func (b *filterCndBuilderSpecContainersEnvFrom) compare(op gotenfilter.CompareOperator, value *common.EnvFromSource) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:           op,
		Pod_FieldPathValue: NewPodFieldPathBuilder().Spec().Containers().EnvFrom().WithValue(value),
	})
}

func (b *filterCndBuilderSpecContainersEnvFrom) Prefix() *filterCndBuilderSpecContainersEnvFromPrefix {
	return &filterCndBuilderSpecContainersEnvFromPrefix{builder: b.builder}
}

func (b *filterCndBuilderSpecContainersEnvFrom) ConfigMapRef() *filterCndBuilderSpecContainersEnvFromConfigMapRef {
	return &filterCndBuilderSpecContainersEnvFromConfigMapRef{builder: b.builder}
}

func (b *filterCndBuilderSpecContainersEnvFrom) SecretRef() *filterCndBuilderSpecContainersEnvFromSecretRef {
	return &filterCndBuilderSpecContainersEnvFromSecretRef{builder: b.builder}
}

type filterCndBuilderSpecContainersEnvFromPrefix struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecContainersEnvFromPrefix) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Containers().EnvFrom().Prefix().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecContainersEnvFromPrefix) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Containers().EnvFrom().Prefix().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecContainersEnvFromPrefix) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPodFieldPathBuilder().Spec().Containers().EnvFrom().Prefix().FieldPath(),
	})
}

func (b *filterCndBuilderSpecContainersEnvFromPrefix) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPodFieldPathBuilder().Spec().Containers().EnvFrom().Prefix().FieldPath(),
	})
}

func (b *filterCndBuilderSpecContainersEnvFromPrefix) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:           op,
		Pod_FieldPathValue: NewPodFieldPathBuilder().Spec().Containers().EnvFrom().Prefix().WithValue(value),
	})
}

type filterCndBuilderSpecContainersEnvFromConfigMapRef struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecContainersEnvFromConfigMapRef) In(values []*common.ConfigMapEnvSource) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Containers().EnvFrom().ConfigMapRef().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecContainersEnvFromConfigMapRef) NotIn(values []*common.ConfigMapEnvSource) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Containers().EnvFrom().ConfigMapRef().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecContainersEnvFromConfigMapRef) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPodFieldPathBuilder().Spec().Containers().EnvFrom().ConfigMapRef().FieldPath(),
	})
}

func (b *filterCndBuilderSpecContainersEnvFromConfigMapRef) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPodFieldPathBuilder().Spec().Containers().EnvFrom().ConfigMapRef().FieldPath(),
	})
}

func (b *filterCndBuilderSpecContainersEnvFromConfigMapRef) compare(op gotenfilter.CompareOperator, value *common.ConfigMapEnvSource) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:           op,
		Pod_FieldPathValue: NewPodFieldPathBuilder().Spec().Containers().EnvFrom().ConfigMapRef().WithValue(value),
	})
}

func (b *filterCndBuilderSpecContainersEnvFromConfigMapRef) Name() *filterCndBuilderSpecContainersEnvFromConfigMapRefName {
	return &filterCndBuilderSpecContainersEnvFromConfigMapRefName{builder: b.builder}
}

func (b *filterCndBuilderSpecContainersEnvFromConfigMapRef) Optional() *filterCndBuilderSpecContainersEnvFromConfigMapRefOptional {
	return &filterCndBuilderSpecContainersEnvFromConfigMapRefOptional{builder: b.builder}
}

type filterCndBuilderSpecContainersEnvFromConfigMapRefName struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecContainersEnvFromConfigMapRefName) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Containers().EnvFrom().ConfigMapRef().Name().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecContainersEnvFromConfigMapRefName) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Containers().EnvFrom().ConfigMapRef().Name().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecContainersEnvFromConfigMapRefName) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPodFieldPathBuilder().Spec().Containers().EnvFrom().ConfigMapRef().Name().FieldPath(),
	})
}

func (b *filterCndBuilderSpecContainersEnvFromConfigMapRefName) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPodFieldPathBuilder().Spec().Containers().EnvFrom().ConfigMapRef().Name().FieldPath(),
	})
}

func (b *filterCndBuilderSpecContainersEnvFromConfigMapRefName) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:           op,
		Pod_FieldPathValue: NewPodFieldPathBuilder().Spec().Containers().EnvFrom().ConfigMapRef().Name().WithValue(value),
	})
}

type filterCndBuilderSpecContainersEnvFromConfigMapRefOptional struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecContainersEnvFromConfigMapRefOptional) In(values []bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Containers().EnvFrom().ConfigMapRef().Optional().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecContainersEnvFromConfigMapRefOptional) NotIn(values []bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Containers().EnvFrom().ConfigMapRef().Optional().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecContainersEnvFromConfigMapRefOptional) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPodFieldPathBuilder().Spec().Containers().EnvFrom().ConfigMapRef().Optional().FieldPath(),
	})
}

func (b *filterCndBuilderSpecContainersEnvFromConfigMapRefOptional) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPodFieldPathBuilder().Spec().Containers().EnvFrom().ConfigMapRef().Optional().FieldPath(),
	})
}

func (b *filterCndBuilderSpecContainersEnvFromConfigMapRefOptional) compare(op gotenfilter.CompareOperator, value bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:           op,
		Pod_FieldPathValue: NewPodFieldPathBuilder().Spec().Containers().EnvFrom().ConfigMapRef().Optional().WithValue(value),
	})
}

type filterCndBuilderSpecContainersEnvFromSecretRef struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecContainersEnvFromSecretRef) In(values []*common.SecretEnvSource) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Containers().EnvFrom().SecretRef().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecContainersEnvFromSecretRef) NotIn(values []*common.SecretEnvSource) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Containers().EnvFrom().SecretRef().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecContainersEnvFromSecretRef) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPodFieldPathBuilder().Spec().Containers().EnvFrom().SecretRef().FieldPath(),
	})
}

func (b *filterCndBuilderSpecContainersEnvFromSecretRef) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPodFieldPathBuilder().Spec().Containers().EnvFrom().SecretRef().FieldPath(),
	})
}

func (b *filterCndBuilderSpecContainersEnvFromSecretRef) compare(op gotenfilter.CompareOperator, value *common.SecretEnvSource) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:           op,
		Pod_FieldPathValue: NewPodFieldPathBuilder().Spec().Containers().EnvFrom().SecretRef().WithValue(value),
	})
}

func (b *filterCndBuilderSpecContainersEnvFromSecretRef) Name() *filterCndBuilderSpecContainersEnvFromSecretRefName {
	return &filterCndBuilderSpecContainersEnvFromSecretRefName{builder: b.builder}
}

func (b *filterCndBuilderSpecContainersEnvFromSecretRef) Optional() *filterCndBuilderSpecContainersEnvFromSecretRefOptional {
	return &filterCndBuilderSpecContainersEnvFromSecretRefOptional{builder: b.builder}
}

type filterCndBuilderSpecContainersEnvFromSecretRefName struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecContainersEnvFromSecretRefName) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Containers().EnvFrom().SecretRef().Name().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecContainersEnvFromSecretRefName) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Containers().EnvFrom().SecretRef().Name().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecContainersEnvFromSecretRefName) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPodFieldPathBuilder().Spec().Containers().EnvFrom().SecretRef().Name().FieldPath(),
	})
}

func (b *filterCndBuilderSpecContainersEnvFromSecretRefName) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPodFieldPathBuilder().Spec().Containers().EnvFrom().SecretRef().Name().FieldPath(),
	})
}

func (b *filterCndBuilderSpecContainersEnvFromSecretRefName) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:           op,
		Pod_FieldPathValue: NewPodFieldPathBuilder().Spec().Containers().EnvFrom().SecretRef().Name().WithValue(value),
	})
}

type filterCndBuilderSpecContainersEnvFromSecretRefOptional struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecContainersEnvFromSecretRefOptional) In(values []bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Containers().EnvFrom().SecretRef().Optional().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecContainersEnvFromSecretRefOptional) NotIn(values []bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Containers().EnvFrom().SecretRef().Optional().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecContainersEnvFromSecretRefOptional) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPodFieldPathBuilder().Spec().Containers().EnvFrom().SecretRef().Optional().FieldPath(),
	})
}

func (b *filterCndBuilderSpecContainersEnvFromSecretRefOptional) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPodFieldPathBuilder().Spec().Containers().EnvFrom().SecretRef().Optional().FieldPath(),
	})
}

func (b *filterCndBuilderSpecContainersEnvFromSecretRefOptional) compare(op gotenfilter.CompareOperator, value bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:           op,
		Pod_FieldPathValue: NewPodFieldPathBuilder().Spec().Containers().EnvFrom().SecretRef().Optional().WithValue(value),
	})
}

type filterCndBuilderSpecHostNetwork struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecHostNetwork) In(values []bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().HostNetwork().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecHostNetwork) NotIn(values []bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().HostNetwork().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecHostNetwork) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPodFieldPathBuilder().Spec().HostNetwork().FieldPath(),
	})
}

func (b *filterCndBuilderSpecHostNetwork) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPodFieldPathBuilder().Spec().HostNetwork().FieldPath(),
	})
}

func (b *filterCndBuilderSpecHostNetwork) compare(op gotenfilter.CompareOperator, value bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:           op,
		Pod_FieldPathValue: NewPodFieldPathBuilder().Spec().HostNetwork().WithValue(value),
	})
}

type filterCndBuilderSpecRestartPolicy struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecRestartPolicy) In(values []common.PodSpec_RestartPolicy) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().RestartPolicy().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecRestartPolicy) NotIn(values []common.PodSpec_RestartPolicy) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().RestartPolicy().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecRestartPolicy) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPodFieldPathBuilder().Spec().RestartPolicy().FieldPath(),
	})
}

func (b *filterCndBuilderSpecRestartPolicy) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPodFieldPathBuilder().Spec().RestartPolicy().FieldPath(),
	})
}

func (b *filterCndBuilderSpecRestartPolicy) compare(op gotenfilter.CompareOperator, value common.PodSpec_RestartPolicy) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:           op,
		Pod_FieldPathValue: NewPodFieldPathBuilder().Spec().RestartPolicy().WithValue(value),
	})
}

type filterCndBuilderSpecImagePullSecrets struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderSpecImagePullSecrets) Eq(value []*common.LocalObjectReferenceSecret) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderSpecImagePullSecrets) Neq(value []*common.LocalObjectReferenceSecret) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderSpecImagePullSecrets) Gt(value []*common.LocalObjectReferenceSecret) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderSpecImagePullSecrets) Gte(value []*common.LocalObjectReferenceSecret) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderSpecImagePullSecrets) Lt(value []*common.LocalObjectReferenceSecret) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderSpecImagePullSecrets) Lte(value []*common.LocalObjectReferenceSecret) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderSpecImagePullSecrets) In(values [][]*common.LocalObjectReferenceSecret) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().ImagePullSecrets().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecImagePullSecrets) NotIn(values [][]*common.LocalObjectReferenceSecret) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().ImagePullSecrets().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecImagePullSecrets) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPodFieldPathBuilder().Spec().ImagePullSecrets().FieldPath(),
	})
}

func (b *filterCndBuilderSpecImagePullSecrets) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPodFieldPathBuilder().Spec().ImagePullSecrets().FieldPath(),
	})
}

func (b *filterCndBuilderSpecImagePullSecrets) Contains(value *common.LocalObjectReferenceSecret) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewPodFieldPathBuilder().Spec().ImagePullSecrets().FieldPath(),
		Value:     NewPodFieldPathBuilder().Spec().ImagePullSecrets().WithItemValue(value),
	})
}

func (b *filterCndBuilderSpecImagePullSecrets) ContainsAnyOf(values []*common.LocalObjectReferenceSecret) *FilterBuilder {
	pathSelector := NewPodFieldPathBuilder().Spec().ImagePullSecrets()
	itemValues := make([]Pod_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewPodFieldPathBuilder().Spec().ImagePullSecrets().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderSpecImagePullSecrets) ContainsAll(values []*common.LocalObjectReferenceSecret) *FilterBuilder {
	pathSelector := NewPodFieldPathBuilder().Spec().ImagePullSecrets()
	itemValues := make([]Pod_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewPodFieldPathBuilder().Spec().ImagePullSecrets().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderSpecImagePullSecrets) compare(op gotenfilter.CompareOperator, value []*common.LocalObjectReferenceSecret) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:           op,
		Pod_FieldPathValue: NewPodFieldPathBuilder().Spec().ImagePullSecrets().WithValue(value),
	})
}

func (b *filterCndBuilderSpecImagePullSecrets) Name() *filterCndBuilderSpecImagePullSecretsName {
	return &filterCndBuilderSpecImagePullSecretsName{builder: b.builder}
}

type filterCndBuilderSpecImagePullSecretsName struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecImagePullSecretsName) In(values []*secrets_secret.Reference) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().ImagePullSecrets().Name().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecImagePullSecretsName) NotIn(values []*secrets_secret.Reference) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().ImagePullSecrets().Name().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecImagePullSecretsName) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPodFieldPathBuilder().Spec().ImagePullSecrets().Name().FieldPath(),
	})
}

func (b *filterCndBuilderSpecImagePullSecretsName) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPodFieldPathBuilder().Spec().ImagePullSecrets().Name().FieldPath(),
	})
}

func (b *filterCndBuilderSpecImagePullSecretsName) compare(op gotenfilter.CompareOperator, value *secrets_secret.Reference) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:           op,
		Pod_FieldPathValue: NewPodFieldPathBuilder().Spec().ImagePullSecrets().Name().WithValue(value),
	})
}

type filterCndBuilderSpecVolumes struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderSpecVolumes) Eq(value []*common.Volume) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderSpecVolumes) Neq(value []*common.Volume) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderSpecVolumes) Gt(value []*common.Volume) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderSpecVolumes) Gte(value []*common.Volume) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderSpecVolumes) Lt(value []*common.Volume) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderSpecVolumes) Lte(value []*common.Volume) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderSpecVolumes) In(values [][]*common.Volume) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Volumes().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecVolumes) NotIn(values [][]*common.Volume) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Volumes().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecVolumes) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPodFieldPathBuilder().Spec().Volumes().FieldPath(),
	})
}

func (b *filterCndBuilderSpecVolumes) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPodFieldPathBuilder().Spec().Volumes().FieldPath(),
	})
}

func (b *filterCndBuilderSpecVolumes) Contains(value *common.Volume) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewPodFieldPathBuilder().Spec().Volumes().FieldPath(),
		Value:     NewPodFieldPathBuilder().Spec().Volumes().WithItemValue(value),
	})
}

func (b *filterCndBuilderSpecVolumes) ContainsAnyOf(values []*common.Volume) *FilterBuilder {
	pathSelector := NewPodFieldPathBuilder().Spec().Volumes()
	itemValues := make([]Pod_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewPodFieldPathBuilder().Spec().Volumes().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderSpecVolumes) ContainsAll(values []*common.Volume) *FilterBuilder {
	pathSelector := NewPodFieldPathBuilder().Spec().Volumes()
	itemValues := make([]Pod_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewPodFieldPathBuilder().Spec().Volumes().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderSpecVolumes) compare(op gotenfilter.CompareOperator, value []*common.Volume) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:           op,
		Pod_FieldPathValue: NewPodFieldPathBuilder().Spec().Volumes().WithValue(value),
	})
}

func (b *filterCndBuilderSpecVolumes) Name() *filterCndBuilderSpecVolumesName {
	return &filterCndBuilderSpecVolumesName{builder: b.builder}
}

func (b *filterCndBuilderSpecVolumes) HostPath() *filterCndBuilderSpecVolumesHostPath {
	return &filterCndBuilderSpecVolumesHostPath{builder: b.builder}
}

func (b *filterCndBuilderSpecVolumes) Secret() *filterCndBuilderSpecVolumesSecret {
	return &filterCndBuilderSpecVolumesSecret{builder: b.builder}
}

func (b *filterCndBuilderSpecVolumes) ConfigMap() *filterCndBuilderSpecVolumesConfigMap {
	return &filterCndBuilderSpecVolumesConfigMap{builder: b.builder}
}

type filterCndBuilderSpecVolumesName struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecVolumesName) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Volumes().Name().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecVolumesName) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Volumes().Name().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecVolumesName) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPodFieldPathBuilder().Spec().Volumes().Name().FieldPath(),
	})
}

func (b *filterCndBuilderSpecVolumesName) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPodFieldPathBuilder().Spec().Volumes().Name().FieldPath(),
	})
}

func (b *filterCndBuilderSpecVolumesName) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:           op,
		Pod_FieldPathValue: NewPodFieldPathBuilder().Spec().Volumes().Name().WithValue(value),
	})
}

type filterCndBuilderSpecVolumesHostPath struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecVolumesHostPath) In(values []*common.HostPathVolumeSource) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Volumes().HostPath().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecVolumesHostPath) NotIn(values []*common.HostPathVolumeSource) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Volumes().HostPath().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecVolumesHostPath) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPodFieldPathBuilder().Spec().Volumes().HostPath().FieldPath(),
	})
}

func (b *filterCndBuilderSpecVolumesHostPath) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPodFieldPathBuilder().Spec().Volumes().HostPath().FieldPath(),
	})
}

func (b *filterCndBuilderSpecVolumesHostPath) compare(op gotenfilter.CompareOperator, value *common.HostPathVolumeSource) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:           op,
		Pod_FieldPathValue: NewPodFieldPathBuilder().Spec().Volumes().HostPath().WithValue(value),
	})
}

func (b *filterCndBuilderSpecVolumesHostPath) Path() *filterCndBuilderSpecVolumesHostPathPath {
	return &filterCndBuilderSpecVolumesHostPathPath{builder: b.builder}
}

func (b *filterCndBuilderSpecVolumesHostPath) Type() *filterCndBuilderSpecVolumesHostPathType {
	return &filterCndBuilderSpecVolumesHostPathType{builder: b.builder}
}

type filterCndBuilderSpecVolumesHostPathPath struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecVolumesHostPathPath) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Volumes().HostPath().Path().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecVolumesHostPathPath) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Volumes().HostPath().Path().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecVolumesHostPathPath) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPodFieldPathBuilder().Spec().Volumes().HostPath().Path().FieldPath(),
	})
}

func (b *filterCndBuilderSpecVolumesHostPathPath) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPodFieldPathBuilder().Spec().Volumes().HostPath().Path().FieldPath(),
	})
}

func (b *filterCndBuilderSpecVolumesHostPathPath) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:           op,
		Pod_FieldPathValue: NewPodFieldPathBuilder().Spec().Volumes().HostPath().Path().WithValue(value),
	})
}

type filterCndBuilderSpecVolumesHostPathType struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecVolumesHostPathType) In(values []common.HostPathVolumeSource_Type) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Volumes().HostPath().Type().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecVolumesHostPathType) NotIn(values []common.HostPathVolumeSource_Type) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Volumes().HostPath().Type().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecVolumesHostPathType) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPodFieldPathBuilder().Spec().Volumes().HostPath().Type().FieldPath(),
	})
}

func (b *filterCndBuilderSpecVolumesHostPathType) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPodFieldPathBuilder().Spec().Volumes().HostPath().Type().FieldPath(),
	})
}

func (b *filterCndBuilderSpecVolumesHostPathType) compare(op gotenfilter.CompareOperator, value common.HostPathVolumeSource_Type) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:           op,
		Pod_FieldPathValue: NewPodFieldPathBuilder().Spec().Volumes().HostPath().Type().WithValue(value),
	})
}

type filterCndBuilderSpecVolumesSecret struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecVolumesSecret) In(values []*common.SecretVolumeSource) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Volumes().Secret().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecVolumesSecret) NotIn(values []*common.SecretVolumeSource) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Volumes().Secret().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecVolumesSecret) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPodFieldPathBuilder().Spec().Volumes().Secret().FieldPath(),
	})
}

func (b *filterCndBuilderSpecVolumesSecret) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPodFieldPathBuilder().Spec().Volumes().Secret().FieldPath(),
	})
}

func (b *filterCndBuilderSpecVolumesSecret) compare(op gotenfilter.CompareOperator, value *common.SecretVolumeSource) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:           op,
		Pod_FieldPathValue: NewPodFieldPathBuilder().Spec().Volumes().Secret().WithValue(value),
	})
}

func (b *filterCndBuilderSpecVolumesSecret) SecretName() *filterCndBuilderSpecVolumesSecretSecretName {
	return &filterCndBuilderSpecVolumesSecretSecretName{builder: b.builder}
}

func (b *filterCndBuilderSpecVolumesSecret) Items() *filterCndBuilderSpecVolumesSecretItems {
	return &filterCndBuilderSpecVolumesSecretItems{builder: b.builder}
}

func (b *filterCndBuilderSpecVolumesSecret) DefaultMode() *filterCndBuilderSpecVolumesSecretDefaultMode {
	return &filterCndBuilderSpecVolumesSecretDefaultMode{builder: b.builder}
}

func (b *filterCndBuilderSpecVolumesSecret) Optional() *filterCndBuilderSpecVolumesSecretOptional {
	return &filterCndBuilderSpecVolumesSecretOptional{builder: b.builder}
}

type filterCndBuilderSpecVolumesSecretSecretName struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecVolumesSecretSecretName) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Volumes().Secret().SecretName().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecVolumesSecretSecretName) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Volumes().Secret().SecretName().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecVolumesSecretSecretName) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPodFieldPathBuilder().Spec().Volumes().Secret().SecretName().FieldPath(),
	})
}

func (b *filterCndBuilderSpecVolumesSecretSecretName) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPodFieldPathBuilder().Spec().Volumes().Secret().SecretName().FieldPath(),
	})
}

func (b *filterCndBuilderSpecVolumesSecretSecretName) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:           op,
		Pod_FieldPathValue: NewPodFieldPathBuilder().Spec().Volumes().Secret().SecretName().WithValue(value),
	})
}

type filterCndBuilderSpecVolumesSecretItems struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderSpecVolumesSecretItems) Eq(value []*common.KeyToPath) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderSpecVolumesSecretItems) Neq(value []*common.KeyToPath) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderSpecVolumesSecretItems) Gt(value []*common.KeyToPath) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderSpecVolumesSecretItems) Gte(value []*common.KeyToPath) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderSpecVolumesSecretItems) Lt(value []*common.KeyToPath) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderSpecVolumesSecretItems) Lte(value []*common.KeyToPath) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderSpecVolumesSecretItems) In(values [][]*common.KeyToPath) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Volumes().Secret().Items().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecVolumesSecretItems) NotIn(values [][]*common.KeyToPath) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Volumes().Secret().Items().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecVolumesSecretItems) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPodFieldPathBuilder().Spec().Volumes().Secret().Items().FieldPath(),
	})
}

func (b *filterCndBuilderSpecVolumesSecretItems) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPodFieldPathBuilder().Spec().Volumes().Secret().Items().FieldPath(),
	})
}

func (b *filterCndBuilderSpecVolumesSecretItems) Contains(value *common.KeyToPath) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewPodFieldPathBuilder().Spec().Volumes().Secret().Items().FieldPath(),
		Value:     NewPodFieldPathBuilder().Spec().Volumes().Secret().Items().WithItemValue(value),
	})
}

func (b *filterCndBuilderSpecVolumesSecretItems) ContainsAnyOf(values []*common.KeyToPath) *FilterBuilder {
	pathSelector := NewPodFieldPathBuilder().Spec().Volumes().Secret().Items()
	itemValues := make([]Pod_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewPodFieldPathBuilder().Spec().Volumes().Secret().Items().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderSpecVolumesSecretItems) ContainsAll(values []*common.KeyToPath) *FilterBuilder {
	pathSelector := NewPodFieldPathBuilder().Spec().Volumes().Secret().Items()
	itemValues := make([]Pod_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewPodFieldPathBuilder().Spec().Volumes().Secret().Items().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderSpecVolumesSecretItems) compare(op gotenfilter.CompareOperator, value []*common.KeyToPath) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:           op,
		Pod_FieldPathValue: NewPodFieldPathBuilder().Spec().Volumes().Secret().Items().WithValue(value),
	})
}

func (b *filterCndBuilderSpecVolumesSecretItems) Key() *filterCndBuilderSpecVolumesSecretItemsKey {
	return &filterCndBuilderSpecVolumesSecretItemsKey{builder: b.builder}
}

func (b *filterCndBuilderSpecVolumesSecretItems) Path() *filterCndBuilderSpecVolumesSecretItemsPath {
	return &filterCndBuilderSpecVolumesSecretItemsPath{builder: b.builder}
}

func (b *filterCndBuilderSpecVolumesSecretItems) Mode() *filterCndBuilderSpecVolumesSecretItemsMode {
	return &filterCndBuilderSpecVolumesSecretItemsMode{builder: b.builder}
}

type filterCndBuilderSpecVolumesSecretItemsKey struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecVolumesSecretItemsKey) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Volumes().Secret().Items().Key().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecVolumesSecretItemsKey) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Volumes().Secret().Items().Key().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecVolumesSecretItemsKey) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPodFieldPathBuilder().Spec().Volumes().Secret().Items().Key().FieldPath(),
	})
}

func (b *filterCndBuilderSpecVolumesSecretItemsKey) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPodFieldPathBuilder().Spec().Volumes().Secret().Items().Key().FieldPath(),
	})
}

func (b *filterCndBuilderSpecVolumesSecretItemsKey) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:           op,
		Pod_FieldPathValue: NewPodFieldPathBuilder().Spec().Volumes().Secret().Items().Key().WithValue(value),
	})
}

type filterCndBuilderSpecVolumesSecretItemsPath struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecVolumesSecretItemsPath) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Volumes().Secret().Items().Path().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecVolumesSecretItemsPath) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Volumes().Secret().Items().Path().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecVolumesSecretItemsPath) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPodFieldPathBuilder().Spec().Volumes().Secret().Items().Path().FieldPath(),
	})
}

func (b *filterCndBuilderSpecVolumesSecretItemsPath) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPodFieldPathBuilder().Spec().Volumes().Secret().Items().Path().FieldPath(),
	})
}

func (b *filterCndBuilderSpecVolumesSecretItemsPath) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:           op,
		Pod_FieldPathValue: NewPodFieldPathBuilder().Spec().Volumes().Secret().Items().Path().WithValue(value),
	})
}

type filterCndBuilderSpecVolumesSecretItemsMode struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecVolumesSecretItemsMode) In(values []int32) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Volumes().Secret().Items().Mode().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecVolumesSecretItemsMode) NotIn(values []int32) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Volumes().Secret().Items().Mode().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecVolumesSecretItemsMode) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPodFieldPathBuilder().Spec().Volumes().Secret().Items().Mode().FieldPath(),
	})
}

func (b *filterCndBuilderSpecVolumesSecretItemsMode) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPodFieldPathBuilder().Spec().Volumes().Secret().Items().Mode().FieldPath(),
	})
}

func (b *filterCndBuilderSpecVolumesSecretItemsMode) compare(op gotenfilter.CompareOperator, value int32) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:           op,
		Pod_FieldPathValue: NewPodFieldPathBuilder().Spec().Volumes().Secret().Items().Mode().WithValue(value),
	})
}

type filterCndBuilderSpecVolumesSecretDefaultMode struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecVolumesSecretDefaultMode) In(values []int32) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Volumes().Secret().DefaultMode().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecVolumesSecretDefaultMode) NotIn(values []int32) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Volumes().Secret().DefaultMode().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecVolumesSecretDefaultMode) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPodFieldPathBuilder().Spec().Volumes().Secret().DefaultMode().FieldPath(),
	})
}

func (b *filterCndBuilderSpecVolumesSecretDefaultMode) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPodFieldPathBuilder().Spec().Volumes().Secret().DefaultMode().FieldPath(),
	})
}

func (b *filterCndBuilderSpecVolumesSecretDefaultMode) compare(op gotenfilter.CompareOperator, value int32) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:           op,
		Pod_FieldPathValue: NewPodFieldPathBuilder().Spec().Volumes().Secret().DefaultMode().WithValue(value),
	})
}

type filterCndBuilderSpecVolumesSecretOptional struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecVolumesSecretOptional) In(values []bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Volumes().Secret().Optional().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecVolumesSecretOptional) NotIn(values []bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Volumes().Secret().Optional().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecVolumesSecretOptional) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPodFieldPathBuilder().Spec().Volumes().Secret().Optional().FieldPath(),
	})
}

func (b *filterCndBuilderSpecVolumesSecretOptional) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPodFieldPathBuilder().Spec().Volumes().Secret().Optional().FieldPath(),
	})
}

func (b *filterCndBuilderSpecVolumesSecretOptional) compare(op gotenfilter.CompareOperator, value bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:           op,
		Pod_FieldPathValue: NewPodFieldPathBuilder().Spec().Volumes().Secret().Optional().WithValue(value),
	})
}

type filterCndBuilderSpecVolumesConfigMap struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecVolumesConfigMap) In(values []*common.ConfigMapVolumeSource) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Volumes().ConfigMap().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecVolumesConfigMap) NotIn(values []*common.ConfigMapVolumeSource) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Volumes().ConfigMap().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecVolumesConfigMap) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPodFieldPathBuilder().Spec().Volumes().ConfigMap().FieldPath(),
	})
}

func (b *filterCndBuilderSpecVolumesConfigMap) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPodFieldPathBuilder().Spec().Volumes().ConfigMap().FieldPath(),
	})
}

func (b *filterCndBuilderSpecVolumesConfigMap) compare(op gotenfilter.CompareOperator, value *common.ConfigMapVolumeSource) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:           op,
		Pod_FieldPathValue: NewPodFieldPathBuilder().Spec().Volumes().ConfigMap().WithValue(value),
	})
}

func (b *filterCndBuilderSpecVolumesConfigMap) Name() *filterCndBuilderSpecVolumesConfigMapName {
	return &filterCndBuilderSpecVolumesConfigMapName{builder: b.builder}
}

func (b *filterCndBuilderSpecVolumesConfigMap) Items() *filterCndBuilderSpecVolumesConfigMapItems {
	return &filterCndBuilderSpecVolumesConfigMapItems{builder: b.builder}
}

func (b *filterCndBuilderSpecVolumesConfigMap) DefaultMode() *filterCndBuilderSpecVolumesConfigMapDefaultMode {
	return &filterCndBuilderSpecVolumesConfigMapDefaultMode{builder: b.builder}
}

func (b *filterCndBuilderSpecVolumesConfigMap) Optional() *filterCndBuilderSpecVolumesConfigMapOptional {
	return &filterCndBuilderSpecVolumesConfigMapOptional{builder: b.builder}
}

type filterCndBuilderSpecVolumesConfigMapName struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecVolumesConfigMapName) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Volumes().ConfigMap().Name().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecVolumesConfigMapName) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Volumes().ConfigMap().Name().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecVolumesConfigMapName) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPodFieldPathBuilder().Spec().Volumes().ConfigMap().Name().FieldPath(),
	})
}

func (b *filterCndBuilderSpecVolumesConfigMapName) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPodFieldPathBuilder().Spec().Volumes().ConfigMap().Name().FieldPath(),
	})
}

func (b *filterCndBuilderSpecVolumesConfigMapName) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:           op,
		Pod_FieldPathValue: NewPodFieldPathBuilder().Spec().Volumes().ConfigMap().Name().WithValue(value),
	})
}

type filterCndBuilderSpecVolumesConfigMapItems struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderSpecVolumesConfigMapItems) Eq(value []*common.KeyToPath) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderSpecVolumesConfigMapItems) Neq(value []*common.KeyToPath) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderSpecVolumesConfigMapItems) Gt(value []*common.KeyToPath) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderSpecVolumesConfigMapItems) Gte(value []*common.KeyToPath) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderSpecVolumesConfigMapItems) Lt(value []*common.KeyToPath) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderSpecVolumesConfigMapItems) Lte(value []*common.KeyToPath) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderSpecVolumesConfigMapItems) In(values [][]*common.KeyToPath) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Volumes().ConfigMap().Items().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecVolumesConfigMapItems) NotIn(values [][]*common.KeyToPath) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Volumes().ConfigMap().Items().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecVolumesConfigMapItems) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPodFieldPathBuilder().Spec().Volumes().ConfigMap().Items().FieldPath(),
	})
}

func (b *filterCndBuilderSpecVolumesConfigMapItems) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPodFieldPathBuilder().Spec().Volumes().ConfigMap().Items().FieldPath(),
	})
}

func (b *filterCndBuilderSpecVolumesConfigMapItems) Contains(value *common.KeyToPath) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewPodFieldPathBuilder().Spec().Volumes().ConfigMap().Items().FieldPath(),
		Value:     NewPodFieldPathBuilder().Spec().Volumes().ConfigMap().Items().WithItemValue(value),
	})
}

func (b *filterCndBuilderSpecVolumesConfigMapItems) ContainsAnyOf(values []*common.KeyToPath) *FilterBuilder {
	pathSelector := NewPodFieldPathBuilder().Spec().Volumes().ConfigMap().Items()
	itemValues := make([]Pod_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewPodFieldPathBuilder().Spec().Volumes().ConfigMap().Items().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderSpecVolumesConfigMapItems) ContainsAll(values []*common.KeyToPath) *FilterBuilder {
	pathSelector := NewPodFieldPathBuilder().Spec().Volumes().ConfigMap().Items()
	itemValues := make([]Pod_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewPodFieldPathBuilder().Spec().Volumes().ConfigMap().Items().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderSpecVolumesConfigMapItems) compare(op gotenfilter.CompareOperator, value []*common.KeyToPath) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:           op,
		Pod_FieldPathValue: NewPodFieldPathBuilder().Spec().Volumes().ConfigMap().Items().WithValue(value),
	})
}

func (b *filterCndBuilderSpecVolumesConfigMapItems) Key() *filterCndBuilderSpecVolumesConfigMapItemsKey {
	return &filterCndBuilderSpecVolumesConfigMapItemsKey{builder: b.builder}
}

func (b *filterCndBuilderSpecVolumesConfigMapItems) Path() *filterCndBuilderSpecVolumesConfigMapItemsPath {
	return &filterCndBuilderSpecVolumesConfigMapItemsPath{builder: b.builder}
}

func (b *filterCndBuilderSpecVolumesConfigMapItems) Mode() *filterCndBuilderSpecVolumesConfigMapItemsMode {
	return &filterCndBuilderSpecVolumesConfigMapItemsMode{builder: b.builder}
}

type filterCndBuilderSpecVolumesConfigMapItemsKey struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecVolumesConfigMapItemsKey) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Volumes().ConfigMap().Items().Key().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecVolumesConfigMapItemsKey) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Volumes().ConfigMap().Items().Key().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecVolumesConfigMapItemsKey) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPodFieldPathBuilder().Spec().Volumes().ConfigMap().Items().Key().FieldPath(),
	})
}

func (b *filterCndBuilderSpecVolumesConfigMapItemsKey) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPodFieldPathBuilder().Spec().Volumes().ConfigMap().Items().Key().FieldPath(),
	})
}

func (b *filterCndBuilderSpecVolumesConfigMapItemsKey) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:           op,
		Pod_FieldPathValue: NewPodFieldPathBuilder().Spec().Volumes().ConfigMap().Items().Key().WithValue(value),
	})
}

type filterCndBuilderSpecVolumesConfigMapItemsPath struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecVolumesConfigMapItemsPath) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Volumes().ConfigMap().Items().Path().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecVolumesConfigMapItemsPath) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Volumes().ConfigMap().Items().Path().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecVolumesConfigMapItemsPath) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPodFieldPathBuilder().Spec().Volumes().ConfigMap().Items().Path().FieldPath(),
	})
}

func (b *filterCndBuilderSpecVolumesConfigMapItemsPath) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPodFieldPathBuilder().Spec().Volumes().ConfigMap().Items().Path().FieldPath(),
	})
}

func (b *filterCndBuilderSpecVolumesConfigMapItemsPath) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:           op,
		Pod_FieldPathValue: NewPodFieldPathBuilder().Spec().Volumes().ConfigMap().Items().Path().WithValue(value),
	})
}

type filterCndBuilderSpecVolumesConfigMapItemsMode struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecVolumesConfigMapItemsMode) In(values []int32) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Volumes().ConfigMap().Items().Mode().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecVolumesConfigMapItemsMode) NotIn(values []int32) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Volumes().ConfigMap().Items().Mode().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecVolumesConfigMapItemsMode) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPodFieldPathBuilder().Spec().Volumes().ConfigMap().Items().Mode().FieldPath(),
	})
}

func (b *filterCndBuilderSpecVolumesConfigMapItemsMode) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPodFieldPathBuilder().Spec().Volumes().ConfigMap().Items().Mode().FieldPath(),
	})
}

func (b *filterCndBuilderSpecVolumesConfigMapItemsMode) compare(op gotenfilter.CompareOperator, value int32) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:           op,
		Pod_FieldPathValue: NewPodFieldPathBuilder().Spec().Volumes().ConfigMap().Items().Mode().WithValue(value),
	})
}

type filterCndBuilderSpecVolumesConfigMapDefaultMode struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecVolumesConfigMapDefaultMode) In(values []int32) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Volumes().ConfigMap().DefaultMode().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecVolumesConfigMapDefaultMode) NotIn(values []int32) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Volumes().ConfigMap().DefaultMode().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecVolumesConfigMapDefaultMode) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPodFieldPathBuilder().Spec().Volumes().ConfigMap().DefaultMode().FieldPath(),
	})
}

func (b *filterCndBuilderSpecVolumesConfigMapDefaultMode) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPodFieldPathBuilder().Spec().Volumes().ConfigMap().DefaultMode().FieldPath(),
	})
}

func (b *filterCndBuilderSpecVolumesConfigMapDefaultMode) compare(op gotenfilter.CompareOperator, value int32) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:           op,
		Pod_FieldPathValue: NewPodFieldPathBuilder().Spec().Volumes().ConfigMap().DefaultMode().WithValue(value),
	})
}

type filterCndBuilderSpecVolumesConfigMapOptional struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecVolumesConfigMapOptional) In(values []bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Volumes().ConfigMap().Optional().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecVolumesConfigMapOptional) NotIn(values []bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Volumes().ConfigMap().Optional().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecVolumesConfigMapOptional) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPodFieldPathBuilder().Spec().Volumes().ConfigMap().Optional().FieldPath(),
	})
}

func (b *filterCndBuilderSpecVolumesConfigMapOptional) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPodFieldPathBuilder().Spec().Volumes().ConfigMap().Optional().FieldPath(),
	})
}

func (b *filterCndBuilderSpecVolumesConfigMapOptional) compare(op gotenfilter.CompareOperator, value bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:           op,
		Pod_FieldPathValue: NewPodFieldPathBuilder().Spec().Volumes().ConfigMap().Optional().WithValue(value),
	})
}

type filterCndBuilderSpecCompose struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecCompose) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Compose().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecCompose) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().Compose().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecCompose) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPodFieldPathBuilder().Spec().Compose().FieldPath(),
	})
}

func (b *filterCndBuilderSpecCompose) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPodFieldPathBuilder().Spec().Compose().FieldPath(),
	})
}

func (b *filterCndBuilderSpecCompose) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:           op,
		Pod_FieldPathValue: NewPodFieldPathBuilder().Spec().Compose().WithValue(value),
	})
}

type filterCndBuilderSpecHostVolumeMounts struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderSpecHostVolumeMounts) Eq(value []*common.VolumeMount) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderSpecHostVolumeMounts) Neq(value []*common.VolumeMount) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderSpecHostVolumeMounts) Gt(value []*common.VolumeMount) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderSpecHostVolumeMounts) Gte(value []*common.VolumeMount) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderSpecHostVolumeMounts) Lt(value []*common.VolumeMount) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderSpecHostVolumeMounts) Lte(value []*common.VolumeMount) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderSpecHostVolumeMounts) In(values [][]*common.VolumeMount) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().HostVolumeMounts().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecHostVolumeMounts) NotIn(values [][]*common.VolumeMount) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().HostVolumeMounts().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecHostVolumeMounts) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPodFieldPathBuilder().Spec().HostVolumeMounts().FieldPath(),
	})
}

func (b *filterCndBuilderSpecHostVolumeMounts) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPodFieldPathBuilder().Spec().HostVolumeMounts().FieldPath(),
	})
}

func (b *filterCndBuilderSpecHostVolumeMounts) Contains(value *common.VolumeMount) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewPodFieldPathBuilder().Spec().HostVolumeMounts().FieldPath(),
		Value:     NewPodFieldPathBuilder().Spec().HostVolumeMounts().WithItemValue(value),
	})
}

func (b *filterCndBuilderSpecHostVolumeMounts) ContainsAnyOf(values []*common.VolumeMount) *FilterBuilder {
	pathSelector := NewPodFieldPathBuilder().Spec().HostVolumeMounts()
	itemValues := make([]Pod_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewPodFieldPathBuilder().Spec().HostVolumeMounts().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderSpecHostVolumeMounts) ContainsAll(values []*common.VolumeMount) *FilterBuilder {
	pathSelector := NewPodFieldPathBuilder().Spec().HostVolumeMounts()
	itemValues := make([]Pod_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewPodFieldPathBuilder().Spec().HostVolumeMounts().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderSpecHostVolumeMounts) compare(op gotenfilter.CompareOperator, value []*common.VolumeMount) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:           op,
		Pod_FieldPathValue: NewPodFieldPathBuilder().Spec().HostVolumeMounts().WithValue(value),
	})
}

func (b *filterCndBuilderSpecHostVolumeMounts) Name() *filterCndBuilderSpecHostVolumeMountsName {
	return &filterCndBuilderSpecHostVolumeMountsName{builder: b.builder}
}

func (b *filterCndBuilderSpecHostVolumeMounts) ReadOnly() *filterCndBuilderSpecHostVolumeMountsReadOnly {
	return &filterCndBuilderSpecHostVolumeMountsReadOnly{builder: b.builder}
}

func (b *filterCndBuilderSpecHostVolumeMounts) MountPath() *filterCndBuilderSpecHostVolumeMountsMountPath {
	return &filterCndBuilderSpecHostVolumeMountsMountPath{builder: b.builder}
}

func (b *filterCndBuilderSpecHostVolumeMounts) SubPath() *filterCndBuilderSpecHostVolumeMountsSubPath {
	return &filterCndBuilderSpecHostVolumeMountsSubPath{builder: b.builder}
}

type filterCndBuilderSpecHostVolumeMountsName struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecHostVolumeMountsName) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().HostVolumeMounts().Name().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecHostVolumeMountsName) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().HostVolumeMounts().Name().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecHostVolumeMountsName) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPodFieldPathBuilder().Spec().HostVolumeMounts().Name().FieldPath(),
	})
}

func (b *filterCndBuilderSpecHostVolumeMountsName) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPodFieldPathBuilder().Spec().HostVolumeMounts().Name().FieldPath(),
	})
}

func (b *filterCndBuilderSpecHostVolumeMountsName) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:           op,
		Pod_FieldPathValue: NewPodFieldPathBuilder().Spec().HostVolumeMounts().Name().WithValue(value),
	})
}

type filterCndBuilderSpecHostVolumeMountsReadOnly struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecHostVolumeMountsReadOnly) In(values []bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().HostVolumeMounts().ReadOnly().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecHostVolumeMountsReadOnly) NotIn(values []bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().HostVolumeMounts().ReadOnly().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecHostVolumeMountsReadOnly) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPodFieldPathBuilder().Spec().HostVolumeMounts().ReadOnly().FieldPath(),
	})
}

func (b *filterCndBuilderSpecHostVolumeMountsReadOnly) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPodFieldPathBuilder().Spec().HostVolumeMounts().ReadOnly().FieldPath(),
	})
}

func (b *filterCndBuilderSpecHostVolumeMountsReadOnly) compare(op gotenfilter.CompareOperator, value bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:           op,
		Pod_FieldPathValue: NewPodFieldPathBuilder().Spec().HostVolumeMounts().ReadOnly().WithValue(value),
	})
}

type filterCndBuilderSpecHostVolumeMountsMountPath struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecHostVolumeMountsMountPath) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().HostVolumeMounts().MountPath().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecHostVolumeMountsMountPath) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().HostVolumeMounts().MountPath().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecHostVolumeMountsMountPath) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPodFieldPathBuilder().Spec().HostVolumeMounts().MountPath().FieldPath(),
	})
}

func (b *filterCndBuilderSpecHostVolumeMountsMountPath) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPodFieldPathBuilder().Spec().HostVolumeMounts().MountPath().FieldPath(),
	})
}

func (b *filterCndBuilderSpecHostVolumeMountsMountPath) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:           op,
		Pod_FieldPathValue: NewPodFieldPathBuilder().Spec().HostVolumeMounts().MountPath().WithValue(value),
	})
}

type filterCndBuilderSpecHostVolumeMountsSubPath struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecHostVolumeMountsSubPath) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().HostVolumeMounts().SubPath().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecHostVolumeMountsSubPath) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Spec().HostVolumeMounts().SubPath().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecHostVolumeMountsSubPath) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPodFieldPathBuilder().Spec().HostVolumeMounts().SubPath().FieldPath(),
	})
}

func (b *filterCndBuilderSpecHostVolumeMountsSubPath) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPodFieldPathBuilder().Spec().HostVolumeMounts().SubPath().FieldPath(),
	})
}

func (b *filterCndBuilderSpecHostVolumeMountsSubPath) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:           op,
		Pod_FieldPathValue: NewPodFieldPathBuilder().Spec().HostVolumeMounts().SubPath().WithValue(value),
	})
}

type filterCndBuilderDistribution struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderDistribution) In(values []*distribution.Reference) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Distribution().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderDistribution) NotIn(values []*distribution.Reference) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Distribution().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderDistribution) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPodFieldPathBuilder().Distribution().FieldPath(),
	})
}

func (b *filterCndBuilderDistribution) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPodFieldPathBuilder().Distribution().FieldPath(),
	})
}

func (b *filterCndBuilderDistribution) compare(op gotenfilter.CompareOperator, value *distribution.Reference) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:           op,
		Pod_FieldPathValue: NewPodFieldPathBuilder().Distribution().WithValue(value),
	})
}

type filterCndBuilderStatus struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatus) Eq(value *Pod_Status) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatus) Neq(value *Pod_Status) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatus) Gt(value *Pod_Status) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatus) Gte(value *Pod_Status) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatus) Lt(value *Pod_Status) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatus) Lte(value *Pod_Status) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatus) In(values []*Pod_Status) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Status().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatus) NotIn(values []*Pod_Status) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Status().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatus) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPodFieldPathBuilder().Status().FieldPath(),
	})
}

func (b *filterCndBuilderStatus) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPodFieldPathBuilder().Status().FieldPath(),
	})
}

func (b *filterCndBuilderStatus) compare(op gotenfilter.CompareOperator, value *Pod_Status) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:           op,
		Pod_FieldPathValue: NewPodFieldPathBuilder().Status().WithValue(value),
	})
}

func (b *filterCndBuilderStatus) Phase() *filterCndBuilderStatusPhase {
	return &filterCndBuilderStatusPhase{builder: b.builder}
}

func (b *filterCndBuilderStatus) ContainerStatuses() *filterCndBuilderStatusContainerStatuses {
	return &filterCndBuilderStatusContainerStatuses{builder: b.builder}
}

func (b *filterCndBuilderStatus) Error() *filterCndBuilderStatusError {
	return &filterCndBuilderStatusError{builder: b.builder}
}

type filterCndBuilderStatusPhase struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusPhase) Eq(value Pod_Status_Phase) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusPhase) Neq(value Pod_Status_Phase) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusPhase) Gt(value Pod_Status_Phase) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusPhase) Gte(value Pod_Status_Phase) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusPhase) Lt(value Pod_Status_Phase) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusPhase) Lte(value Pod_Status_Phase) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusPhase) In(values []Pod_Status_Phase) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Status().Phase().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusPhase) NotIn(values []Pod_Status_Phase) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Status().Phase().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusPhase) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPodFieldPathBuilder().Status().Phase().FieldPath(),
	})
}

func (b *filterCndBuilderStatusPhase) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPodFieldPathBuilder().Status().Phase().FieldPath(),
	})
}

func (b *filterCndBuilderStatusPhase) compare(op gotenfilter.CompareOperator, value Pod_Status_Phase) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:           op,
		Pod_FieldPathValue: NewPodFieldPathBuilder().Status().Phase().WithValue(value),
	})
}

type filterCndBuilderStatusContainerStatuses struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusContainerStatuses) In(values [][]*Pod_Status_Container) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Status().ContainerStatuses().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusContainerStatuses) NotIn(values [][]*Pod_Status_Container) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Status().ContainerStatuses().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusContainerStatuses) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPodFieldPathBuilder().Status().ContainerStatuses().FieldPath(),
	})
}

func (b *filterCndBuilderStatusContainerStatuses) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPodFieldPathBuilder().Status().ContainerStatuses().FieldPath(),
	})
}

func (b *filterCndBuilderStatusContainerStatuses) Contains(value *Pod_Status_Container) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewPodFieldPathBuilder().Status().ContainerStatuses().FieldPath(),
		Value:     NewPodFieldPathBuilder().Status().ContainerStatuses().WithItemValue(value),
	})
}

func (b *filterCndBuilderStatusContainerStatuses) ContainsAnyOf(values []*Pod_Status_Container) *FilterBuilder {
	pathSelector := NewPodFieldPathBuilder().Status().ContainerStatuses()
	itemValues := make([]Pod_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewPodFieldPathBuilder().Status().ContainerStatuses().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderStatusContainerStatuses) ContainsAll(values []*Pod_Status_Container) *FilterBuilder {
	pathSelector := NewPodFieldPathBuilder().Status().ContainerStatuses()
	itemValues := make([]Pod_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewPodFieldPathBuilder().Status().ContainerStatuses().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderStatusContainerStatuses) compare(op gotenfilter.CompareOperator, value []*Pod_Status_Container) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:           op,
		Pod_FieldPathValue: NewPodFieldPathBuilder().Status().ContainerStatuses().WithValue(value),
	})
}

func (b *filterCndBuilderStatusContainerStatuses) Name() *filterCndBuilderStatusContainerStatusesName {
	return &filterCndBuilderStatusContainerStatusesName{builder: b.builder}
}

func (b *filterCndBuilderStatusContainerStatuses) State() *filterCndBuilderStatusContainerStatusesState {
	return &filterCndBuilderStatusContainerStatusesState{builder: b.builder}
}

func (b *filterCndBuilderStatusContainerStatuses) Waiting() *filterCndBuilderStatusContainerStatusesWaiting {
	return &filterCndBuilderStatusContainerStatusesWaiting{builder: b.builder}
}

func (b *filterCndBuilderStatusContainerStatuses) Running() *filterCndBuilderStatusContainerStatusesRunning {
	return &filterCndBuilderStatusContainerStatusesRunning{builder: b.builder}
}

func (b *filterCndBuilderStatusContainerStatuses) Terminated() *filterCndBuilderStatusContainerStatusesTerminated {
	return &filterCndBuilderStatusContainerStatusesTerminated{builder: b.builder}
}

type filterCndBuilderStatusContainerStatusesName struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusContainerStatusesName) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Status().ContainerStatuses().Name().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusContainerStatusesName) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Status().ContainerStatuses().Name().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusContainerStatusesName) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPodFieldPathBuilder().Status().ContainerStatuses().Name().FieldPath(),
	})
}

func (b *filterCndBuilderStatusContainerStatusesName) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPodFieldPathBuilder().Status().ContainerStatuses().Name().FieldPath(),
	})
}

func (b *filterCndBuilderStatusContainerStatusesName) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:           op,
		Pod_FieldPathValue: NewPodFieldPathBuilder().Status().ContainerStatuses().Name().WithValue(value),
	})
}

type filterCndBuilderStatusContainerStatusesState struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusContainerStatusesState) Eq(value Pod_Status_Container_State) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusContainerStatusesState) Neq(value Pod_Status_Container_State) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusContainerStatusesState) Gt(value Pod_Status_Container_State) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusContainerStatusesState) Gte(value Pod_Status_Container_State) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusContainerStatusesState) Lt(value Pod_Status_Container_State) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusContainerStatusesState) Lte(value Pod_Status_Container_State) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusContainerStatusesState) In(values []Pod_Status_Container_State) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Status().ContainerStatuses().State().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusContainerStatusesState) NotIn(values []Pod_Status_Container_State) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Status().ContainerStatuses().State().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusContainerStatusesState) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPodFieldPathBuilder().Status().ContainerStatuses().State().FieldPath(),
	})
}

func (b *filterCndBuilderStatusContainerStatusesState) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPodFieldPathBuilder().Status().ContainerStatuses().State().FieldPath(),
	})
}

func (b *filterCndBuilderStatusContainerStatusesState) compare(op gotenfilter.CompareOperator, value Pod_Status_Container_State) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:           op,
		Pod_FieldPathValue: NewPodFieldPathBuilder().Status().ContainerStatuses().State().WithValue(value),
	})
}

type filterCndBuilderStatusContainerStatusesWaiting struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusContainerStatusesWaiting) Eq(value *Pod_Status_Container_StateWaiting) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusContainerStatusesWaiting) Neq(value *Pod_Status_Container_StateWaiting) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusContainerStatusesWaiting) Gt(value *Pod_Status_Container_StateWaiting) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusContainerStatusesWaiting) Gte(value *Pod_Status_Container_StateWaiting) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusContainerStatusesWaiting) Lt(value *Pod_Status_Container_StateWaiting) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusContainerStatusesWaiting) Lte(value *Pod_Status_Container_StateWaiting) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusContainerStatusesWaiting) In(values []*Pod_Status_Container_StateWaiting) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Status().ContainerStatuses().Waiting().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusContainerStatusesWaiting) NotIn(values []*Pod_Status_Container_StateWaiting) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Status().ContainerStatuses().Waiting().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusContainerStatusesWaiting) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPodFieldPathBuilder().Status().ContainerStatuses().Waiting().FieldPath(),
	})
}

func (b *filterCndBuilderStatusContainerStatusesWaiting) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPodFieldPathBuilder().Status().ContainerStatuses().Waiting().FieldPath(),
	})
}

func (b *filterCndBuilderStatusContainerStatusesWaiting) compare(op gotenfilter.CompareOperator, value *Pod_Status_Container_StateWaiting) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:           op,
		Pod_FieldPathValue: NewPodFieldPathBuilder().Status().ContainerStatuses().Waiting().WithValue(value),
	})
}

func (b *filterCndBuilderStatusContainerStatusesWaiting) Reason() *filterCndBuilderStatusContainerStatusesWaitingReason {
	return &filterCndBuilderStatusContainerStatusesWaitingReason{builder: b.builder}
}

func (b *filterCndBuilderStatusContainerStatusesWaiting) Message() *filterCndBuilderStatusContainerStatusesWaitingMessage {
	return &filterCndBuilderStatusContainerStatusesWaitingMessage{builder: b.builder}
}

type filterCndBuilderStatusContainerStatusesWaitingReason struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusContainerStatusesWaitingReason) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Status().ContainerStatuses().Waiting().Reason().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusContainerStatusesWaitingReason) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Status().ContainerStatuses().Waiting().Reason().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusContainerStatusesWaitingReason) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPodFieldPathBuilder().Status().ContainerStatuses().Waiting().Reason().FieldPath(),
	})
}

func (b *filterCndBuilderStatusContainerStatusesWaitingReason) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPodFieldPathBuilder().Status().ContainerStatuses().Waiting().Reason().FieldPath(),
	})
}

func (b *filterCndBuilderStatusContainerStatusesWaitingReason) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:           op,
		Pod_FieldPathValue: NewPodFieldPathBuilder().Status().ContainerStatuses().Waiting().Reason().WithValue(value),
	})
}

type filterCndBuilderStatusContainerStatusesWaitingMessage struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusContainerStatusesWaitingMessage) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Status().ContainerStatuses().Waiting().Message().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusContainerStatusesWaitingMessage) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Status().ContainerStatuses().Waiting().Message().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusContainerStatusesWaitingMessage) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPodFieldPathBuilder().Status().ContainerStatuses().Waiting().Message().FieldPath(),
	})
}

func (b *filterCndBuilderStatusContainerStatusesWaitingMessage) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPodFieldPathBuilder().Status().ContainerStatuses().Waiting().Message().FieldPath(),
	})
}

func (b *filterCndBuilderStatusContainerStatusesWaitingMessage) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:           op,
		Pod_FieldPathValue: NewPodFieldPathBuilder().Status().ContainerStatuses().Waiting().Message().WithValue(value),
	})
}

type filterCndBuilderStatusContainerStatusesRunning struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusContainerStatusesRunning) Eq(value *Pod_Status_Container_StateRunning) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusContainerStatusesRunning) Neq(value *Pod_Status_Container_StateRunning) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusContainerStatusesRunning) Gt(value *Pod_Status_Container_StateRunning) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusContainerStatusesRunning) Gte(value *Pod_Status_Container_StateRunning) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusContainerStatusesRunning) Lt(value *Pod_Status_Container_StateRunning) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusContainerStatusesRunning) Lte(value *Pod_Status_Container_StateRunning) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusContainerStatusesRunning) In(values []*Pod_Status_Container_StateRunning) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Status().ContainerStatuses().Running().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusContainerStatusesRunning) NotIn(values []*Pod_Status_Container_StateRunning) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Status().ContainerStatuses().Running().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusContainerStatusesRunning) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPodFieldPathBuilder().Status().ContainerStatuses().Running().FieldPath(),
	})
}

func (b *filterCndBuilderStatusContainerStatusesRunning) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPodFieldPathBuilder().Status().ContainerStatuses().Running().FieldPath(),
	})
}

func (b *filterCndBuilderStatusContainerStatusesRunning) compare(op gotenfilter.CompareOperator, value *Pod_Status_Container_StateRunning) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:           op,
		Pod_FieldPathValue: NewPodFieldPathBuilder().Status().ContainerStatuses().Running().WithValue(value),
	})
}

func (b *filterCndBuilderStatusContainerStatusesRunning) StartedAt() *filterCndBuilderStatusContainerStatusesRunningStartedAt {
	return &filterCndBuilderStatusContainerStatusesRunningStartedAt{builder: b.builder}
}

type filterCndBuilderStatusContainerStatusesRunningStartedAt struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusContainerStatusesRunningStartedAt) In(values []*timestamppb.Timestamp) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Status().ContainerStatuses().Running().StartedAt().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusContainerStatusesRunningStartedAt) NotIn(values []*timestamppb.Timestamp) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Status().ContainerStatuses().Running().StartedAt().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusContainerStatusesRunningStartedAt) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPodFieldPathBuilder().Status().ContainerStatuses().Running().StartedAt().FieldPath(),
	})
}

func (b *filterCndBuilderStatusContainerStatusesRunningStartedAt) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPodFieldPathBuilder().Status().ContainerStatuses().Running().StartedAt().FieldPath(),
	})
}

func (b *filterCndBuilderStatusContainerStatusesRunningStartedAt) compare(op gotenfilter.CompareOperator, value *timestamppb.Timestamp) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:           op,
		Pod_FieldPathValue: NewPodFieldPathBuilder().Status().ContainerStatuses().Running().StartedAt().WithValue(value),
	})
}

type filterCndBuilderStatusContainerStatusesTerminated struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusContainerStatusesTerminated) Eq(value *Pod_Status_Container_StateTerminated) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusContainerStatusesTerminated) Neq(value *Pod_Status_Container_StateTerminated) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusContainerStatusesTerminated) Gt(value *Pod_Status_Container_StateTerminated) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusContainerStatusesTerminated) Gte(value *Pod_Status_Container_StateTerminated) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusContainerStatusesTerminated) Lt(value *Pod_Status_Container_StateTerminated) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusContainerStatusesTerminated) Lte(value *Pod_Status_Container_StateTerminated) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusContainerStatusesTerminated) In(values []*Pod_Status_Container_StateTerminated) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Status().ContainerStatuses().Terminated().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusContainerStatusesTerminated) NotIn(values []*Pod_Status_Container_StateTerminated) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Status().ContainerStatuses().Terminated().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusContainerStatusesTerminated) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPodFieldPathBuilder().Status().ContainerStatuses().Terminated().FieldPath(),
	})
}

func (b *filterCndBuilderStatusContainerStatusesTerminated) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPodFieldPathBuilder().Status().ContainerStatuses().Terminated().FieldPath(),
	})
}

func (b *filterCndBuilderStatusContainerStatusesTerminated) compare(op gotenfilter.CompareOperator, value *Pod_Status_Container_StateTerminated) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:           op,
		Pod_FieldPathValue: NewPodFieldPathBuilder().Status().ContainerStatuses().Terminated().WithValue(value),
	})
}

func (b *filterCndBuilderStatusContainerStatusesTerminated) ExitCode() *filterCndBuilderStatusContainerStatusesTerminatedExitCode {
	return &filterCndBuilderStatusContainerStatusesTerminatedExitCode{builder: b.builder}
}

func (b *filterCndBuilderStatusContainerStatusesTerminated) Signal() *filterCndBuilderStatusContainerStatusesTerminatedSignal {
	return &filterCndBuilderStatusContainerStatusesTerminatedSignal{builder: b.builder}
}

func (b *filterCndBuilderStatusContainerStatusesTerminated) Reason() *filterCndBuilderStatusContainerStatusesTerminatedReason {
	return &filterCndBuilderStatusContainerStatusesTerminatedReason{builder: b.builder}
}

func (b *filterCndBuilderStatusContainerStatusesTerminated) Message() *filterCndBuilderStatusContainerStatusesTerminatedMessage {
	return &filterCndBuilderStatusContainerStatusesTerminatedMessage{builder: b.builder}
}

func (b *filterCndBuilderStatusContainerStatusesTerminated) StartedAt() *filterCndBuilderStatusContainerStatusesTerminatedStartedAt {
	return &filterCndBuilderStatusContainerStatusesTerminatedStartedAt{builder: b.builder}
}

func (b *filterCndBuilderStatusContainerStatusesTerminated) FinishedAt() *filterCndBuilderStatusContainerStatusesTerminatedFinishedAt {
	return &filterCndBuilderStatusContainerStatusesTerminatedFinishedAt{builder: b.builder}
}

func (b *filterCndBuilderStatusContainerStatusesTerminated) ContainerId() *filterCndBuilderStatusContainerStatusesTerminatedContainerId {
	return &filterCndBuilderStatusContainerStatusesTerminatedContainerId{builder: b.builder}
}

type filterCndBuilderStatusContainerStatusesTerminatedExitCode struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusContainerStatusesTerminatedExitCode) In(values []int32) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Status().ContainerStatuses().Terminated().ExitCode().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusContainerStatusesTerminatedExitCode) NotIn(values []int32) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Status().ContainerStatuses().Terminated().ExitCode().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusContainerStatusesTerminatedExitCode) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPodFieldPathBuilder().Status().ContainerStatuses().Terminated().ExitCode().FieldPath(),
	})
}

func (b *filterCndBuilderStatusContainerStatusesTerminatedExitCode) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPodFieldPathBuilder().Status().ContainerStatuses().Terminated().ExitCode().FieldPath(),
	})
}

func (b *filterCndBuilderStatusContainerStatusesTerminatedExitCode) compare(op gotenfilter.CompareOperator, value int32) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:           op,
		Pod_FieldPathValue: NewPodFieldPathBuilder().Status().ContainerStatuses().Terminated().ExitCode().WithValue(value),
	})
}

type filterCndBuilderStatusContainerStatusesTerminatedSignal struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusContainerStatusesTerminatedSignal) In(values []int32) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Status().ContainerStatuses().Terminated().Signal().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusContainerStatusesTerminatedSignal) NotIn(values []int32) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Status().ContainerStatuses().Terminated().Signal().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusContainerStatusesTerminatedSignal) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPodFieldPathBuilder().Status().ContainerStatuses().Terminated().Signal().FieldPath(),
	})
}

func (b *filterCndBuilderStatusContainerStatusesTerminatedSignal) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPodFieldPathBuilder().Status().ContainerStatuses().Terminated().Signal().FieldPath(),
	})
}

func (b *filterCndBuilderStatusContainerStatusesTerminatedSignal) compare(op gotenfilter.CompareOperator, value int32) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:           op,
		Pod_FieldPathValue: NewPodFieldPathBuilder().Status().ContainerStatuses().Terminated().Signal().WithValue(value),
	})
}

type filterCndBuilderStatusContainerStatusesTerminatedReason struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusContainerStatusesTerminatedReason) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Status().ContainerStatuses().Terminated().Reason().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusContainerStatusesTerminatedReason) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Status().ContainerStatuses().Terminated().Reason().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusContainerStatusesTerminatedReason) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPodFieldPathBuilder().Status().ContainerStatuses().Terminated().Reason().FieldPath(),
	})
}

func (b *filterCndBuilderStatusContainerStatusesTerminatedReason) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPodFieldPathBuilder().Status().ContainerStatuses().Terminated().Reason().FieldPath(),
	})
}

func (b *filterCndBuilderStatusContainerStatusesTerminatedReason) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:           op,
		Pod_FieldPathValue: NewPodFieldPathBuilder().Status().ContainerStatuses().Terminated().Reason().WithValue(value),
	})
}

type filterCndBuilderStatusContainerStatusesTerminatedMessage struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusContainerStatusesTerminatedMessage) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Status().ContainerStatuses().Terminated().Message().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusContainerStatusesTerminatedMessage) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Status().ContainerStatuses().Terminated().Message().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusContainerStatusesTerminatedMessage) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPodFieldPathBuilder().Status().ContainerStatuses().Terminated().Message().FieldPath(),
	})
}

func (b *filterCndBuilderStatusContainerStatusesTerminatedMessage) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPodFieldPathBuilder().Status().ContainerStatuses().Terminated().Message().FieldPath(),
	})
}

func (b *filterCndBuilderStatusContainerStatusesTerminatedMessage) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:           op,
		Pod_FieldPathValue: NewPodFieldPathBuilder().Status().ContainerStatuses().Terminated().Message().WithValue(value),
	})
}

type filterCndBuilderStatusContainerStatusesTerminatedStartedAt struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusContainerStatusesTerminatedStartedAt) In(values []*timestamppb.Timestamp) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Status().ContainerStatuses().Terminated().StartedAt().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusContainerStatusesTerminatedStartedAt) NotIn(values []*timestamppb.Timestamp) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Status().ContainerStatuses().Terminated().StartedAt().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusContainerStatusesTerminatedStartedAt) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPodFieldPathBuilder().Status().ContainerStatuses().Terminated().StartedAt().FieldPath(),
	})
}

func (b *filterCndBuilderStatusContainerStatusesTerminatedStartedAt) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPodFieldPathBuilder().Status().ContainerStatuses().Terminated().StartedAt().FieldPath(),
	})
}

func (b *filterCndBuilderStatusContainerStatusesTerminatedStartedAt) compare(op gotenfilter.CompareOperator, value *timestamppb.Timestamp) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:           op,
		Pod_FieldPathValue: NewPodFieldPathBuilder().Status().ContainerStatuses().Terminated().StartedAt().WithValue(value),
	})
}

type filterCndBuilderStatusContainerStatusesTerminatedFinishedAt struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusContainerStatusesTerminatedFinishedAt) In(values []*timestamppb.Timestamp) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Status().ContainerStatuses().Terminated().FinishedAt().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusContainerStatusesTerminatedFinishedAt) NotIn(values []*timestamppb.Timestamp) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Status().ContainerStatuses().Terminated().FinishedAt().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusContainerStatusesTerminatedFinishedAt) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPodFieldPathBuilder().Status().ContainerStatuses().Terminated().FinishedAt().FieldPath(),
	})
}

func (b *filterCndBuilderStatusContainerStatusesTerminatedFinishedAt) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPodFieldPathBuilder().Status().ContainerStatuses().Terminated().FinishedAt().FieldPath(),
	})
}

func (b *filterCndBuilderStatusContainerStatusesTerminatedFinishedAt) compare(op gotenfilter.CompareOperator, value *timestamppb.Timestamp) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:           op,
		Pod_FieldPathValue: NewPodFieldPathBuilder().Status().ContainerStatuses().Terminated().FinishedAt().WithValue(value),
	})
}

type filterCndBuilderStatusContainerStatusesTerminatedContainerId struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusContainerStatusesTerminatedContainerId) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Status().ContainerStatuses().Terminated().ContainerId().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusContainerStatusesTerminatedContainerId) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Status().ContainerStatuses().Terminated().ContainerId().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusContainerStatusesTerminatedContainerId) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPodFieldPathBuilder().Status().ContainerStatuses().Terminated().ContainerId().FieldPath(),
	})
}

func (b *filterCndBuilderStatusContainerStatusesTerminatedContainerId) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPodFieldPathBuilder().Status().ContainerStatuses().Terminated().ContainerId().FieldPath(),
	})
}

func (b *filterCndBuilderStatusContainerStatusesTerminatedContainerId) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:           op,
		Pod_FieldPathValue: NewPodFieldPathBuilder().Status().ContainerStatuses().Terminated().ContainerId().WithValue(value),
	})
}

type filterCndBuilderStatusError struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusError) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Status().Error().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusError) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Pod_FieldPathArrayOfValues: NewPodFieldPathBuilder().Status().Error().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusError) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewPodFieldPathBuilder().Status().Error().FieldPath(),
	})
}

func (b *filterCndBuilderStatusError) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewPodFieldPathBuilder().Status().Error().FieldPath(),
	})
}

func (b *filterCndBuilderStatusError) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:           op,
		Pod_FieldPathValue: NewPodFieldPathBuilder().Status().Error().WithValue(value),
	})
}