github.com/cloudwan/edgelq-sdk@v1.15.4/devices/resources/v1/device/device.pb.filterbuilder.go

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

package device

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

// proto imports
import (
	api "github.com/cloudwan/edgelq-sdk/common/api"
	project "github.com/cloudwan/edgelq-sdk/devices/resources/v1/project"
	iam_attestation_domain "github.com/cloudwan/edgelq-sdk/iam/resources/v1/attestation_domain"
	iam_iam_common "github.com/cloudwan/edgelq-sdk/iam/resources/v1/common"
	iam_organization "github.com/cloudwan/edgelq-sdk/iam/resources/v1/organization"
	iam_project "github.com/cloudwan/edgelq-sdk/iam/resources/v1/project"
	iam_service_account "github.com/cloudwan/edgelq-sdk/iam/resources/v1/service_account"
	logging_bucket "github.com/cloudwan/edgelq-sdk/logging/resources/v1/bucket"
	logging_common "github.com/cloudwan/edgelq-sdk/logging/resources/v1/common"
	logging_log_descriptor "github.com/cloudwan/edgelq-sdk/logging/resources/v1/log_descriptor"
	monitoring_bucket "github.com/cloudwan/edgelq-sdk/monitoring/resources/v4/bucket"
	monitoring_project "github.com/cloudwan/edgelq-sdk/monitoring/resources/v4/project"
	meta_common "github.com/cloudwan/goten-sdk/meta-service/resources/v1/common"
	meta_service "github.com/cloudwan/goten-sdk/meta-service/resources/v1/service"
	meta "github.com/cloudwan/goten-sdk/types/meta"
	multi_region_policy "github.com/cloudwan/goten-sdk/types/multi_region_policy"
	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 (
	_ = &api.HealthCheckSpec{}
	_ = &project.Project{}
	_ = &iam_attestation_domain.AttestationDomain{}
	_ = &iam_iam_common.PCR{}
	_ = &iam_organization.Organization{}
	_ = &iam_project.Project{}
	_ = &iam_service_account.ServiceAccount{}
	_ = &logging_bucket.Bucket{}
	_ = &logging_common.LabelDescriptor{}
	_ = &logging_log_descriptor.LogDescriptor{}
	_ = &monitoring_bucket.Bucket{}
	_ = &monitoring_project.Project{}
	_ = &durationpb.Duration{}
	_ = &fieldmaskpb.FieldMask{}
	_ = &timestamppb.Timestamp{}
	_ = &latlng.LatLng{}
	_ = &meta_common.LabelledDomain{}
	_ = &meta_service.Service{}
	_ = &meta.Meta{}
	_ = &multi_region_policy.MultiRegionPolicy{}
)

type FilterBuilderOrCondition interface {
	_IsDeviceFilterBuilderOrCondition()
}

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

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

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

type filterCndBuilder struct {
	builder *FilterBuilder
}

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

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

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

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

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

func (b *filterCndBuilder) Status() *filterCndBuilderStatus {
	return &filterCndBuilderStatus{builder: b.builder}
}

func (b *filterCndBuilder) PublicListingSpec() *filterCndBuilderPublicListingSpec {
	return &filterCndBuilderPublicListingSpec{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{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Name().WithArrayOfValues(values),
	})
}

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

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

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

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

type filterCndBuilderMetadata struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

type filterCndBuilderDisplayName struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

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

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

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

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

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

type filterCndBuilderDescription struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

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

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

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

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

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

type filterCndBuilderSpec struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpec) In(values []*Device_Spec) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpec) NotIn(values []*Device_Spec) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().WithArrayOfValues(values),
	})
}

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

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

func (b *filterCndBuilderSpec) compare(op gotenfilter.CompareOperator, value *Device_Spec) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Spec().WithValue(value),
	})
}

func (b *filterCndBuilderSpec) ServiceAccount() *filterCndBuilderSpecServiceAccount {
	return &filterCndBuilderSpecServiceAccount{builder: b.builder}
}

func (b *filterCndBuilderSpec) LogBucket() *filterCndBuilderSpecLogBucket {
	return &filterCndBuilderSpecLogBucket{builder: b.builder}
}

func (b *filterCndBuilderSpec) MetricsBucket() *filterCndBuilderSpecMetricsBucket {
	return &filterCndBuilderSpecMetricsBucket{builder: b.builder}
}

func (b *filterCndBuilderSpec) OsVersion() *filterCndBuilderSpecOsVersion {
	return &filterCndBuilderSpecOsVersion{builder: b.builder}
}

func (b *filterCndBuilderSpec) NetplanYamlConfig() *filterCndBuilderSpecNetplanYamlConfig {
	return &filterCndBuilderSpecNetplanYamlConfig{builder: b.builder}
}

func (b *filterCndBuilderSpec) NetplanApiConfigMode() *filterCndBuilderSpecNetplanApiConfigMode {
	return &filterCndBuilderSpecNetplanApiConfigMode{builder: b.builder}
}

func (b *filterCndBuilderSpec) OsImageUrl() *filterCndBuilderSpecOsImageUrl {
	return &filterCndBuilderSpecOsImageUrl{builder: b.builder}
}

func (b *filterCndBuilderSpec) SshConfig() *filterCndBuilderSpecSshConfig {
	return &filterCndBuilderSpecSshConfig{builder: b.builder}
}

func (b *filterCndBuilderSpec) AttestationConfig() *filterCndBuilderSpecAttestationConfig {
	return &filterCndBuilderSpecAttestationConfig{builder: b.builder}
}

func (b *filterCndBuilderSpec) DisableDeviceDiscovery() *filterCndBuilderSpecDisableDeviceDiscovery {
	return &filterCndBuilderSpecDisableDeviceDiscovery{builder: b.builder}
}

func (b *filterCndBuilderSpec) LoggingConfig() *filterCndBuilderSpecLoggingConfig {
	return &filterCndBuilderSpecLoggingConfig{builder: b.builder}
}

func (b *filterCndBuilderSpec) ProxyConfig() *filterCndBuilderSpecProxyConfig {
	return &filterCndBuilderSpecProxyConfig{builder: b.builder}
}

func (b *filterCndBuilderSpec) Location() *filterCndBuilderSpecLocation {
	return &filterCndBuilderSpecLocation{builder: b.builder}
}

func (b *filterCndBuilderSpec) UsbGuard() *filterCndBuilderSpecUsbGuard {
	return &filterCndBuilderSpecUsbGuard{builder: b.builder}
}

func (b *filterCndBuilderSpec) HealthChecks() *filterCndBuilderSpecHealthChecks {
	return &filterCndBuilderSpecHealthChecks{builder: b.builder}
}

func (b *filterCndBuilderSpec) DisableNetworkConfigFallback() *filterCndBuilderSpecDisableNetworkConfigFallback {
	return &filterCndBuilderSpecDisableNetworkConfigFallback{builder: b.builder}
}

type filterCndBuilderSpecServiceAccount struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecServiceAccount) In(values []*iam_service_account.Reference) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().ServiceAccount().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecServiceAccount) NotIn(values []*iam_service_account.Reference) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().ServiceAccount().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecServiceAccount) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Spec().ServiceAccount().FieldPath(),
	})
}

func (b *filterCndBuilderSpecServiceAccount) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Spec().ServiceAccount().FieldPath(),
	})
}

func (b *filterCndBuilderSpecServiceAccount) compare(op gotenfilter.CompareOperator, value *iam_service_account.Reference) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Spec().ServiceAccount().WithValue(value),
	})
}

type filterCndBuilderSpecLogBucket struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecLogBucket) In(values []*logging_bucket.Reference) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().LogBucket().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecLogBucket) NotIn(values []*logging_bucket.Reference) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().LogBucket().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecLogBucket) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Spec().LogBucket().FieldPath(),
	})
}

func (b *filterCndBuilderSpecLogBucket) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Spec().LogBucket().FieldPath(),
	})
}

func (b *filterCndBuilderSpecLogBucket) compare(op gotenfilter.CompareOperator, value *logging_bucket.Reference) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Spec().LogBucket().WithValue(value),
	})
}

type filterCndBuilderSpecMetricsBucket struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecMetricsBucket) In(values []*monitoring_bucket.Reference) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().MetricsBucket().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecMetricsBucket) NotIn(values []*monitoring_bucket.Reference) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().MetricsBucket().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecMetricsBucket) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Spec().MetricsBucket().FieldPath(),
	})
}

func (b *filterCndBuilderSpecMetricsBucket) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Spec().MetricsBucket().FieldPath(),
	})
}

func (b *filterCndBuilderSpecMetricsBucket) compare(op gotenfilter.CompareOperator, value *monitoring_bucket.Reference) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Spec().MetricsBucket().WithValue(value),
	})
}

type filterCndBuilderSpecOsVersion struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecOsVersion) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().OsVersion().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecOsVersion) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().OsVersion().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecOsVersion) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Spec().OsVersion().FieldPath(),
	})
}

func (b *filterCndBuilderSpecOsVersion) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Spec().OsVersion().FieldPath(),
	})
}

func (b *filterCndBuilderSpecOsVersion) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Spec().OsVersion().WithValue(value),
	})
}

type filterCndBuilderSpecNetplanYamlConfig struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecNetplanYamlConfig) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().NetplanYamlConfig().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecNetplanYamlConfig) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().NetplanYamlConfig().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecNetplanYamlConfig) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Spec().NetplanYamlConfig().FieldPath(),
	})
}

func (b *filterCndBuilderSpecNetplanYamlConfig) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Spec().NetplanYamlConfig().FieldPath(),
	})
}

func (b *filterCndBuilderSpecNetplanYamlConfig) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Spec().NetplanYamlConfig().WithValue(value),
	})
}

type filterCndBuilderSpecNetplanApiConfigMode struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderSpecNetplanApiConfigMode) Eq(value Device_Spec_NetworkConfigMode) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderSpecNetplanApiConfigMode) Neq(value Device_Spec_NetworkConfigMode) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderSpecNetplanApiConfigMode) Gt(value Device_Spec_NetworkConfigMode) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderSpecNetplanApiConfigMode) Gte(value Device_Spec_NetworkConfigMode) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderSpecNetplanApiConfigMode) Lt(value Device_Spec_NetworkConfigMode) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderSpecNetplanApiConfigMode) Lte(value Device_Spec_NetworkConfigMode) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderSpecNetplanApiConfigMode) In(values []Device_Spec_NetworkConfigMode) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().NetplanApiConfigMode().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecNetplanApiConfigMode) NotIn(values []Device_Spec_NetworkConfigMode) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().NetplanApiConfigMode().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecNetplanApiConfigMode) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Spec().NetplanApiConfigMode().FieldPath(),
	})
}

func (b *filterCndBuilderSpecNetplanApiConfigMode) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Spec().NetplanApiConfigMode().FieldPath(),
	})
}

func (b *filterCndBuilderSpecNetplanApiConfigMode) compare(op gotenfilter.CompareOperator, value Device_Spec_NetworkConfigMode) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Spec().NetplanApiConfigMode().WithValue(value),
	})
}

type filterCndBuilderSpecOsImageUrl struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecOsImageUrl) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().OsImageUrl().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecOsImageUrl) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().OsImageUrl().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecOsImageUrl) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Spec().OsImageUrl().FieldPath(),
	})
}

func (b *filterCndBuilderSpecOsImageUrl) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Spec().OsImageUrl().FieldPath(),
	})
}

func (b *filterCndBuilderSpecOsImageUrl) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Spec().OsImageUrl().WithValue(value),
	})
}

type filterCndBuilderSpecSshConfig struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderSpecSshConfig) Eq(value *Device_Spec_SSHConfig) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderSpecSshConfig) Neq(value *Device_Spec_SSHConfig) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderSpecSshConfig) Gt(value *Device_Spec_SSHConfig) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderSpecSshConfig) Gte(value *Device_Spec_SSHConfig) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderSpecSshConfig) Lt(value *Device_Spec_SSHConfig) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderSpecSshConfig) Lte(value *Device_Spec_SSHConfig) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderSpecSshConfig) In(values []*Device_Spec_SSHConfig) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().SshConfig().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecSshConfig) NotIn(values []*Device_Spec_SSHConfig) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().SshConfig().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecSshConfig) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Spec().SshConfig().FieldPath(),
	})
}

func (b *filterCndBuilderSpecSshConfig) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Spec().SshConfig().FieldPath(),
	})
}

func (b *filterCndBuilderSpecSshConfig) compare(op gotenfilter.CompareOperator, value *Device_Spec_SSHConfig) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Spec().SshConfig().WithValue(value),
	})
}

func (b *filterCndBuilderSpecSshConfig) DisableSshServer() *filterCndBuilderSpecSshConfigDisableSshServer {
	return &filterCndBuilderSpecSshConfigDisableSshServer{builder: b.builder}
}

func (b *filterCndBuilderSpecSshConfig) DisableSshPassword() *filterCndBuilderSpecSshConfigDisableSshPassword {
	return &filterCndBuilderSpecSshConfigDisableSshPassword{builder: b.builder}
}

func (b *filterCndBuilderSpecSshConfig) SshAuthorized() *filterCndBuilderSpecSshConfigSshAuthorized {
	return &filterCndBuilderSpecSshConfigSshAuthorized{builder: b.builder}
}

func (b *filterCndBuilderSpecSshConfig) IpAllowList() *filterCndBuilderSpecSshConfigIpAllowList {
	return &filterCndBuilderSpecSshConfigIpAllowList{builder: b.builder}
}

func (b *filterCndBuilderSpecSshConfig) IpDenyList() *filterCndBuilderSpecSshConfigIpDenyList {
	return &filterCndBuilderSpecSshConfigIpDenyList{builder: b.builder}
}

func (b *filterCndBuilderSpecSshConfig) RejectPeriod() *filterCndBuilderSpecSshConfigRejectPeriod {
	return &filterCndBuilderSpecSshConfigRejectPeriod{builder: b.builder}
}

func (b *filterCndBuilderSpecSshConfig) DisableSshAuthkey() *filterCndBuilderSpecSshConfigDisableSshAuthkey {
	return &filterCndBuilderSpecSshConfigDisableSshAuthkey{builder: b.builder}
}

type filterCndBuilderSpecSshConfigDisableSshServer struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecSshConfigDisableSshServer) In(values []bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().SshConfig().DisableSshServer().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecSshConfigDisableSshServer) NotIn(values []bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().SshConfig().DisableSshServer().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecSshConfigDisableSshServer) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Spec().SshConfig().DisableSshServer().FieldPath(),
	})
}

func (b *filterCndBuilderSpecSshConfigDisableSshServer) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Spec().SshConfig().DisableSshServer().FieldPath(),
	})
}

func (b *filterCndBuilderSpecSshConfigDisableSshServer) compare(op gotenfilter.CompareOperator, value bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Spec().SshConfig().DisableSshServer().WithValue(value),
	})
}

type filterCndBuilderSpecSshConfigDisableSshPassword struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecSshConfigDisableSshPassword) In(values []bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().SshConfig().DisableSshPassword().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecSshConfigDisableSshPassword) NotIn(values []bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().SshConfig().DisableSshPassword().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecSshConfigDisableSshPassword) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Spec().SshConfig().DisableSshPassword().FieldPath(),
	})
}

func (b *filterCndBuilderSpecSshConfigDisableSshPassword) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Spec().SshConfig().DisableSshPassword().FieldPath(),
	})
}

func (b *filterCndBuilderSpecSshConfigDisableSshPassword) compare(op gotenfilter.CompareOperator, value bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Spec().SshConfig().DisableSshPassword().WithValue(value),
	})
}

type filterCndBuilderSpecSshConfigSshAuthorized struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecSshConfigSshAuthorized) In(values [][]*Device_Spec_SSHConfig_AuthKey) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().SshConfig().SshAuthorized().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecSshConfigSshAuthorized) NotIn(values [][]*Device_Spec_SSHConfig_AuthKey) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().SshConfig().SshAuthorized().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecSshConfigSshAuthorized) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Spec().SshConfig().SshAuthorized().FieldPath(),
	})
}

func (b *filterCndBuilderSpecSshConfigSshAuthorized) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Spec().SshConfig().SshAuthorized().FieldPath(),
	})
}

func (b *filterCndBuilderSpecSshConfigSshAuthorized) Contains(value *Device_Spec_SSHConfig_AuthKey) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewDeviceFieldPathBuilder().Spec().SshConfig().SshAuthorized().FieldPath(),
		Value:     NewDeviceFieldPathBuilder().Spec().SshConfig().SshAuthorized().WithItemValue(value),
	})
}

func (b *filterCndBuilderSpecSshConfigSshAuthorized) ContainsAnyOf(values []*Device_Spec_SSHConfig_AuthKey) *FilterBuilder {
	pathSelector := NewDeviceFieldPathBuilder().Spec().SshConfig().SshAuthorized()
	itemValues := make([]Device_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewDeviceFieldPathBuilder().Spec().SshConfig().SshAuthorized().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderSpecSshConfigSshAuthorized) ContainsAll(values []*Device_Spec_SSHConfig_AuthKey) *FilterBuilder {
	pathSelector := NewDeviceFieldPathBuilder().Spec().SshConfig().SshAuthorized()
	itemValues := make([]Device_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewDeviceFieldPathBuilder().Spec().SshConfig().SshAuthorized().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderSpecSshConfigSshAuthorized) compare(op gotenfilter.CompareOperator, value []*Device_Spec_SSHConfig_AuthKey) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Spec().SshConfig().SshAuthorized().WithValue(value),
	})
}

func (b *filterCndBuilderSpecSshConfigSshAuthorized) SshaKey() *filterCndBuilderSpecSshConfigSshAuthorizedSshaKey {
	return &filterCndBuilderSpecSshConfigSshAuthorizedSshaKey{builder: b.builder}
}

func (b *filterCndBuilderSpecSshConfigSshAuthorized) CertAuthority() *filterCndBuilderSpecSshConfigSshAuthorizedCertAuthority {
	return &filterCndBuilderSpecSshConfigSshAuthorizedCertAuthority{builder: b.builder}
}

func (b *filterCndBuilderSpecSshConfigSshAuthorized) Command() *filterCndBuilderSpecSshConfigSshAuthorizedCommand {
	return &filterCndBuilderSpecSshConfigSshAuthorizedCommand{builder: b.builder}
}

func (b *filterCndBuilderSpecSshConfigSshAuthorized) Environment() *filterCndBuilderSpecSshConfigSshAuthorizedEnvironment {
	return &filterCndBuilderSpecSshConfigSshAuthorizedEnvironment{builder: b.builder}
}

func (b *filterCndBuilderSpecSshConfigSshAuthorized) From() *filterCndBuilderSpecSshConfigSshAuthorizedFrom {
	return &filterCndBuilderSpecSshConfigSshAuthorizedFrom{builder: b.builder}
}

func (b *filterCndBuilderSpecSshConfigSshAuthorized) NoAgentForwarding() *filterCndBuilderSpecSshConfigSshAuthorizedNoAgentForwarding {
	return &filterCndBuilderSpecSshConfigSshAuthorizedNoAgentForwarding{builder: b.builder}
}

func (b *filterCndBuilderSpecSshConfigSshAuthorized) NoPortForwarding() *filterCndBuilderSpecSshConfigSshAuthorizedNoPortForwarding {
	return &filterCndBuilderSpecSshConfigSshAuthorizedNoPortForwarding{builder: b.builder}
}

func (b *filterCndBuilderSpecSshConfigSshAuthorized) NoPty() *filterCndBuilderSpecSshConfigSshAuthorizedNoPty {
	return &filterCndBuilderSpecSshConfigSshAuthorizedNoPty{builder: b.builder}
}

func (b *filterCndBuilderSpecSshConfigSshAuthorized) NoUserRc() *filterCndBuilderSpecSshConfigSshAuthorizedNoUserRc {
	return &filterCndBuilderSpecSshConfigSshAuthorizedNoUserRc{builder: b.builder}
}

func (b *filterCndBuilderSpecSshConfigSshAuthorized) NoX11Forwarding() *filterCndBuilderSpecSshConfigSshAuthorizedNoX11Forwarding {
	return &filterCndBuilderSpecSshConfigSshAuthorizedNoX11Forwarding{builder: b.builder}
}

func (b *filterCndBuilderSpecSshConfigSshAuthorized) Permitopen() *filterCndBuilderSpecSshConfigSshAuthorizedPermitopen {
	return &filterCndBuilderSpecSshConfigSshAuthorizedPermitopen{builder: b.builder}
}

func (b *filterCndBuilderSpecSshConfigSshAuthorized) Principals() *filterCndBuilderSpecSshConfigSshAuthorizedPrincipals {
	return &filterCndBuilderSpecSshConfigSshAuthorizedPrincipals{builder: b.builder}
}

func (b *filterCndBuilderSpecSshConfigSshAuthorized) Tunnel() *filterCndBuilderSpecSshConfigSshAuthorizedTunnel {
	return &filterCndBuilderSpecSshConfigSshAuthorizedTunnel{builder: b.builder}
}

func (b *filterCndBuilderSpecSshConfigSshAuthorized) Restrict() *filterCndBuilderSpecSshConfigSshAuthorizedRestrict {
	return &filterCndBuilderSpecSshConfigSshAuthorizedRestrict{builder: b.builder}
}

type filterCndBuilderSpecSshConfigSshAuthorizedSshaKey struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecSshConfigSshAuthorizedSshaKey) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().SshConfig().SshAuthorized().SshaKey().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecSshConfigSshAuthorizedSshaKey) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().SshConfig().SshAuthorized().SshaKey().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecSshConfigSshAuthorizedSshaKey) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Spec().SshConfig().SshAuthorized().SshaKey().FieldPath(),
	})
}

func (b *filterCndBuilderSpecSshConfigSshAuthorizedSshaKey) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Spec().SshConfig().SshAuthorized().SshaKey().FieldPath(),
	})
}

func (b *filterCndBuilderSpecSshConfigSshAuthorizedSshaKey) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Spec().SshConfig().SshAuthorized().SshaKey().WithValue(value),
	})
}

type filterCndBuilderSpecSshConfigSshAuthorizedCertAuthority struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecSshConfigSshAuthorizedCertAuthority) In(values []bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().SshConfig().SshAuthorized().CertAuthority().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecSshConfigSshAuthorizedCertAuthority) NotIn(values []bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().SshConfig().SshAuthorized().CertAuthority().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecSshConfigSshAuthorizedCertAuthority) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Spec().SshConfig().SshAuthorized().CertAuthority().FieldPath(),
	})
}

func (b *filterCndBuilderSpecSshConfigSshAuthorizedCertAuthority) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Spec().SshConfig().SshAuthorized().CertAuthority().FieldPath(),
	})
}

func (b *filterCndBuilderSpecSshConfigSshAuthorizedCertAuthority) compare(op gotenfilter.CompareOperator, value bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Spec().SshConfig().SshAuthorized().CertAuthority().WithValue(value),
	})
}

type filterCndBuilderSpecSshConfigSshAuthorizedCommand struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecSshConfigSshAuthorizedCommand) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().SshConfig().SshAuthorized().Command().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecSshConfigSshAuthorizedCommand) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().SshConfig().SshAuthorized().Command().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecSshConfigSshAuthorizedCommand) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Spec().SshConfig().SshAuthorized().Command().FieldPath(),
	})
}

func (b *filterCndBuilderSpecSshConfigSshAuthorizedCommand) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Spec().SshConfig().SshAuthorized().Command().FieldPath(),
	})
}

func (b *filterCndBuilderSpecSshConfigSshAuthorizedCommand) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Spec().SshConfig().SshAuthorized().Command().WithValue(value),
	})
}

type filterCndBuilderSpecSshConfigSshAuthorizedEnvironment struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecSshConfigSshAuthorizedEnvironment) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().SshConfig().SshAuthorized().Environment().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecSshConfigSshAuthorizedEnvironment) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().SshConfig().SshAuthorized().Environment().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecSshConfigSshAuthorizedEnvironment) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Spec().SshConfig().SshAuthorized().Environment().FieldPath(),
	})
}

func (b *filterCndBuilderSpecSshConfigSshAuthorizedEnvironment) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Spec().SshConfig().SshAuthorized().Environment().FieldPath(),
	})
}

func (b *filterCndBuilderSpecSshConfigSshAuthorizedEnvironment) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Spec().SshConfig().SshAuthorized().Environment().WithValue(value),
	})
}

type filterCndBuilderSpecSshConfigSshAuthorizedFrom struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecSshConfigSshAuthorizedFrom) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().SshConfig().SshAuthorized().From().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecSshConfigSshAuthorizedFrom) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().SshConfig().SshAuthorized().From().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecSshConfigSshAuthorizedFrom) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Spec().SshConfig().SshAuthorized().From().FieldPath(),
	})
}

func (b *filterCndBuilderSpecSshConfigSshAuthorizedFrom) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Spec().SshConfig().SshAuthorized().From().FieldPath(),
	})
}

func (b *filterCndBuilderSpecSshConfigSshAuthorizedFrom) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Spec().SshConfig().SshAuthorized().From().WithValue(value),
	})
}

type filterCndBuilderSpecSshConfigSshAuthorizedNoAgentForwarding struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecSshConfigSshAuthorizedNoAgentForwarding) In(values []bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().SshConfig().SshAuthorized().NoAgentForwarding().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecSshConfigSshAuthorizedNoAgentForwarding) NotIn(values []bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().SshConfig().SshAuthorized().NoAgentForwarding().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecSshConfigSshAuthorizedNoAgentForwarding) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Spec().SshConfig().SshAuthorized().NoAgentForwarding().FieldPath(),
	})
}

func (b *filterCndBuilderSpecSshConfigSshAuthorizedNoAgentForwarding) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Spec().SshConfig().SshAuthorized().NoAgentForwarding().FieldPath(),
	})
}

func (b *filterCndBuilderSpecSshConfigSshAuthorizedNoAgentForwarding) compare(op gotenfilter.CompareOperator, value bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Spec().SshConfig().SshAuthorized().NoAgentForwarding().WithValue(value),
	})
}

type filterCndBuilderSpecSshConfigSshAuthorizedNoPortForwarding struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecSshConfigSshAuthorizedNoPortForwarding) In(values []bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().SshConfig().SshAuthorized().NoPortForwarding().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecSshConfigSshAuthorizedNoPortForwarding) NotIn(values []bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().SshConfig().SshAuthorized().NoPortForwarding().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecSshConfigSshAuthorizedNoPortForwarding) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Spec().SshConfig().SshAuthorized().NoPortForwarding().FieldPath(),
	})
}

func (b *filterCndBuilderSpecSshConfigSshAuthorizedNoPortForwarding) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Spec().SshConfig().SshAuthorized().NoPortForwarding().FieldPath(),
	})
}

func (b *filterCndBuilderSpecSshConfigSshAuthorizedNoPortForwarding) compare(op gotenfilter.CompareOperator, value bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Spec().SshConfig().SshAuthorized().NoPortForwarding().WithValue(value),
	})
}

type filterCndBuilderSpecSshConfigSshAuthorizedNoPty struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecSshConfigSshAuthorizedNoPty) In(values []bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().SshConfig().SshAuthorized().NoPty().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecSshConfigSshAuthorizedNoPty) NotIn(values []bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().SshConfig().SshAuthorized().NoPty().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecSshConfigSshAuthorizedNoPty) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Spec().SshConfig().SshAuthorized().NoPty().FieldPath(),
	})
}

func (b *filterCndBuilderSpecSshConfigSshAuthorizedNoPty) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Spec().SshConfig().SshAuthorized().NoPty().FieldPath(),
	})
}

func (b *filterCndBuilderSpecSshConfigSshAuthorizedNoPty) compare(op gotenfilter.CompareOperator, value bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Spec().SshConfig().SshAuthorized().NoPty().WithValue(value),
	})
}

type filterCndBuilderSpecSshConfigSshAuthorizedNoUserRc struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecSshConfigSshAuthorizedNoUserRc) In(values []bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().SshConfig().SshAuthorized().NoUserRc().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecSshConfigSshAuthorizedNoUserRc) NotIn(values []bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().SshConfig().SshAuthorized().NoUserRc().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecSshConfigSshAuthorizedNoUserRc) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Spec().SshConfig().SshAuthorized().NoUserRc().FieldPath(),
	})
}

func (b *filterCndBuilderSpecSshConfigSshAuthorizedNoUserRc) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Spec().SshConfig().SshAuthorized().NoUserRc().FieldPath(),
	})
}

func (b *filterCndBuilderSpecSshConfigSshAuthorizedNoUserRc) compare(op gotenfilter.CompareOperator, value bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Spec().SshConfig().SshAuthorized().NoUserRc().WithValue(value),
	})
}

type filterCndBuilderSpecSshConfigSshAuthorizedNoX11Forwarding struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecSshConfigSshAuthorizedNoX11Forwarding) In(values []bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().SshConfig().SshAuthorized().NoX11Forwarding().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecSshConfigSshAuthorizedNoX11Forwarding) NotIn(values []bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().SshConfig().SshAuthorized().NoX11Forwarding().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecSshConfigSshAuthorizedNoX11Forwarding) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Spec().SshConfig().SshAuthorized().NoX11Forwarding().FieldPath(),
	})
}

func (b *filterCndBuilderSpecSshConfigSshAuthorizedNoX11Forwarding) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Spec().SshConfig().SshAuthorized().NoX11Forwarding().FieldPath(),
	})
}

func (b *filterCndBuilderSpecSshConfigSshAuthorizedNoX11Forwarding) compare(op gotenfilter.CompareOperator, value bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Spec().SshConfig().SshAuthorized().NoX11Forwarding().WithValue(value),
	})
}

type filterCndBuilderSpecSshConfigSshAuthorizedPermitopen struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecSshConfigSshAuthorizedPermitopen) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().SshConfig().SshAuthorized().Permitopen().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecSshConfigSshAuthorizedPermitopen) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().SshConfig().SshAuthorized().Permitopen().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecSshConfigSshAuthorizedPermitopen) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Spec().SshConfig().SshAuthorized().Permitopen().FieldPath(),
	})
}

func (b *filterCndBuilderSpecSshConfigSshAuthorizedPermitopen) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Spec().SshConfig().SshAuthorized().Permitopen().FieldPath(),
	})
}

func (b *filterCndBuilderSpecSshConfigSshAuthorizedPermitopen) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Spec().SshConfig().SshAuthorized().Permitopen().WithValue(value),
	})
}

type filterCndBuilderSpecSshConfigSshAuthorizedPrincipals struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecSshConfigSshAuthorizedPrincipals) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().SshConfig().SshAuthorized().Principals().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecSshConfigSshAuthorizedPrincipals) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().SshConfig().SshAuthorized().Principals().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecSshConfigSshAuthorizedPrincipals) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Spec().SshConfig().SshAuthorized().Principals().FieldPath(),
	})
}

func (b *filterCndBuilderSpecSshConfigSshAuthorizedPrincipals) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Spec().SshConfig().SshAuthorized().Principals().FieldPath(),
	})
}

func (b *filterCndBuilderSpecSshConfigSshAuthorizedPrincipals) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Spec().SshConfig().SshAuthorized().Principals().WithValue(value),
	})
}

type filterCndBuilderSpecSshConfigSshAuthorizedTunnel struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecSshConfigSshAuthorizedTunnel) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().SshConfig().SshAuthorized().Tunnel().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecSshConfigSshAuthorizedTunnel) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().SshConfig().SshAuthorized().Tunnel().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecSshConfigSshAuthorizedTunnel) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Spec().SshConfig().SshAuthorized().Tunnel().FieldPath(),
	})
}

func (b *filterCndBuilderSpecSshConfigSshAuthorizedTunnel) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Spec().SshConfig().SshAuthorized().Tunnel().FieldPath(),
	})
}

func (b *filterCndBuilderSpecSshConfigSshAuthorizedTunnel) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Spec().SshConfig().SshAuthorized().Tunnel().WithValue(value),
	})
}

type filterCndBuilderSpecSshConfigSshAuthorizedRestrict struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecSshConfigSshAuthorizedRestrict) In(values []bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().SshConfig().SshAuthorized().Restrict().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecSshConfigSshAuthorizedRestrict) NotIn(values []bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().SshConfig().SshAuthorized().Restrict().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecSshConfigSshAuthorizedRestrict) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Spec().SshConfig().SshAuthorized().Restrict().FieldPath(),
	})
}

func (b *filterCndBuilderSpecSshConfigSshAuthorizedRestrict) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Spec().SshConfig().SshAuthorized().Restrict().FieldPath(),
	})
}

func (b *filterCndBuilderSpecSshConfigSshAuthorizedRestrict) compare(op gotenfilter.CompareOperator, value bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Spec().SshConfig().SshAuthorized().Restrict().WithValue(value),
	})
}

type filterCndBuilderSpecSshConfigIpAllowList struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecSshConfigIpAllowList) In(values [][]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().SshConfig().IpAllowList().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecSshConfigIpAllowList) NotIn(values [][]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().SshConfig().IpAllowList().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecSshConfigIpAllowList) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Spec().SshConfig().IpAllowList().FieldPath(),
	})
}

func (b *filterCndBuilderSpecSshConfigIpAllowList) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Spec().SshConfig().IpAllowList().FieldPath(),
	})
}

func (b *filterCndBuilderSpecSshConfigIpAllowList) Contains(value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewDeviceFieldPathBuilder().Spec().SshConfig().IpAllowList().FieldPath(),
		Value:     NewDeviceFieldPathBuilder().Spec().SshConfig().IpAllowList().WithItemValue(value),
	})
}

func (b *filterCndBuilderSpecSshConfigIpAllowList) ContainsAnyOf(values []string) *FilterBuilder {
	pathSelector := NewDeviceFieldPathBuilder().Spec().SshConfig().IpAllowList()
	itemValues := make([]Device_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewDeviceFieldPathBuilder().Spec().SshConfig().IpAllowList().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderSpecSshConfigIpAllowList) ContainsAll(values []string) *FilterBuilder {
	pathSelector := NewDeviceFieldPathBuilder().Spec().SshConfig().IpAllowList()
	itemValues := make([]Device_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewDeviceFieldPathBuilder().Spec().SshConfig().IpAllowList().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderSpecSshConfigIpAllowList) compare(op gotenfilter.CompareOperator, value []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Spec().SshConfig().IpAllowList().WithValue(value),
	})
}

type filterCndBuilderSpecSshConfigIpDenyList struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecSshConfigIpDenyList) In(values [][]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().SshConfig().IpDenyList().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecSshConfigIpDenyList) NotIn(values [][]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().SshConfig().IpDenyList().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecSshConfigIpDenyList) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Spec().SshConfig().IpDenyList().FieldPath(),
	})
}

func (b *filterCndBuilderSpecSshConfigIpDenyList) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Spec().SshConfig().IpDenyList().FieldPath(),
	})
}

func (b *filterCndBuilderSpecSshConfigIpDenyList) Contains(value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewDeviceFieldPathBuilder().Spec().SshConfig().IpDenyList().FieldPath(),
		Value:     NewDeviceFieldPathBuilder().Spec().SshConfig().IpDenyList().WithItemValue(value),
	})
}

func (b *filterCndBuilderSpecSshConfigIpDenyList) ContainsAnyOf(values []string) *FilterBuilder {
	pathSelector := NewDeviceFieldPathBuilder().Spec().SshConfig().IpDenyList()
	itemValues := make([]Device_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewDeviceFieldPathBuilder().Spec().SshConfig().IpDenyList().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderSpecSshConfigIpDenyList) ContainsAll(values []string) *FilterBuilder {
	pathSelector := NewDeviceFieldPathBuilder().Spec().SshConfig().IpDenyList()
	itemValues := make([]Device_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewDeviceFieldPathBuilder().Spec().SshConfig().IpDenyList().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderSpecSshConfigIpDenyList) compare(op gotenfilter.CompareOperator, value []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Spec().SshConfig().IpDenyList().WithValue(value),
	})
}

type filterCndBuilderSpecSshConfigRejectPeriod struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecSshConfigRejectPeriod) In(values []*durationpb.Duration) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().SshConfig().RejectPeriod().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecSshConfigRejectPeriod) NotIn(values []*durationpb.Duration) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().SshConfig().RejectPeriod().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecSshConfigRejectPeriod) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Spec().SshConfig().RejectPeriod().FieldPath(),
	})
}

func (b *filterCndBuilderSpecSshConfigRejectPeriod) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Spec().SshConfig().RejectPeriod().FieldPath(),
	})
}

func (b *filterCndBuilderSpecSshConfigRejectPeriod) compare(op gotenfilter.CompareOperator, value *durationpb.Duration) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Spec().SshConfig().RejectPeriod().WithValue(value),
	})
}

type filterCndBuilderSpecSshConfigDisableSshAuthkey struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecSshConfigDisableSshAuthkey) In(values []bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().SshConfig().DisableSshAuthkey().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecSshConfigDisableSshAuthkey) NotIn(values []bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().SshConfig().DisableSshAuthkey().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecSshConfigDisableSshAuthkey) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Spec().SshConfig().DisableSshAuthkey().FieldPath(),
	})
}

func (b *filterCndBuilderSpecSshConfigDisableSshAuthkey) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Spec().SshConfig().DisableSshAuthkey().FieldPath(),
	})
}

func (b *filterCndBuilderSpecSshConfigDisableSshAuthkey) compare(op gotenfilter.CompareOperator, value bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Spec().SshConfig().DisableSshAuthkey().WithValue(value),
	})
}

type filterCndBuilderSpecAttestationConfig struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderSpecAttestationConfig) Eq(value *Device_Spec_AttestationConfig) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderSpecAttestationConfig) Neq(value *Device_Spec_AttestationConfig) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderSpecAttestationConfig) Gt(value *Device_Spec_AttestationConfig) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderSpecAttestationConfig) Gte(value *Device_Spec_AttestationConfig) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderSpecAttestationConfig) Lt(value *Device_Spec_AttestationConfig) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderSpecAttestationConfig) Lte(value *Device_Spec_AttestationConfig) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderSpecAttestationConfig) In(values []*Device_Spec_AttestationConfig) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().AttestationConfig().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecAttestationConfig) NotIn(values []*Device_Spec_AttestationConfig) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().AttestationConfig().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecAttestationConfig) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Spec().AttestationConfig().FieldPath(),
	})
}

func (b *filterCndBuilderSpecAttestationConfig) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Spec().AttestationConfig().FieldPath(),
	})
}

func (b *filterCndBuilderSpecAttestationConfig) compare(op gotenfilter.CompareOperator, value *Device_Spec_AttestationConfig) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Spec().AttestationConfig().WithValue(value),
	})
}

func (b *filterCndBuilderSpecAttestationConfig) AttestationExpected() *filterCndBuilderSpecAttestationConfigAttestationExpected {
	return &filterCndBuilderSpecAttestationConfigAttestationExpected{builder: b.builder}
}

func (b *filterCndBuilderSpecAttestationConfig) AttestationDomain() *filterCndBuilderSpecAttestationConfigAttestationDomain {
	return &filterCndBuilderSpecAttestationConfigAttestationDomain{builder: b.builder}
}

type filterCndBuilderSpecAttestationConfigAttestationExpected struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecAttestationConfigAttestationExpected) In(values []bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().AttestationConfig().AttestationExpected().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecAttestationConfigAttestationExpected) NotIn(values []bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().AttestationConfig().AttestationExpected().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecAttestationConfigAttestationExpected) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Spec().AttestationConfig().AttestationExpected().FieldPath(),
	})
}

func (b *filterCndBuilderSpecAttestationConfigAttestationExpected) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Spec().AttestationConfig().AttestationExpected().FieldPath(),
	})
}

func (b *filterCndBuilderSpecAttestationConfigAttestationExpected) compare(op gotenfilter.CompareOperator, value bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Spec().AttestationConfig().AttestationExpected().WithValue(value),
	})
}

type filterCndBuilderSpecAttestationConfigAttestationDomain struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecAttestationConfigAttestationDomain) In(values []*iam_attestation_domain.Reference) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().AttestationConfig().AttestationDomain().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecAttestationConfigAttestationDomain) NotIn(values []*iam_attestation_domain.Reference) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().AttestationConfig().AttestationDomain().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecAttestationConfigAttestationDomain) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Spec().AttestationConfig().AttestationDomain().FieldPath(),
	})
}

func (b *filterCndBuilderSpecAttestationConfigAttestationDomain) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Spec().AttestationConfig().AttestationDomain().FieldPath(),
	})
}

func (b *filterCndBuilderSpecAttestationConfigAttestationDomain) compare(op gotenfilter.CompareOperator, value *iam_attestation_domain.Reference) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Spec().AttestationConfig().AttestationDomain().WithValue(value),
	})
}

type filterCndBuilderSpecDisableDeviceDiscovery struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecDisableDeviceDiscovery) In(values []bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().DisableDeviceDiscovery().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecDisableDeviceDiscovery) NotIn(values []bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().DisableDeviceDiscovery().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecDisableDeviceDiscovery) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Spec().DisableDeviceDiscovery().FieldPath(),
	})
}

func (b *filterCndBuilderSpecDisableDeviceDiscovery) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Spec().DisableDeviceDiscovery().FieldPath(),
	})
}

func (b *filterCndBuilderSpecDisableDeviceDiscovery) compare(op gotenfilter.CompareOperator, value bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Spec().DisableDeviceDiscovery().WithValue(value),
	})
}

type filterCndBuilderSpecLoggingConfig struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderSpecLoggingConfig) Eq(value *Device_Spec_LoggingConfig) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderSpecLoggingConfig) Neq(value *Device_Spec_LoggingConfig) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderSpecLoggingConfig) Gt(value *Device_Spec_LoggingConfig) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderSpecLoggingConfig) Gte(value *Device_Spec_LoggingConfig) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderSpecLoggingConfig) Lt(value *Device_Spec_LoggingConfig) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderSpecLoggingConfig) Lte(value *Device_Spec_LoggingConfig) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderSpecLoggingConfig) In(values []*Device_Spec_LoggingConfig) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().LoggingConfig().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecLoggingConfig) NotIn(values []*Device_Spec_LoggingConfig) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().LoggingConfig().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecLoggingConfig) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Spec().LoggingConfig().FieldPath(),
	})
}

func (b *filterCndBuilderSpecLoggingConfig) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Spec().LoggingConfig().FieldPath(),
	})
}

func (b *filterCndBuilderSpecLoggingConfig) compare(op gotenfilter.CompareOperator, value *Device_Spec_LoggingConfig) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Spec().LoggingConfig().WithValue(value),
	})
}

func (b *filterCndBuilderSpecLoggingConfig) Priority() *filterCndBuilderSpecLoggingConfigPriority {
	return &filterCndBuilderSpecLoggingConfigPriority{builder: b.builder}
}

func (b *filterCndBuilderSpecLoggingConfig) Units() *filterCndBuilderSpecLoggingConfigUnits {
	return &filterCndBuilderSpecLoggingConfigUnits{builder: b.builder}
}

func (b *filterCndBuilderSpecLoggingConfig) EnableJournalExport() *filterCndBuilderSpecLoggingConfigEnableJournalExport {
	return &filterCndBuilderSpecLoggingConfigEnableJournalExport{builder: b.builder}
}

func (b *filterCndBuilderSpecLoggingConfig) ContainerLoggingConfig() *filterCndBuilderSpecLoggingConfigContainerLoggingConfig {
	return &filterCndBuilderSpecLoggingConfigContainerLoggingConfig{builder: b.builder}
}

type filterCndBuilderSpecLoggingConfigPriority struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderSpecLoggingConfigPriority) Eq(value int32) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderSpecLoggingConfigPriority) Neq(value int32) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderSpecLoggingConfigPriority) Gt(value int32) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderSpecLoggingConfigPriority) Gte(value int32) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderSpecLoggingConfigPriority) Lt(value int32) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderSpecLoggingConfigPriority) Lte(value int32) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderSpecLoggingConfigPriority) In(values []int32) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().LoggingConfig().Priority().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecLoggingConfigPriority) NotIn(values []int32) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().LoggingConfig().Priority().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecLoggingConfigPriority) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Spec().LoggingConfig().Priority().FieldPath(),
	})
}

func (b *filterCndBuilderSpecLoggingConfigPriority) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Spec().LoggingConfig().Priority().FieldPath(),
	})
}

func (b *filterCndBuilderSpecLoggingConfigPriority) compare(op gotenfilter.CompareOperator, value int32) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Spec().LoggingConfig().Priority().WithValue(value),
	})
}

type filterCndBuilderSpecLoggingConfigUnits struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecLoggingConfigUnits) In(values [][]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().LoggingConfig().Units().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecLoggingConfigUnits) NotIn(values [][]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().LoggingConfig().Units().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecLoggingConfigUnits) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Spec().LoggingConfig().Units().FieldPath(),
	})
}

func (b *filterCndBuilderSpecLoggingConfigUnits) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Spec().LoggingConfig().Units().FieldPath(),
	})
}

func (b *filterCndBuilderSpecLoggingConfigUnits) Contains(value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewDeviceFieldPathBuilder().Spec().LoggingConfig().Units().FieldPath(),
		Value:     NewDeviceFieldPathBuilder().Spec().LoggingConfig().Units().WithItemValue(value),
	})
}

func (b *filterCndBuilderSpecLoggingConfigUnits) ContainsAnyOf(values []string) *FilterBuilder {
	pathSelector := NewDeviceFieldPathBuilder().Spec().LoggingConfig().Units()
	itemValues := make([]Device_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewDeviceFieldPathBuilder().Spec().LoggingConfig().Units().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderSpecLoggingConfigUnits) ContainsAll(values []string) *FilterBuilder {
	pathSelector := NewDeviceFieldPathBuilder().Spec().LoggingConfig().Units()
	itemValues := make([]Device_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewDeviceFieldPathBuilder().Spec().LoggingConfig().Units().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderSpecLoggingConfigUnits) compare(op gotenfilter.CompareOperator, value []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Spec().LoggingConfig().Units().WithValue(value),
	})
}

type filterCndBuilderSpecLoggingConfigEnableJournalExport struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecLoggingConfigEnableJournalExport) In(values []bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().LoggingConfig().EnableJournalExport().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecLoggingConfigEnableJournalExport) NotIn(values []bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().LoggingConfig().EnableJournalExport().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecLoggingConfigEnableJournalExport) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Spec().LoggingConfig().EnableJournalExport().FieldPath(),
	})
}

func (b *filterCndBuilderSpecLoggingConfigEnableJournalExport) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Spec().LoggingConfig().EnableJournalExport().FieldPath(),
	})
}

func (b *filterCndBuilderSpecLoggingConfigEnableJournalExport) compare(op gotenfilter.CompareOperator, value bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Spec().LoggingConfig().EnableJournalExport().WithValue(value),
	})
}

type filterCndBuilderSpecLoggingConfigContainerLoggingConfig struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderSpecLoggingConfigContainerLoggingConfig) Eq(value *Device_Spec_LoggingConfig_ContainerLoggingConfig) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderSpecLoggingConfigContainerLoggingConfig) Neq(value *Device_Spec_LoggingConfig_ContainerLoggingConfig) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderSpecLoggingConfigContainerLoggingConfig) Gt(value *Device_Spec_LoggingConfig_ContainerLoggingConfig) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderSpecLoggingConfigContainerLoggingConfig) Gte(value *Device_Spec_LoggingConfig_ContainerLoggingConfig) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderSpecLoggingConfigContainerLoggingConfig) Lt(value *Device_Spec_LoggingConfig_ContainerLoggingConfig) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderSpecLoggingConfigContainerLoggingConfig) Lte(value *Device_Spec_LoggingConfig_ContainerLoggingConfig) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderSpecLoggingConfigContainerLoggingConfig) In(values []*Device_Spec_LoggingConfig_ContainerLoggingConfig) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().LoggingConfig().ContainerLoggingConfig().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecLoggingConfigContainerLoggingConfig) NotIn(values []*Device_Spec_LoggingConfig_ContainerLoggingConfig) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().LoggingConfig().ContainerLoggingConfig().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecLoggingConfigContainerLoggingConfig) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Spec().LoggingConfig().ContainerLoggingConfig().FieldPath(),
	})
}

func (b *filterCndBuilderSpecLoggingConfigContainerLoggingConfig) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Spec().LoggingConfig().ContainerLoggingConfig().FieldPath(),
	})
}

func (b *filterCndBuilderSpecLoggingConfigContainerLoggingConfig) compare(op gotenfilter.CompareOperator, value *Device_Spec_LoggingConfig_ContainerLoggingConfig) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Spec().LoggingConfig().ContainerLoggingConfig().WithValue(value),
	})
}

func (b *filterCndBuilderSpecLoggingConfigContainerLoggingConfig) EnableContainerLogExport() *filterCndBuilderSpecLoggingConfigContainerLoggingConfigEnableContainerLogExport {
	return &filterCndBuilderSpecLoggingConfigContainerLoggingConfigEnableContainerLogExport{builder: b.builder}
}

type filterCndBuilderSpecLoggingConfigContainerLoggingConfigEnableContainerLogExport struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecLoggingConfigContainerLoggingConfigEnableContainerLogExport) In(values []bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().LoggingConfig().ContainerLoggingConfig().EnableContainerLogExport().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecLoggingConfigContainerLoggingConfigEnableContainerLogExport) NotIn(values []bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().LoggingConfig().ContainerLoggingConfig().EnableContainerLogExport().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecLoggingConfigContainerLoggingConfigEnableContainerLogExport) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Spec().LoggingConfig().ContainerLoggingConfig().EnableContainerLogExport().FieldPath(),
	})
}

func (b *filterCndBuilderSpecLoggingConfigContainerLoggingConfigEnableContainerLogExport) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Spec().LoggingConfig().ContainerLoggingConfig().EnableContainerLogExport().FieldPath(),
	})
}

func (b *filterCndBuilderSpecLoggingConfigContainerLoggingConfigEnableContainerLogExport) compare(op gotenfilter.CompareOperator, value bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Spec().LoggingConfig().ContainerLoggingConfig().EnableContainerLogExport().WithValue(value),
	})
}

type filterCndBuilderSpecProxyConfig struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderSpecProxyConfig) Eq(value *Device_Spec_ProxyConfig) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderSpecProxyConfig) Neq(value *Device_Spec_ProxyConfig) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderSpecProxyConfig) Gt(value *Device_Spec_ProxyConfig) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderSpecProxyConfig) Gte(value *Device_Spec_ProxyConfig) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderSpecProxyConfig) Lt(value *Device_Spec_ProxyConfig) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderSpecProxyConfig) Lte(value *Device_Spec_ProxyConfig) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderSpecProxyConfig) In(values []*Device_Spec_ProxyConfig) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().ProxyConfig().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecProxyConfig) NotIn(values []*Device_Spec_ProxyConfig) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().ProxyConfig().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecProxyConfig) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Spec().ProxyConfig().FieldPath(),
	})
}

func (b *filterCndBuilderSpecProxyConfig) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Spec().ProxyConfig().FieldPath(),
	})
}

func (b *filterCndBuilderSpecProxyConfig) compare(op gotenfilter.CompareOperator, value *Device_Spec_ProxyConfig) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Spec().ProxyConfig().WithValue(value),
	})
}

func (b *filterCndBuilderSpecProxyConfig) HttpProxy() *filterCndBuilderSpecProxyConfigHttpProxy {
	return &filterCndBuilderSpecProxyConfigHttpProxy{builder: b.builder}
}

func (b *filterCndBuilderSpecProxyConfig) HttpsProxy() *filterCndBuilderSpecProxyConfigHttpsProxy {
	return &filterCndBuilderSpecProxyConfigHttpsProxy{builder: b.builder}
}

func (b *filterCndBuilderSpecProxyConfig) NoProxy() *filterCndBuilderSpecProxyConfigNoProxy {
	return &filterCndBuilderSpecProxyConfigNoProxy{builder: b.builder}
}

func (b *filterCndBuilderSpecProxyConfig) ProxyInterfaces() *filterCndBuilderSpecProxyConfigProxyInterfaces {
	return &filterCndBuilderSpecProxyConfigProxyInterfaces{builder: b.builder}
}

type filterCndBuilderSpecProxyConfigHttpProxy struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecProxyConfigHttpProxy) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().ProxyConfig().HttpProxy().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecProxyConfigHttpProxy) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().ProxyConfig().HttpProxy().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecProxyConfigHttpProxy) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Spec().ProxyConfig().HttpProxy().FieldPath(),
	})
}

func (b *filterCndBuilderSpecProxyConfigHttpProxy) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Spec().ProxyConfig().HttpProxy().FieldPath(),
	})
}

func (b *filterCndBuilderSpecProxyConfigHttpProxy) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Spec().ProxyConfig().HttpProxy().WithValue(value),
	})
}

type filterCndBuilderSpecProxyConfigHttpsProxy struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecProxyConfigHttpsProxy) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().ProxyConfig().HttpsProxy().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecProxyConfigHttpsProxy) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().ProxyConfig().HttpsProxy().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecProxyConfigHttpsProxy) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Spec().ProxyConfig().HttpsProxy().FieldPath(),
	})
}

func (b *filterCndBuilderSpecProxyConfigHttpsProxy) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Spec().ProxyConfig().HttpsProxy().FieldPath(),
	})
}

func (b *filterCndBuilderSpecProxyConfigHttpsProxy) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Spec().ProxyConfig().HttpsProxy().WithValue(value),
	})
}

type filterCndBuilderSpecProxyConfigNoProxy struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecProxyConfigNoProxy) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().ProxyConfig().NoProxy().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecProxyConfigNoProxy) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().ProxyConfig().NoProxy().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecProxyConfigNoProxy) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Spec().ProxyConfig().NoProxy().FieldPath(),
	})
}

func (b *filterCndBuilderSpecProxyConfigNoProxy) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Spec().ProxyConfig().NoProxy().FieldPath(),
	})
}

func (b *filterCndBuilderSpecProxyConfigNoProxy) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Spec().ProxyConfig().NoProxy().WithValue(value),
	})
}

type filterCndBuilderSpecProxyConfigProxyInterfaces struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecProxyConfigProxyInterfaces) In(values [][]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().ProxyConfig().ProxyInterfaces().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecProxyConfigProxyInterfaces) NotIn(values [][]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().ProxyConfig().ProxyInterfaces().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecProxyConfigProxyInterfaces) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Spec().ProxyConfig().ProxyInterfaces().FieldPath(),
	})
}

func (b *filterCndBuilderSpecProxyConfigProxyInterfaces) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Spec().ProxyConfig().ProxyInterfaces().FieldPath(),
	})
}

func (b *filterCndBuilderSpecProxyConfigProxyInterfaces) Contains(value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewDeviceFieldPathBuilder().Spec().ProxyConfig().ProxyInterfaces().FieldPath(),
		Value:     NewDeviceFieldPathBuilder().Spec().ProxyConfig().ProxyInterfaces().WithItemValue(value),
	})
}

func (b *filterCndBuilderSpecProxyConfigProxyInterfaces) ContainsAnyOf(values []string) *FilterBuilder {
	pathSelector := NewDeviceFieldPathBuilder().Spec().ProxyConfig().ProxyInterfaces()
	itemValues := make([]Device_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewDeviceFieldPathBuilder().Spec().ProxyConfig().ProxyInterfaces().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderSpecProxyConfigProxyInterfaces) ContainsAll(values []string) *FilterBuilder {
	pathSelector := NewDeviceFieldPathBuilder().Spec().ProxyConfig().ProxyInterfaces()
	itemValues := make([]Device_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewDeviceFieldPathBuilder().Spec().ProxyConfig().ProxyInterfaces().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderSpecProxyConfigProxyInterfaces) compare(op gotenfilter.CompareOperator, value []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Spec().ProxyConfig().ProxyInterfaces().WithValue(value),
	})
}

type filterCndBuilderSpecLocation struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderSpecLocation) Eq(value *Device_Spec_Location) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderSpecLocation) Neq(value *Device_Spec_Location) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderSpecLocation) Gt(value *Device_Spec_Location) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderSpecLocation) Gte(value *Device_Spec_Location) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderSpecLocation) Lt(value *Device_Spec_Location) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderSpecLocation) Lte(value *Device_Spec_Location) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderSpecLocation) In(values []*Device_Spec_Location) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().Location().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecLocation) NotIn(values []*Device_Spec_Location) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().Location().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecLocation) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Spec().Location().FieldPath(),
	})
}

func (b *filterCndBuilderSpecLocation) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Spec().Location().FieldPath(),
	})
}

func (b *filterCndBuilderSpecLocation) compare(op gotenfilter.CompareOperator, value *Device_Spec_Location) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Spec().Location().WithValue(value),
	})
}

func (b *filterCndBuilderSpecLocation) Address() *filterCndBuilderSpecLocationAddress {
	return &filterCndBuilderSpecLocationAddress{builder: b.builder}
}

func (b *filterCndBuilderSpecLocation) Placement() *filterCndBuilderSpecLocationPlacement {
	return &filterCndBuilderSpecLocationPlacement{builder: b.builder}
}

type filterCndBuilderSpecLocationAddress struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecLocationAddress) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().Location().Address().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecLocationAddress) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().Location().Address().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecLocationAddress) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Spec().Location().Address().FieldPath(),
	})
}

func (b *filterCndBuilderSpecLocationAddress) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Spec().Location().Address().FieldPath(),
	})
}

func (b *filterCndBuilderSpecLocationAddress) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Spec().Location().Address().WithValue(value),
	})
}

type filterCndBuilderSpecLocationPlacement struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecLocationPlacement) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().Location().Placement().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecLocationPlacement) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().Location().Placement().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecLocationPlacement) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Spec().Location().Placement().FieldPath(),
	})
}

func (b *filterCndBuilderSpecLocationPlacement) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Spec().Location().Placement().FieldPath(),
	})
}

func (b *filterCndBuilderSpecLocationPlacement) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Spec().Location().Placement().WithValue(value),
	})
}

type filterCndBuilderSpecUsbGuard struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderSpecUsbGuard) Eq(value *Device_Spec_USBGuard) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderSpecUsbGuard) Neq(value *Device_Spec_USBGuard) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderSpecUsbGuard) Gt(value *Device_Spec_USBGuard) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderSpecUsbGuard) Gte(value *Device_Spec_USBGuard) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderSpecUsbGuard) Lt(value *Device_Spec_USBGuard) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderSpecUsbGuard) Lte(value *Device_Spec_USBGuard) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderSpecUsbGuard) In(values []*Device_Spec_USBGuard) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().UsbGuard().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecUsbGuard) NotIn(values []*Device_Spec_USBGuard) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().UsbGuard().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecUsbGuard) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Spec().UsbGuard().FieldPath(),
	})
}

func (b *filterCndBuilderSpecUsbGuard) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Spec().UsbGuard().FieldPath(),
	})
}

func (b *filterCndBuilderSpecUsbGuard) compare(op gotenfilter.CompareOperator, value *Device_Spec_USBGuard) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Spec().UsbGuard().WithValue(value),
	})
}

func (b *filterCndBuilderSpecUsbGuard) Enable() *filterCndBuilderSpecUsbGuardEnable {
	return &filterCndBuilderSpecUsbGuardEnable{builder: b.builder}
}

func (b *filterCndBuilderSpecUsbGuard) WhiteList() *filterCndBuilderSpecUsbGuardWhiteList {
	return &filterCndBuilderSpecUsbGuardWhiteList{builder: b.builder}
}

type filterCndBuilderSpecUsbGuardEnable struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecUsbGuardEnable) In(values []bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().UsbGuard().Enable().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecUsbGuardEnable) NotIn(values []bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().UsbGuard().Enable().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecUsbGuardEnable) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Spec().UsbGuard().Enable().FieldPath(),
	})
}

func (b *filterCndBuilderSpecUsbGuardEnable) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Spec().UsbGuard().Enable().FieldPath(),
	})
}

func (b *filterCndBuilderSpecUsbGuardEnable) compare(op gotenfilter.CompareOperator, value bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Spec().UsbGuard().Enable().WithValue(value),
	})
}

type filterCndBuilderSpecUsbGuardWhiteList struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecUsbGuardWhiteList) In(values [][]*Device_Spec_USBGuard_WhiteList) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().UsbGuard().WhiteList().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecUsbGuardWhiteList) NotIn(values [][]*Device_Spec_USBGuard_WhiteList) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().UsbGuard().WhiteList().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecUsbGuardWhiteList) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Spec().UsbGuard().WhiteList().FieldPath(),
	})
}

func (b *filterCndBuilderSpecUsbGuardWhiteList) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Spec().UsbGuard().WhiteList().FieldPath(),
	})
}

func (b *filterCndBuilderSpecUsbGuardWhiteList) Contains(value *Device_Spec_USBGuard_WhiteList) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewDeviceFieldPathBuilder().Spec().UsbGuard().WhiteList().FieldPath(),
		Value:     NewDeviceFieldPathBuilder().Spec().UsbGuard().WhiteList().WithItemValue(value),
	})
}

func (b *filterCndBuilderSpecUsbGuardWhiteList) ContainsAnyOf(values []*Device_Spec_USBGuard_WhiteList) *FilterBuilder {
	pathSelector := NewDeviceFieldPathBuilder().Spec().UsbGuard().WhiteList()
	itemValues := make([]Device_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewDeviceFieldPathBuilder().Spec().UsbGuard().WhiteList().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderSpecUsbGuardWhiteList) ContainsAll(values []*Device_Spec_USBGuard_WhiteList) *FilterBuilder {
	pathSelector := NewDeviceFieldPathBuilder().Spec().UsbGuard().WhiteList()
	itemValues := make([]Device_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewDeviceFieldPathBuilder().Spec().UsbGuard().WhiteList().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderSpecUsbGuardWhiteList) compare(op gotenfilter.CompareOperator, value []*Device_Spec_USBGuard_WhiteList) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Spec().UsbGuard().WhiteList().WithValue(value),
	})
}

func (b *filterCndBuilderSpecUsbGuardWhiteList) DeviceName() *filterCndBuilderSpecUsbGuardWhiteListDeviceName {
	return &filterCndBuilderSpecUsbGuardWhiteListDeviceName{builder: b.builder}
}

func (b *filterCndBuilderSpecUsbGuardWhiteList) DeviceId() *filterCndBuilderSpecUsbGuardWhiteListDeviceId {
	return &filterCndBuilderSpecUsbGuardWhiteListDeviceId{builder: b.builder}
}

func (b *filterCndBuilderSpecUsbGuardWhiteList) ViaPort() *filterCndBuilderSpecUsbGuardWhiteListViaPort {
	return &filterCndBuilderSpecUsbGuardWhiteListViaPort{builder: b.builder}
}

func (b *filterCndBuilderSpecUsbGuardWhiteList) WithInterface() *filterCndBuilderSpecUsbGuardWhiteListWithInterface {
	return &filterCndBuilderSpecUsbGuardWhiteListWithInterface{builder: b.builder}
}

func (b *filterCndBuilderSpecUsbGuardWhiteList) WithConnectType() *filterCndBuilderSpecUsbGuardWhiteListWithConnectType {
	return &filterCndBuilderSpecUsbGuardWhiteListWithConnectType{builder: b.builder}
}

type filterCndBuilderSpecUsbGuardWhiteListDeviceName struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecUsbGuardWhiteListDeviceName) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().UsbGuard().WhiteList().DeviceName().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecUsbGuardWhiteListDeviceName) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().UsbGuard().WhiteList().DeviceName().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecUsbGuardWhiteListDeviceName) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Spec().UsbGuard().WhiteList().DeviceName().FieldPath(),
	})
}

func (b *filterCndBuilderSpecUsbGuardWhiteListDeviceName) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Spec().UsbGuard().WhiteList().DeviceName().FieldPath(),
	})
}

func (b *filterCndBuilderSpecUsbGuardWhiteListDeviceName) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Spec().UsbGuard().WhiteList().DeviceName().WithValue(value),
	})
}

type filterCndBuilderSpecUsbGuardWhiteListDeviceId struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecUsbGuardWhiteListDeviceId) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().UsbGuard().WhiteList().DeviceId().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecUsbGuardWhiteListDeviceId) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().UsbGuard().WhiteList().DeviceId().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecUsbGuardWhiteListDeviceId) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Spec().UsbGuard().WhiteList().DeviceId().FieldPath(),
	})
}

func (b *filterCndBuilderSpecUsbGuardWhiteListDeviceId) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Spec().UsbGuard().WhiteList().DeviceId().FieldPath(),
	})
}

func (b *filterCndBuilderSpecUsbGuardWhiteListDeviceId) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Spec().UsbGuard().WhiteList().DeviceId().WithValue(value),
	})
}

type filterCndBuilderSpecUsbGuardWhiteListViaPort struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderSpecUsbGuardWhiteListViaPort) Eq(value *Device_Spec_USBGuard_Port) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderSpecUsbGuardWhiteListViaPort) Neq(value *Device_Spec_USBGuard_Port) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderSpecUsbGuardWhiteListViaPort) Gt(value *Device_Spec_USBGuard_Port) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderSpecUsbGuardWhiteListViaPort) Gte(value *Device_Spec_USBGuard_Port) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderSpecUsbGuardWhiteListViaPort) Lt(value *Device_Spec_USBGuard_Port) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderSpecUsbGuardWhiteListViaPort) Lte(value *Device_Spec_USBGuard_Port) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderSpecUsbGuardWhiteListViaPort) In(values []*Device_Spec_USBGuard_Port) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().UsbGuard().WhiteList().ViaPort().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecUsbGuardWhiteListViaPort) NotIn(values []*Device_Spec_USBGuard_Port) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().UsbGuard().WhiteList().ViaPort().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecUsbGuardWhiteListViaPort) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Spec().UsbGuard().WhiteList().ViaPort().FieldPath(),
	})
}

func (b *filterCndBuilderSpecUsbGuardWhiteListViaPort) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Spec().UsbGuard().WhiteList().ViaPort().FieldPath(),
	})
}

func (b *filterCndBuilderSpecUsbGuardWhiteListViaPort) compare(op gotenfilter.CompareOperator, value *Device_Spec_USBGuard_Port) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Spec().UsbGuard().WhiteList().ViaPort().WithValue(value),
	})
}

func (b *filterCndBuilderSpecUsbGuardWhiteListViaPort) Equals() *filterCndBuilderSpecUsbGuardWhiteListViaPortEquals {
	return &filterCndBuilderSpecUsbGuardWhiteListViaPortEquals{builder: b.builder}
}

func (b *filterCndBuilderSpecUsbGuardWhiteListViaPort) OneOf() *filterCndBuilderSpecUsbGuardWhiteListViaPortOneOf {
	return &filterCndBuilderSpecUsbGuardWhiteListViaPortOneOf{builder: b.builder}
}

type filterCndBuilderSpecUsbGuardWhiteListViaPortEquals struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecUsbGuardWhiteListViaPortEquals) In(values [][]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().UsbGuard().WhiteList().ViaPort().Equals().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecUsbGuardWhiteListViaPortEquals) NotIn(values [][]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().UsbGuard().WhiteList().ViaPort().Equals().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecUsbGuardWhiteListViaPortEquals) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Spec().UsbGuard().WhiteList().ViaPort().Equals().FieldPath(),
	})
}

func (b *filterCndBuilderSpecUsbGuardWhiteListViaPortEquals) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Spec().UsbGuard().WhiteList().ViaPort().Equals().FieldPath(),
	})
}

func (b *filterCndBuilderSpecUsbGuardWhiteListViaPortEquals) Contains(value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewDeviceFieldPathBuilder().Spec().UsbGuard().WhiteList().ViaPort().Equals().FieldPath(),
		Value:     NewDeviceFieldPathBuilder().Spec().UsbGuard().WhiteList().ViaPort().Equals().WithItemValue(value),
	})
}

func (b *filterCndBuilderSpecUsbGuardWhiteListViaPortEquals) ContainsAnyOf(values []string) *FilterBuilder {
	pathSelector := NewDeviceFieldPathBuilder().Spec().UsbGuard().WhiteList().ViaPort().Equals()
	itemValues := make([]Device_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewDeviceFieldPathBuilder().Spec().UsbGuard().WhiteList().ViaPort().Equals().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderSpecUsbGuardWhiteListViaPortEquals) ContainsAll(values []string) *FilterBuilder {
	pathSelector := NewDeviceFieldPathBuilder().Spec().UsbGuard().WhiteList().ViaPort().Equals()
	itemValues := make([]Device_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewDeviceFieldPathBuilder().Spec().UsbGuard().WhiteList().ViaPort().Equals().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderSpecUsbGuardWhiteListViaPortEquals) compare(op gotenfilter.CompareOperator, value []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Spec().UsbGuard().WhiteList().ViaPort().Equals().WithValue(value),
	})
}

type filterCndBuilderSpecUsbGuardWhiteListViaPortOneOf struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecUsbGuardWhiteListViaPortOneOf) In(values [][]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().UsbGuard().WhiteList().ViaPort().OneOf().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecUsbGuardWhiteListViaPortOneOf) NotIn(values [][]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().UsbGuard().WhiteList().ViaPort().OneOf().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecUsbGuardWhiteListViaPortOneOf) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Spec().UsbGuard().WhiteList().ViaPort().OneOf().FieldPath(),
	})
}

func (b *filterCndBuilderSpecUsbGuardWhiteListViaPortOneOf) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Spec().UsbGuard().WhiteList().ViaPort().OneOf().FieldPath(),
	})
}

func (b *filterCndBuilderSpecUsbGuardWhiteListViaPortOneOf) Contains(value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewDeviceFieldPathBuilder().Spec().UsbGuard().WhiteList().ViaPort().OneOf().FieldPath(),
		Value:     NewDeviceFieldPathBuilder().Spec().UsbGuard().WhiteList().ViaPort().OneOf().WithItemValue(value),
	})
}

func (b *filterCndBuilderSpecUsbGuardWhiteListViaPortOneOf) ContainsAnyOf(values []string) *FilterBuilder {
	pathSelector := NewDeviceFieldPathBuilder().Spec().UsbGuard().WhiteList().ViaPort().OneOf()
	itemValues := make([]Device_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewDeviceFieldPathBuilder().Spec().UsbGuard().WhiteList().ViaPort().OneOf().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderSpecUsbGuardWhiteListViaPortOneOf) ContainsAll(values []string) *FilterBuilder {
	pathSelector := NewDeviceFieldPathBuilder().Spec().UsbGuard().WhiteList().ViaPort().OneOf()
	itemValues := make([]Device_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewDeviceFieldPathBuilder().Spec().UsbGuard().WhiteList().ViaPort().OneOf().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderSpecUsbGuardWhiteListViaPortOneOf) compare(op gotenfilter.CompareOperator, value []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Spec().UsbGuard().WhiteList().ViaPort().OneOf().WithValue(value),
	})
}

type filterCndBuilderSpecUsbGuardWhiteListWithInterface struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderSpecUsbGuardWhiteListWithInterface) Eq(value *Device_Spec_USBGuard_Interface) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderSpecUsbGuardWhiteListWithInterface) Neq(value *Device_Spec_USBGuard_Interface) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderSpecUsbGuardWhiteListWithInterface) Gt(value *Device_Spec_USBGuard_Interface) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderSpecUsbGuardWhiteListWithInterface) Gte(value *Device_Spec_USBGuard_Interface) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderSpecUsbGuardWhiteListWithInterface) Lt(value *Device_Spec_USBGuard_Interface) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderSpecUsbGuardWhiteListWithInterface) Lte(value *Device_Spec_USBGuard_Interface) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderSpecUsbGuardWhiteListWithInterface) In(values []*Device_Spec_USBGuard_Interface) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().UsbGuard().WhiteList().WithInterface().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecUsbGuardWhiteListWithInterface) NotIn(values []*Device_Spec_USBGuard_Interface) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().UsbGuard().WhiteList().WithInterface().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecUsbGuardWhiteListWithInterface) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Spec().UsbGuard().WhiteList().WithInterface().FieldPath(),
	})
}

func (b *filterCndBuilderSpecUsbGuardWhiteListWithInterface) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Spec().UsbGuard().WhiteList().WithInterface().FieldPath(),
	})
}

func (b *filterCndBuilderSpecUsbGuardWhiteListWithInterface) compare(op gotenfilter.CompareOperator, value *Device_Spec_USBGuard_Interface) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Spec().UsbGuard().WhiteList().WithInterface().WithValue(value),
	})
}

func (b *filterCndBuilderSpecUsbGuardWhiteListWithInterface) Equals() *filterCndBuilderSpecUsbGuardWhiteListWithInterfaceEquals {
	return &filterCndBuilderSpecUsbGuardWhiteListWithInterfaceEquals{builder: b.builder}
}

func (b *filterCndBuilderSpecUsbGuardWhiteListWithInterface) OneOf() *filterCndBuilderSpecUsbGuardWhiteListWithInterfaceOneOf {
	return &filterCndBuilderSpecUsbGuardWhiteListWithInterfaceOneOf{builder: b.builder}
}

type filterCndBuilderSpecUsbGuardWhiteListWithInterfaceEquals struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecUsbGuardWhiteListWithInterfaceEquals) In(values [][]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().UsbGuard().WhiteList().WithInterface().Equals().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecUsbGuardWhiteListWithInterfaceEquals) NotIn(values [][]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().UsbGuard().WhiteList().WithInterface().Equals().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecUsbGuardWhiteListWithInterfaceEquals) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Spec().UsbGuard().WhiteList().WithInterface().Equals().FieldPath(),
	})
}

func (b *filterCndBuilderSpecUsbGuardWhiteListWithInterfaceEquals) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Spec().UsbGuard().WhiteList().WithInterface().Equals().FieldPath(),
	})
}

func (b *filterCndBuilderSpecUsbGuardWhiteListWithInterfaceEquals) Contains(value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewDeviceFieldPathBuilder().Spec().UsbGuard().WhiteList().WithInterface().Equals().FieldPath(),
		Value:     NewDeviceFieldPathBuilder().Spec().UsbGuard().WhiteList().WithInterface().Equals().WithItemValue(value),
	})
}

func (b *filterCndBuilderSpecUsbGuardWhiteListWithInterfaceEquals) ContainsAnyOf(values []string) *FilterBuilder {
	pathSelector := NewDeviceFieldPathBuilder().Spec().UsbGuard().WhiteList().WithInterface().Equals()
	itemValues := make([]Device_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewDeviceFieldPathBuilder().Spec().UsbGuard().WhiteList().WithInterface().Equals().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderSpecUsbGuardWhiteListWithInterfaceEquals) ContainsAll(values []string) *FilterBuilder {
	pathSelector := NewDeviceFieldPathBuilder().Spec().UsbGuard().WhiteList().WithInterface().Equals()
	itemValues := make([]Device_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewDeviceFieldPathBuilder().Spec().UsbGuard().WhiteList().WithInterface().Equals().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderSpecUsbGuardWhiteListWithInterfaceEquals) compare(op gotenfilter.CompareOperator, value []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Spec().UsbGuard().WhiteList().WithInterface().Equals().WithValue(value),
	})
}

type filterCndBuilderSpecUsbGuardWhiteListWithInterfaceOneOf struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecUsbGuardWhiteListWithInterfaceOneOf) In(values [][]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().UsbGuard().WhiteList().WithInterface().OneOf().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecUsbGuardWhiteListWithInterfaceOneOf) NotIn(values [][]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().UsbGuard().WhiteList().WithInterface().OneOf().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecUsbGuardWhiteListWithInterfaceOneOf) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Spec().UsbGuard().WhiteList().WithInterface().OneOf().FieldPath(),
	})
}

func (b *filterCndBuilderSpecUsbGuardWhiteListWithInterfaceOneOf) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Spec().UsbGuard().WhiteList().WithInterface().OneOf().FieldPath(),
	})
}

func (b *filterCndBuilderSpecUsbGuardWhiteListWithInterfaceOneOf) Contains(value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewDeviceFieldPathBuilder().Spec().UsbGuard().WhiteList().WithInterface().OneOf().FieldPath(),
		Value:     NewDeviceFieldPathBuilder().Spec().UsbGuard().WhiteList().WithInterface().OneOf().WithItemValue(value),
	})
}

func (b *filterCndBuilderSpecUsbGuardWhiteListWithInterfaceOneOf) ContainsAnyOf(values []string) *FilterBuilder {
	pathSelector := NewDeviceFieldPathBuilder().Spec().UsbGuard().WhiteList().WithInterface().OneOf()
	itemValues := make([]Device_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewDeviceFieldPathBuilder().Spec().UsbGuard().WhiteList().WithInterface().OneOf().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderSpecUsbGuardWhiteListWithInterfaceOneOf) ContainsAll(values []string) *FilterBuilder {
	pathSelector := NewDeviceFieldPathBuilder().Spec().UsbGuard().WhiteList().WithInterface().OneOf()
	itemValues := make([]Device_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewDeviceFieldPathBuilder().Spec().UsbGuard().WhiteList().WithInterface().OneOf().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderSpecUsbGuardWhiteListWithInterfaceOneOf) compare(op gotenfilter.CompareOperator, value []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Spec().UsbGuard().WhiteList().WithInterface().OneOf().WithValue(value),
	})
}

type filterCndBuilderSpecUsbGuardWhiteListWithConnectType struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecUsbGuardWhiteListWithConnectType) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().UsbGuard().WhiteList().WithConnectType().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecUsbGuardWhiteListWithConnectType) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().UsbGuard().WhiteList().WithConnectType().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecUsbGuardWhiteListWithConnectType) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Spec().UsbGuard().WhiteList().WithConnectType().FieldPath(),
	})
}

func (b *filterCndBuilderSpecUsbGuardWhiteListWithConnectType) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Spec().UsbGuard().WhiteList().WithConnectType().FieldPath(),
	})
}

func (b *filterCndBuilderSpecUsbGuardWhiteListWithConnectType) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Spec().UsbGuard().WhiteList().WithConnectType().WithValue(value),
	})
}

type filterCndBuilderSpecHealthChecks struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderSpecHealthChecks) Eq(value []*api.HealthCheckSpec) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderSpecHealthChecks) Neq(value []*api.HealthCheckSpec) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderSpecHealthChecks) Gt(value []*api.HealthCheckSpec) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderSpecHealthChecks) Gte(value []*api.HealthCheckSpec) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderSpecHealthChecks) Lt(value []*api.HealthCheckSpec) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderSpecHealthChecks) Lte(value []*api.HealthCheckSpec) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderSpecHealthChecks) In(values [][]*api.HealthCheckSpec) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().HealthChecks().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecHealthChecks) NotIn(values [][]*api.HealthCheckSpec) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().HealthChecks().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecHealthChecks) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Spec().HealthChecks().FieldPath(),
	})
}

func (b *filterCndBuilderSpecHealthChecks) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Spec().HealthChecks().FieldPath(),
	})
}

func (b *filterCndBuilderSpecHealthChecks) Contains(value *api.HealthCheckSpec) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewDeviceFieldPathBuilder().Spec().HealthChecks().FieldPath(),
		Value:     NewDeviceFieldPathBuilder().Spec().HealthChecks().WithItemValue(value),
	})
}

func (b *filterCndBuilderSpecHealthChecks) ContainsAnyOf(values []*api.HealthCheckSpec) *FilterBuilder {
	pathSelector := NewDeviceFieldPathBuilder().Spec().HealthChecks()
	itemValues := make([]Device_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewDeviceFieldPathBuilder().Spec().HealthChecks().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderSpecHealthChecks) ContainsAll(values []*api.HealthCheckSpec) *FilterBuilder {
	pathSelector := NewDeviceFieldPathBuilder().Spec().HealthChecks()
	itemValues := make([]Device_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewDeviceFieldPathBuilder().Spec().HealthChecks().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderSpecHealthChecks) compare(op gotenfilter.CompareOperator, value []*api.HealthCheckSpec) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Spec().HealthChecks().WithValue(value),
	})
}

type filterCndBuilderSpecDisableNetworkConfigFallback struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecDisableNetworkConfigFallback) In(values []bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().DisableNetworkConfigFallback().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecDisableNetworkConfigFallback) NotIn(values []bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().DisableNetworkConfigFallback().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecDisableNetworkConfigFallback) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Spec().DisableNetworkConfigFallback().FieldPath(),
	})
}

func (b *filterCndBuilderSpecDisableNetworkConfigFallback) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Spec().DisableNetworkConfigFallback().FieldPath(),
	})
}

func (b *filterCndBuilderSpecDisableNetworkConfigFallback) compare(op gotenfilter.CompareOperator, value bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Spec().DisableNetworkConfigFallback().WithValue(value),
	})
}

type filterCndBuilderStatus struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatus) Eq(value *Device_Status) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatus) Neq(value *Device_Status) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatus) Gt(value *Device_Status) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatus) Gte(value *Device_Status) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatus) Lt(value *Device_Status) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatus) Lte(value *Device_Status) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatus) In(values []*Device_Status) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatus) NotIn(values []*Device_Status) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatus) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().FieldPath(),
	})
}

func (b *filterCndBuilderStatus) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().FieldPath(),
	})
}

func (b *filterCndBuilderStatus) compare(op gotenfilter.CompareOperator, value *Device_Status) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().WithValue(value),
	})
}

func (b *filterCndBuilderStatus) Addresses() *filterCndBuilderStatusAddresses {
	return &filterCndBuilderStatusAddresses{builder: b.builder}
}

func (b *filterCndBuilderStatus) Conditions() *filterCndBuilderStatusConditions {
	return &filterCndBuilderStatusConditions{builder: b.builder}
}

func (b *filterCndBuilderStatus) NetworkConfigState() *filterCndBuilderStatusNetworkConfigState {
	return &filterCndBuilderStatusNetworkConfigState{builder: b.builder}
}

func (b *filterCndBuilderStatus) ProxyConfigStatus() *filterCndBuilderStatusProxyConfigStatus {
	return &filterCndBuilderStatusProxyConfigStatus{builder: b.builder}
}

func (b *filterCndBuilderStatus) DeviceInfo() *filterCndBuilderStatusDeviceInfo {
	return &filterCndBuilderStatusDeviceInfo{builder: b.builder}
}

func (b *filterCndBuilderStatus) AttestationStatus() *filterCndBuilderStatusAttestationStatus {
	return &filterCndBuilderStatusAttestationStatus{builder: b.builder}
}

func (b *filterCndBuilderStatus) NormalizedAddress() *filterCndBuilderStatusNormalizedAddress {
	return &filterCndBuilderStatusNormalizedAddress{builder: b.builder}
}

func (b *filterCndBuilderStatus) ConnectionStatus() *filterCndBuilderStatusConnectionStatus {
	return &filterCndBuilderStatusConnectionStatus{builder: b.builder}
}

func (b *filterCndBuilderStatus) ConnectionStatusChangeTime() *filterCndBuilderStatusConnectionStatusChangeTime {
	return &filterCndBuilderStatusConnectionStatusChangeTime{builder: b.builder}
}

type filterCndBuilderStatusAddresses struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusAddresses) In(values [][]*Device_Status_Address) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().Addresses().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusAddresses) NotIn(values [][]*Device_Status_Address) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().Addresses().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusAddresses) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().Addresses().FieldPath(),
	})
}

func (b *filterCndBuilderStatusAddresses) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().Addresses().FieldPath(),
	})
}

func (b *filterCndBuilderStatusAddresses) Contains(value *Device_Status_Address) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewDeviceFieldPathBuilder().Status().Addresses().FieldPath(),
		Value:     NewDeviceFieldPathBuilder().Status().Addresses().WithItemValue(value),
	})
}

func (b *filterCndBuilderStatusAddresses) ContainsAnyOf(values []*Device_Status_Address) *FilterBuilder {
	pathSelector := NewDeviceFieldPathBuilder().Status().Addresses()
	itemValues := make([]Device_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewDeviceFieldPathBuilder().Status().Addresses().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderStatusAddresses) ContainsAll(values []*Device_Status_Address) *FilterBuilder {
	pathSelector := NewDeviceFieldPathBuilder().Status().Addresses()
	itemValues := make([]Device_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewDeviceFieldPathBuilder().Status().Addresses().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderStatusAddresses) compare(op gotenfilter.CompareOperator, value []*Device_Status_Address) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().Addresses().WithValue(value),
	})
}

func (b *filterCndBuilderStatusAddresses) Address() *filterCndBuilderStatusAddressesAddress {
	return &filterCndBuilderStatusAddressesAddress{builder: b.builder}
}

func (b *filterCndBuilderStatusAddresses) Type() *filterCndBuilderStatusAddressesType {
	return &filterCndBuilderStatusAddressesType{builder: b.builder}
}

type filterCndBuilderStatusAddressesAddress struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusAddressesAddress) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().Addresses().Address().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusAddressesAddress) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().Addresses().Address().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusAddressesAddress) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().Addresses().Address().FieldPath(),
	})
}

func (b *filterCndBuilderStatusAddressesAddress) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().Addresses().Address().FieldPath(),
	})
}

func (b *filterCndBuilderStatusAddressesAddress) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().Addresses().Address().WithValue(value),
	})
}

type filterCndBuilderStatusAddressesType struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusAddressesType) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().Addresses().Type().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusAddressesType) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().Addresses().Type().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusAddressesType) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().Addresses().Type().FieldPath(),
	})
}

func (b *filterCndBuilderStatusAddressesType) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().Addresses().Type().FieldPath(),
	})
}

func (b *filterCndBuilderStatusAddressesType) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().Addresses().Type().WithValue(value),
	})
}

type filterCndBuilderStatusConditions struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusConditions) In(values [][]*Device_Status_Condition) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().Conditions().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusConditions) NotIn(values [][]*Device_Status_Condition) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().Conditions().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusConditions) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().Conditions().FieldPath(),
	})
}

func (b *filterCndBuilderStatusConditions) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().Conditions().FieldPath(),
	})
}

func (b *filterCndBuilderStatusConditions) Contains(value *Device_Status_Condition) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewDeviceFieldPathBuilder().Status().Conditions().FieldPath(),
		Value:     NewDeviceFieldPathBuilder().Status().Conditions().WithItemValue(value),
	})
}

func (b *filterCndBuilderStatusConditions) ContainsAnyOf(values []*Device_Status_Condition) *FilterBuilder {
	pathSelector := NewDeviceFieldPathBuilder().Status().Conditions()
	itemValues := make([]Device_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewDeviceFieldPathBuilder().Status().Conditions().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderStatusConditions) ContainsAll(values []*Device_Status_Condition) *FilterBuilder {
	pathSelector := NewDeviceFieldPathBuilder().Status().Conditions()
	itemValues := make([]Device_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewDeviceFieldPathBuilder().Status().Conditions().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderStatusConditions) compare(op gotenfilter.CompareOperator, value []*Device_Status_Condition) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().Conditions().WithValue(value),
	})
}

func (b *filterCndBuilderStatusConditions) Message() *filterCndBuilderStatusConditionsMessage {
	return &filterCndBuilderStatusConditionsMessage{builder: b.builder}
}

func (b *filterCndBuilderStatusConditions) Reason() *filterCndBuilderStatusConditionsReason {
	return &filterCndBuilderStatusConditionsReason{builder: b.builder}
}

func (b *filterCndBuilderStatusConditions) Status() *filterCndBuilderStatusConditionsStatus {
	return &filterCndBuilderStatusConditionsStatus{builder: b.builder}
}

func (b *filterCndBuilderStatusConditions) Type() *filterCndBuilderStatusConditionsType {
	return &filterCndBuilderStatusConditionsType{builder: b.builder}
}

func (b *filterCndBuilderStatusConditions) LastHeartBeatTime() *filterCndBuilderStatusConditionsLastHeartBeatTime {
	return &filterCndBuilderStatusConditionsLastHeartBeatTime{builder: b.builder}
}

func (b *filterCndBuilderStatusConditions) LastTransitionTime() *filterCndBuilderStatusConditionsLastTransitionTime {
	return &filterCndBuilderStatusConditionsLastTransitionTime{builder: b.builder}
}

type filterCndBuilderStatusConditionsMessage struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusConditionsMessage) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().Conditions().Message().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusConditionsMessage) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().Conditions().Message().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusConditionsMessage) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().Conditions().Message().FieldPath(),
	})
}

func (b *filterCndBuilderStatusConditionsMessage) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().Conditions().Message().FieldPath(),
	})
}

func (b *filterCndBuilderStatusConditionsMessage) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().Conditions().Message().WithValue(value),
	})
}

type filterCndBuilderStatusConditionsReason struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusConditionsReason) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().Conditions().Reason().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusConditionsReason) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().Conditions().Reason().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusConditionsReason) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().Conditions().Reason().FieldPath(),
	})
}

func (b *filterCndBuilderStatusConditionsReason) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().Conditions().Reason().FieldPath(),
	})
}

func (b *filterCndBuilderStatusConditionsReason) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().Conditions().Reason().WithValue(value),
	})
}

type filterCndBuilderStatusConditionsStatus struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusConditionsStatus) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().Conditions().Status().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusConditionsStatus) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().Conditions().Status().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusConditionsStatus) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().Conditions().Status().FieldPath(),
	})
}

func (b *filterCndBuilderStatusConditionsStatus) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().Conditions().Status().FieldPath(),
	})
}

func (b *filterCndBuilderStatusConditionsStatus) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().Conditions().Status().WithValue(value),
	})
}

type filterCndBuilderStatusConditionsType struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusConditionsType) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().Conditions().Type().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusConditionsType) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().Conditions().Type().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusConditionsType) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().Conditions().Type().FieldPath(),
	})
}

func (b *filterCndBuilderStatusConditionsType) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().Conditions().Type().FieldPath(),
	})
}

func (b *filterCndBuilderStatusConditionsType) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().Conditions().Type().WithValue(value),
	})
}

type filterCndBuilderStatusConditionsLastHeartBeatTime struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusConditionsLastHeartBeatTime) In(values []*timestamppb.Timestamp) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().Conditions().LastHeartBeatTime().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusConditionsLastHeartBeatTime) NotIn(values []*timestamppb.Timestamp) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().Conditions().LastHeartBeatTime().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusConditionsLastHeartBeatTime) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().Conditions().LastHeartBeatTime().FieldPath(),
	})
}

func (b *filterCndBuilderStatusConditionsLastHeartBeatTime) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().Conditions().LastHeartBeatTime().FieldPath(),
	})
}

func (b *filterCndBuilderStatusConditionsLastHeartBeatTime) compare(op gotenfilter.CompareOperator, value *timestamppb.Timestamp) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().Conditions().LastHeartBeatTime().WithValue(value),
	})
}

type filterCndBuilderStatusConditionsLastTransitionTime struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusConditionsLastTransitionTime) In(values []*timestamppb.Timestamp) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().Conditions().LastTransitionTime().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusConditionsLastTransitionTime) NotIn(values []*timestamppb.Timestamp) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().Conditions().LastTransitionTime().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusConditionsLastTransitionTime) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().Conditions().LastTransitionTime().FieldPath(),
	})
}

func (b *filterCndBuilderStatusConditionsLastTransitionTime) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().Conditions().LastTransitionTime().FieldPath(),
	})
}

func (b *filterCndBuilderStatusConditionsLastTransitionTime) compare(op gotenfilter.CompareOperator, value *timestamppb.Timestamp) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().Conditions().LastTransitionTime().WithValue(value),
	})
}

type filterCndBuilderStatusNetworkConfigState struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusNetworkConfigState) Eq(value *Device_Status_NetworkConfigState) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusNetworkConfigState) Neq(value *Device_Status_NetworkConfigState) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusNetworkConfigState) Gt(value *Device_Status_NetworkConfigState) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusNetworkConfigState) Gte(value *Device_Status_NetworkConfigState) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusNetworkConfigState) Lt(value *Device_Status_NetworkConfigState) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusNetworkConfigState) Lte(value *Device_Status_NetworkConfigState) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusNetworkConfigState) In(values []*Device_Status_NetworkConfigState) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNetworkConfigState) NotIn(values []*Device_Status_NetworkConfigState) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNetworkConfigState) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNetworkConfigState) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNetworkConfigState) compare(op gotenfilter.CompareOperator, value *Device_Status_NetworkConfigState) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().NetworkConfigState().WithValue(value),
	})
}

func (b *filterCndBuilderStatusNetworkConfigState) ActiveNetworkConfigSource() *filterCndBuilderStatusNetworkConfigStateActiveNetworkConfigSource {
	return &filterCndBuilderStatusNetworkConfigStateActiveNetworkConfigSource{builder: b.builder}
}

func (b *filterCndBuilderStatusNetworkConfigState) DesiredNetworkConfigSource() *filterCndBuilderStatusNetworkConfigStateDesiredNetworkConfigSource {
	return &filterCndBuilderStatusNetworkConfigStateDesiredNetworkConfigSource{builder: b.builder}
}

func (b *filterCndBuilderStatusNetworkConfigState) DesiredNetworkConfigError() *filterCndBuilderStatusNetworkConfigStateDesiredNetworkConfigError {
	return &filterCndBuilderStatusNetworkConfigStateDesiredNetworkConfigError{builder: b.builder}
}

func (b *filterCndBuilderStatusNetworkConfigState) DefaultNetplanConfig() *filterCndBuilderStatusNetworkConfigStateDefaultNetplanConfig {
	return &filterCndBuilderStatusNetworkConfigStateDefaultNetplanConfig{builder: b.builder}
}

func (b *filterCndBuilderStatusNetworkConfigState) ActiveNetplanConfig() *filterCndBuilderStatusNetworkConfigStateActiveNetplanConfig {
	return &filterCndBuilderStatusNetworkConfigStateActiveNetplanConfig{builder: b.builder}
}

func (b *filterCndBuilderStatusNetworkConfigState) DesiredNetplanConfig() *filterCndBuilderStatusNetworkConfigStateDesiredNetplanConfig {
	return &filterCndBuilderStatusNetworkConfigStateDesiredNetplanConfig{builder: b.builder}
}

type filterCndBuilderStatusNetworkConfigStateActiveNetworkConfigSource struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusNetworkConfigStateActiveNetworkConfigSource) Eq(value Device_Status_NetworkConfigState_NetworkConfigSource) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusNetworkConfigStateActiveNetworkConfigSource) Neq(value Device_Status_NetworkConfigState_NetworkConfigSource) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusNetworkConfigStateActiveNetworkConfigSource) Gt(value Device_Status_NetworkConfigState_NetworkConfigSource) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusNetworkConfigStateActiveNetworkConfigSource) Gte(value Device_Status_NetworkConfigState_NetworkConfigSource) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusNetworkConfigStateActiveNetworkConfigSource) Lt(value Device_Status_NetworkConfigState_NetworkConfigSource) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusNetworkConfigStateActiveNetworkConfigSource) Lte(value Device_Status_NetworkConfigState_NetworkConfigSource) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusNetworkConfigStateActiveNetworkConfigSource) In(values []Device_Status_NetworkConfigState_NetworkConfigSource) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveNetworkConfigSource().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateActiveNetworkConfigSource) NotIn(values []Device_Status_NetworkConfigState_NetworkConfigSource) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveNetworkConfigSource().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateActiveNetworkConfigSource) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveNetworkConfigSource().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateActiveNetworkConfigSource) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveNetworkConfigSource().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateActiveNetworkConfigSource) compare(op gotenfilter.CompareOperator, value Device_Status_NetworkConfigState_NetworkConfigSource) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveNetworkConfigSource().WithValue(value),
	})
}

type filterCndBuilderStatusNetworkConfigStateDesiredNetworkConfigSource struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusNetworkConfigStateDesiredNetworkConfigSource) Eq(value Device_Status_NetworkConfigState_NetworkConfigSource) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusNetworkConfigStateDesiredNetworkConfigSource) Neq(value Device_Status_NetworkConfigState_NetworkConfigSource) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusNetworkConfigStateDesiredNetworkConfigSource) Gt(value Device_Status_NetworkConfigState_NetworkConfigSource) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusNetworkConfigStateDesiredNetworkConfigSource) Gte(value Device_Status_NetworkConfigState_NetworkConfigSource) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusNetworkConfigStateDesiredNetworkConfigSource) Lt(value Device_Status_NetworkConfigState_NetworkConfigSource) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusNetworkConfigStateDesiredNetworkConfigSource) Lte(value Device_Status_NetworkConfigState_NetworkConfigSource) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusNetworkConfigStateDesiredNetworkConfigSource) In(values []Device_Status_NetworkConfigState_NetworkConfigSource) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredNetworkConfigSource().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDesiredNetworkConfigSource) NotIn(values []Device_Status_NetworkConfigState_NetworkConfigSource) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredNetworkConfigSource().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDesiredNetworkConfigSource) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredNetworkConfigSource().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDesiredNetworkConfigSource) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredNetworkConfigSource().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDesiredNetworkConfigSource) compare(op gotenfilter.CompareOperator, value Device_Status_NetworkConfigState_NetworkConfigSource) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredNetworkConfigSource().WithValue(value),
	})
}

type filterCndBuilderStatusNetworkConfigStateDesiredNetworkConfigError struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusNetworkConfigStateDesiredNetworkConfigError) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredNetworkConfigError().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDesiredNetworkConfigError) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredNetworkConfigError().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDesiredNetworkConfigError) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredNetworkConfigError().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDesiredNetworkConfigError) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredNetworkConfigError().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDesiredNetworkConfigError) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredNetworkConfigError().WithValue(value),
	})
}

type filterCndBuilderStatusNetworkConfigStateDefaultNetplanConfig struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusNetworkConfigStateDefaultNetplanConfig) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DefaultNetplanConfig().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDefaultNetplanConfig) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DefaultNetplanConfig().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDefaultNetplanConfig) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DefaultNetplanConfig().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDefaultNetplanConfig) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DefaultNetplanConfig().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDefaultNetplanConfig) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DefaultNetplanConfig().WithValue(value),
	})
}

type filterCndBuilderStatusNetworkConfigStateActiveNetplanConfig struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusNetworkConfigStateActiveNetplanConfig) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveNetplanConfig().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateActiveNetplanConfig) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveNetplanConfig().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateActiveNetplanConfig) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveNetplanConfig().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateActiveNetplanConfig) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveNetplanConfig().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateActiveNetplanConfig) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveNetplanConfig().WithValue(value),
	})
}

type filterCndBuilderStatusNetworkConfigStateDesiredNetplanConfig struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusNetworkConfigStateDesiredNetplanConfig) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredNetplanConfig().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDesiredNetplanConfig) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredNetplanConfig().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDesiredNetplanConfig) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredNetplanConfig().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDesiredNetplanConfig) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredNetplanConfig().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDesiredNetplanConfig) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredNetplanConfig().WithValue(value),
	})
}

type filterCndBuilderStatusProxyConfigStatus struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusProxyConfigStatus) Eq(value *Device_Status_ProxyConfigStatus) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusProxyConfigStatus) Neq(value *Device_Status_ProxyConfigStatus) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusProxyConfigStatus) Gt(value *Device_Status_ProxyConfigStatus) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusProxyConfigStatus) Gte(value *Device_Status_ProxyConfigStatus) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusProxyConfigStatus) Lt(value *Device_Status_ProxyConfigStatus) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusProxyConfigStatus) Lte(value *Device_Status_ProxyConfigStatus) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusProxyConfigStatus) In(values []*Device_Status_ProxyConfigStatus) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusProxyConfigStatus) NotIn(values []*Device_Status_ProxyConfigStatus) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusProxyConfigStatus) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().FieldPath(),
	})
}

func (b *filterCndBuilderStatusProxyConfigStatus) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().FieldPath(),
	})
}

func (b *filterCndBuilderStatusProxyConfigStatus) compare(op gotenfilter.CompareOperator, value *Device_Status_ProxyConfigStatus) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().WithValue(value),
	})
}

func (b *filterCndBuilderStatusProxyConfigStatus) ActiveConfigSource() *filterCndBuilderStatusProxyConfigStatusActiveConfigSource {
	return &filterCndBuilderStatusProxyConfigStatusActiveConfigSource{builder: b.builder}
}

func (b *filterCndBuilderStatusProxyConfigStatus) DesiredConfigSource() *filterCndBuilderStatusProxyConfigStatusDesiredConfigSource {
	return &filterCndBuilderStatusProxyConfigStatusDesiredConfigSource{builder: b.builder}
}

func (b *filterCndBuilderStatusProxyConfigStatus) ProxyConfigError() *filterCndBuilderStatusProxyConfigStatusProxyConfigError {
	return &filterCndBuilderStatusProxyConfigStatusProxyConfigError{builder: b.builder}
}

func (b *filterCndBuilderStatusProxyConfigStatus) DefaultConfig() *filterCndBuilderStatusProxyConfigStatusDefaultConfig {
	return &filterCndBuilderStatusProxyConfigStatusDefaultConfig{builder: b.builder}
}

func (b *filterCndBuilderStatusProxyConfigStatus) ActiveConfig() *filterCndBuilderStatusProxyConfigStatusActiveConfig {
	return &filterCndBuilderStatusProxyConfigStatusActiveConfig{builder: b.builder}
}

func (b *filterCndBuilderStatusProxyConfigStatus) ApiConfig() *filterCndBuilderStatusProxyConfigStatusApiConfig {
	return &filterCndBuilderStatusProxyConfigStatusApiConfig{builder: b.builder}
}

type filterCndBuilderStatusProxyConfigStatusActiveConfigSource struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusProxyConfigStatusActiveConfigSource) Eq(value Device_Status_ProxyConfigStatus_ProxyConfigSource) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusProxyConfigStatusActiveConfigSource) Neq(value Device_Status_ProxyConfigStatus_ProxyConfigSource) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusProxyConfigStatusActiveConfigSource) Gt(value Device_Status_ProxyConfigStatus_ProxyConfigSource) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusProxyConfigStatusActiveConfigSource) Gte(value Device_Status_ProxyConfigStatus_ProxyConfigSource) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusProxyConfigStatusActiveConfigSource) Lt(value Device_Status_ProxyConfigStatus_ProxyConfigSource) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusProxyConfigStatusActiveConfigSource) Lte(value Device_Status_ProxyConfigStatus_ProxyConfigSource) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusProxyConfigStatusActiveConfigSource) In(values []Device_Status_ProxyConfigStatus_ProxyConfigSource) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().ActiveConfigSource().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusProxyConfigStatusActiveConfigSource) NotIn(values []Device_Status_ProxyConfigStatus_ProxyConfigSource) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().ActiveConfigSource().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusProxyConfigStatusActiveConfigSource) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().ActiveConfigSource().FieldPath(),
	})
}

func (b *filterCndBuilderStatusProxyConfigStatusActiveConfigSource) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().ActiveConfigSource().FieldPath(),
	})
}

func (b *filterCndBuilderStatusProxyConfigStatusActiveConfigSource) compare(op gotenfilter.CompareOperator, value Device_Status_ProxyConfigStatus_ProxyConfigSource) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().ActiveConfigSource().WithValue(value),
	})
}

type filterCndBuilderStatusProxyConfigStatusDesiredConfigSource struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusProxyConfigStatusDesiredConfigSource) Eq(value Device_Status_ProxyConfigStatus_ProxyConfigSource) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusProxyConfigStatusDesiredConfigSource) Neq(value Device_Status_ProxyConfigStatus_ProxyConfigSource) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusProxyConfigStatusDesiredConfigSource) Gt(value Device_Status_ProxyConfigStatus_ProxyConfigSource) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusProxyConfigStatusDesiredConfigSource) Gte(value Device_Status_ProxyConfigStatus_ProxyConfigSource) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusProxyConfigStatusDesiredConfigSource) Lt(value Device_Status_ProxyConfigStatus_ProxyConfigSource) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusProxyConfigStatusDesiredConfigSource) Lte(value Device_Status_ProxyConfigStatus_ProxyConfigSource) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusProxyConfigStatusDesiredConfigSource) In(values []Device_Status_ProxyConfigStatus_ProxyConfigSource) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().DesiredConfigSource().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusProxyConfigStatusDesiredConfigSource) NotIn(values []Device_Status_ProxyConfigStatus_ProxyConfigSource) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().DesiredConfigSource().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusProxyConfigStatusDesiredConfigSource) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().DesiredConfigSource().FieldPath(),
	})
}

func (b *filterCndBuilderStatusProxyConfigStatusDesiredConfigSource) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().DesiredConfigSource().FieldPath(),
	})
}

func (b *filterCndBuilderStatusProxyConfigStatusDesiredConfigSource) compare(op gotenfilter.CompareOperator, value Device_Status_ProxyConfigStatus_ProxyConfigSource) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().DesiredConfigSource().WithValue(value),
	})
}

type filterCndBuilderStatusProxyConfigStatusProxyConfigError struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusProxyConfigStatusProxyConfigError) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().ProxyConfigError().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusProxyConfigStatusProxyConfigError) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().ProxyConfigError().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusProxyConfigStatusProxyConfigError) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().ProxyConfigError().FieldPath(),
	})
}

func (b *filterCndBuilderStatusProxyConfigStatusProxyConfigError) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().ProxyConfigError().FieldPath(),
	})
}

func (b *filterCndBuilderStatusProxyConfigStatusProxyConfigError) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().ProxyConfigError().WithValue(value),
	})
}

type filterCndBuilderStatusProxyConfigStatusDefaultConfig struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusProxyConfigStatusDefaultConfig) Eq(value *Device_Spec_ProxyConfig) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusProxyConfigStatusDefaultConfig) Neq(value *Device_Spec_ProxyConfig) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusProxyConfigStatusDefaultConfig) Gt(value *Device_Spec_ProxyConfig) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusProxyConfigStatusDefaultConfig) Gte(value *Device_Spec_ProxyConfig) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusProxyConfigStatusDefaultConfig) Lt(value *Device_Spec_ProxyConfig) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusProxyConfigStatusDefaultConfig) Lte(value *Device_Spec_ProxyConfig) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusProxyConfigStatusDefaultConfig) In(values []*Device_Spec_ProxyConfig) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().DefaultConfig().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusProxyConfigStatusDefaultConfig) NotIn(values []*Device_Spec_ProxyConfig) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().DefaultConfig().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusProxyConfigStatusDefaultConfig) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().DefaultConfig().FieldPath(),
	})
}

func (b *filterCndBuilderStatusProxyConfigStatusDefaultConfig) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().DefaultConfig().FieldPath(),
	})
}

func (b *filterCndBuilderStatusProxyConfigStatusDefaultConfig) compare(op gotenfilter.CompareOperator, value *Device_Spec_ProxyConfig) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().DefaultConfig().WithValue(value),
	})
}

func (b *filterCndBuilderStatusProxyConfigStatusDefaultConfig) HttpProxy() *filterCndBuilderStatusProxyConfigStatusDefaultConfigHttpProxy {
	return &filterCndBuilderStatusProxyConfigStatusDefaultConfigHttpProxy{builder: b.builder}
}

func (b *filterCndBuilderStatusProxyConfigStatusDefaultConfig) HttpsProxy() *filterCndBuilderStatusProxyConfigStatusDefaultConfigHttpsProxy {
	return &filterCndBuilderStatusProxyConfigStatusDefaultConfigHttpsProxy{builder: b.builder}
}

func (b *filterCndBuilderStatusProxyConfigStatusDefaultConfig) NoProxy() *filterCndBuilderStatusProxyConfigStatusDefaultConfigNoProxy {
	return &filterCndBuilderStatusProxyConfigStatusDefaultConfigNoProxy{builder: b.builder}
}

func (b *filterCndBuilderStatusProxyConfigStatusDefaultConfig) ProxyInterfaces() *filterCndBuilderStatusProxyConfigStatusDefaultConfigProxyInterfaces {
	return &filterCndBuilderStatusProxyConfigStatusDefaultConfigProxyInterfaces{builder: b.builder}
}

type filterCndBuilderStatusProxyConfigStatusDefaultConfigHttpProxy struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusProxyConfigStatusDefaultConfigHttpProxy) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().DefaultConfig().HttpProxy().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusProxyConfigStatusDefaultConfigHttpProxy) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().DefaultConfig().HttpProxy().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusProxyConfigStatusDefaultConfigHttpProxy) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().DefaultConfig().HttpProxy().FieldPath(),
	})
}

func (b *filterCndBuilderStatusProxyConfigStatusDefaultConfigHttpProxy) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().DefaultConfig().HttpProxy().FieldPath(),
	})
}

func (b *filterCndBuilderStatusProxyConfigStatusDefaultConfigHttpProxy) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().DefaultConfig().HttpProxy().WithValue(value),
	})
}

type filterCndBuilderStatusProxyConfigStatusDefaultConfigHttpsProxy struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusProxyConfigStatusDefaultConfigHttpsProxy) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().DefaultConfig().HttpsProxy().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusProxyConfigStatusDefaultConfigHttpsProxy) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().DefaultConfig().HttpsProxy().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusProxyConfigStatusDefaultConfigHttpsProxy) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().DefaultConfig().HttpsProxy().FieldPath(),
	})
}

func (b *filterCndBuilderStatusProxyConfigStatusDefaultConfigHttpsProxy) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().DefaultConfig().HttpsProxy().FieldPath(),
	})
}

func (b *filterCndBuilderStatusProxyConfigStatusDefaultConfigHttpsProxy) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().DefaultConfig().HttpsProxy().WithValue(value),
	})
}

type filterCndBuilderStatusProxyConfigStatusDefaultConfigNoProxy struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusProxyConfigStatusDefaultConfigNoProxy) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().DefaultConfig().NoProxy().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusProxyConfigStatusDefaultConfigNoProxy) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().DefaultConfig().NoProxy().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusProxyConfigStatusDefaultConfigNoProxy) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().DefaultConfig().NoProxy().FieldPath(),
	})
}

func (b *filterCndBuilderStatusProxyConfigStatusDefaultConfigNoProxy) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().DefaultConfig().NoProxy().FieldPath(),
	})
}

func (b *filterCndBuilderStatusProxyConfigStatusDefaultConfigNoProxy) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().DefaultConfig().NoProxy().WithValue(value),
	})
}

type filterCndBuilderStatusProxyConfigStatusDefaultConfigProxyInterfaces struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusProxyConfigStatusDefaultConfigProxyInterfaces) In(values [][]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().DefaultConfig().ProxyInterfaces().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusProxyConfigStatusDefaultConfigProxyInterfaces) NotIn(values [][]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().DefaultConfig().ProxyInterfaces().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusProxyConfigStatusDefaultConfigProxyInterfaces) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().DefaultConfig().ProxyInterfaces().FieldPath(),
	})
}

func (b *filterCndBuilderStatusProxyConfigStatusDefaultConfigProxyInterfaces) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().DefaultConfig().ProxyInterfaces().FieldPath(),
	})
}

func (b *filterCndBuilderStatusProxyConfigStatusDefaultConfigProxyInterfaces) Contains(value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().DefaultConfig().ProxyInterfaces().FieldPath(),
		Value:     NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().DefaultConfig().ProxyInterfaces().WithItemValue(value),
	})
}

func (b *filterCndBuilderStatusProxyConfigStatusDefaultConfigProxyInterfaces) ContainsAnyOf(values []string) *FilterBuilder {
	pathSelector := NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().DefaultConfig().ProxyInterfaces()
	itemValues := make([]Device_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().DefaultConfig().ProxyInterfaces().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderStatusProxyConfigStatusDefaultConfigProxyInterfaces) ContainsAll(values []string) *FilterBuilder {
	pathSelector := NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().DefaultConfig().ProxyInterfaces()
	itemValues := make([]Device_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().DefaultConfig().ProxyInterfaces().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderStatusProxyConfigStatusDefaultConfigProxyInterfaces) compare(op gotenfilter.CompareOperator, value []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().DefaultConfig().ProxyInterfaces().WithValue(value),
	})
}

type filterCndBuilderStatusProxyConfigStatusActiveConfig struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusProxyConfigStatusActiveConfig) Eq(value *Device_Spec_ProxyConfig) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusProxyConfigStatusActiveConfig) Neq(value *Device_Spec_ProxyConfig) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusProxyConfigStatusActiveConfig) Gt(value *Device_Spec_ProxyConfig) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusProxyConfigStatusActiveConfig) Gte(value *Device_Spec_ProxyConfig) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusProxyConfigStatusActiveConfig) Lt(value *Device_Spec_ProxyConfig) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusProxyConfigStatusActiveConfig) Lte(value *Device_Spec_ProxyConfig) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusProxyConfigStatusActiveConfig) In(values []*Device_Spec_ProxyConfig) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().ActiveConfig().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusProxyConfigStatusActiveConfig) NotIn(values []*Device_Spec_ProxyConfig) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().ActiveConfig().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusProxyConfigStatusActiveConfig) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().ActiveConfig().FieldPath(),
	})
}

func (b *filterCndBuilderStatusProxyConfigStatusActiveConfig) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().ActiveConfig().FieldPath(),
	})
}

func (b *filterCndBuilderStatusProxyConfigStatusActiveConfig) compare(op gotenfilter.CompareOperator, value *Device_Spec_ProxyConfig) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().ActiveConfig().WithValue(value),
	})
}

func (b *filterCndBuilderStatusProxyConfigStatusActiveConfig) HttpProxy() *filterCndBuilderStatusProxyConfigStatusActiveConfigHttpProxy {
	return &filterCndBuilderStatusProxyConfigStatusActiveConfigHttpProxy{builder: b.builder}
}

func (b *filterCndBuilderStatusProxyConfigStatusActiveConfig) HttpsProxy() *filterCndBuilderStatusProxyConfigStatusActiveConfigHttpsProxy {
	return &filterCndBuilderStatusProxyConfigStatusActiveConfigHttpsProxy{builder: b.builder}
}

func (b *filterCndBuilderStatusProxyConfigStatusActiveConfig) NoProxy() *filterCndBuilderStatusProxyConfigStatusActiveConfigNoProxy {
	return &filterCndBuilderStatusProxyConfigStatusActiveConfigNoProxy{builder: b.builder}
}

func (b *filterCndBuilderStatusProxyConfigStatusActiveConfig) ProxyInterfaces() *filterCndBuilderStatusProxyConfigStatusActiveConfigProxyInterfaces {
	return &filterCndBuilderStatusProxyConfigStatusActiveConfigProxyInterfaces{builder: b.builder}
}

type filterCndBuilderStatusProxyConfigStatusActiveConfigHttpProxy struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusProxyConfigStatusActiveConfigHttpProxy) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().ActiveConfig().HttpProxy().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusProxyConfigStatusActiveConfigHttpProxy) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().ActiveConfig().HttpProxy().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusProxyConfigStatusActiveConfigHttpProxy) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().ActiveConfig().HttpProxy().FieldPath(),
	})
}

func (b *filterCndBuilderStatusProxyConfigStatusActiveConfigHttpProxy) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().ActiveConfig().HttpProxy().FieldPath(),
	})
}

func (b *filterCndBuilderStatusProxyConfigStatusActiveConfigHttpProxy) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().ActiveConfig().HttpProxy().WithValue(value),
	})
}

type filterCndBuilderStatusProxyConfigStatusActiveConfigHttpsProxy struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusProxyConfigStatusActiveConfigHttpsProxy) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().ActiveConfig().HttpsProxy().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusProxyConfigStatusActiveConfigHttpsProxy) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().ActiveConfig().HttpsProxy().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusProxyConfigStatusActiveConfigHttpsProxy) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().ActiveConfig().HttpsProxy().FieldPath(),
	})
}

func (b *filterCndBuilderStatusProxyConfigStatusActiveConfigHttpsProxy) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().ActiveConfig().HttpsProxy().FieldPath(),
	})
}

func (b *filterCndBuilderStatusProxyConfigStatusActiveConfigHttpsProxy) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().ActiveConfig().HttpsProxy().WithValue(value),
	})
}

type filterCndBuilderStatusProxyConfigStatusActiveConfigNoProxy struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusProxyConfigStatusActiveConfigNoProxy) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().ActiveConfig().NoProxy().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusProxyConfigStatusActiveConfigNoProxy) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().ActiveConfig().NoProxy().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusProxyConfigStatusActiveConfigNoProxy) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().ActiveConfig().NoProxy().FieldPath(),
	})
}

func (b *filterCndBuilderStatusProxyConfigStatusActiveConfigNoProxy) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().ActiveConfig().NoProxy().FieldPath(),
	})
}

func (b *filterCndBuilderStatusProxyConfigStatusActiveConfigNoProxy) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().ActiveConfig().NoProxy().WithValue(value),
	})
}

type filterCndBuilderStatusProxyConfigStatusActiveConfigProxyInterfaces struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusProxyConfigStatusActiveConfigProxyInterfaces) In(values [][]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().ActiveConfig().ProxyInterfaces().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusProxyConfigStatusActiveConfigProxyInterfaces) NotIn(values [][]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().ActiveConfig().ProxyInterfaces().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusProxyConfigStatusActiveConfigProxyInterfaces) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().ActiveConfig().ProxyInterfaces().FieldPath(),
	})
}

func (b *filterCndBuilderStatusProxyConfigStatusActiveConfigProxyInterfaces) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().ActiveConfig().ProxyInterfaces().FieldPath(),
	})
}

func (b *filterCndBuilderStatusProxyConfigStatusActiveConfigProxyInterfaces) Contains(value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().ActiveConfig().ProxyInterfaces().FieldPath(),
		Value:     NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().ActiveConfig().ProxyInterfaces().WithItemValue(value),
	})
}

func (b *filterCndBuilderStatusProxyConfigStatusActiveConfigProxyInterfaces) ContainsAnyOf(values []string) *FilterBuilder {
	pathSelector := NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().ActiveConfig().ProxyInterfaces()
	itemValues := make([]Device_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().ActiveConfig().ProxyInterfaces().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderStatusProxyConfigStatusActiveConfigProxyInterfaces) ContainsAll(values []string) *FilterBuilder {
	pathSelector := NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().ActiveConfig().ProxyInterfaces()
	itemValues := make([]Device_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().ActiveConfig().ProxyInterfaces().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderStatusProxyConfigStatusActiveConfigProxyInterfaces) compare(op gotenfilter.CompareOperator, value []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().ActiveConfig().ProxyInterfaces().WithValue(value),
	})
}

type filterCndBuilderStatusProxyConfigStatusApiConfig struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusProxyConfigStatusApiConfig) Eq(value *Device_Spec_ProxyConfig) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusProxyConfigStatusApiConfig) Neq(value *Device_Spec_ProxyConfig) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusProxyConfigStatusApiConfig) Gt(value *Device_Spec_ProxyConfig) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusProxyConfigStatusApiConfig) Gte(value *Device_Spec_ProxyConfig) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusProxyConfigStatusApiConfig) Lt(value *Device_Spec_ProxyConfig) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusProxyConfigStatusApiConfig) Lte(value *Device_Spec_ProxyConfig) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusProxyConfigStatusApiConfig) In(values []*Device_Spec_ProxyConfig) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().ApiConfig().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusProxyConfigStatusApiConfig) NotIn(values []*Device_Spec_ProxyConfig) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().ApiConfig().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusProxyConfigStatusApiConfig) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().ApiConfig().FieldPath(),
	})
}

func (b *filterCndBuilderStatusProxyConfigStatusApiConfig) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().ApiConfig().FieldPath(),
	})
}

func (b *filterCndBuilderStatusProxyConfigStatusApiConfig) compare(op gotenfilter.CompareOperator, value *Device_Spec_ProxyConfig) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().ApiConfig().WithValue(value),
	})
}

func (b *filterCndBuilderStatusProxyConfigStatusApiConfig) HttpProxy() *filterCndBuilderStatusProxyConfigStatusApiConfigHttpProxy {
	return &filterCndBuilderStatusProxyConfigStatusApiConfigHttpProxy{builder: b.builder}
}

func (b *filterCndBuilderStatusProxyConfigStatusApiConfig) HttpsProxy() *filterCndBuilderStatusProxyConfigStatusApiConfigHttpsProxy {
	return &filterCndBuilderStatusProxyConfigStatusApiConfigHttpsProxy{builder: b.builder}
}

func (b *filterCndBuilderStatusProxyConfigStatusApiConfig) NoProxy() *filterCndBuilderStatusProxyConfigStatusApiConfigNoProxy {
	return &filterCndBuilderStatusProxyConfigStatusApiConfigNoProxy{builder: b.builder}
}

func (b *filterCndBuilderStatusProxyConfigStatusApiConfig) ProxyInterfaces() *filterCndBuilderStatusProxyConfigStatusApiConfigProxyInterfaces {
	return &filterCndBuilderStatusProxyConfigStatusApiConfigProxyInterfaces{builder: b.builder}
}

type filterCndBuilderStatusProxyConfigStatusApiConfigHttpProxy struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusProxyConfigStatusApiConfigHttpProxy) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().ApiConfig().HttpProxy().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusProxyConfigStatusApiConfigHttpProxy) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().ApiConfig().HttpProxy().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusProxyConfigStatusApiConfigHttpProxy) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().ApiConfig().HttpProxy().FieldPath(),
	})
}

func (b *filterCndBuilderStatusProxyConfigStatusApiConfigHttpProxy) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().ApiConfig().HttpProxy().FieldPath(),
	})
}

func (b *filterCndBuilderStatusProxyConfigStatusApiConfigHttpProxy) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().ApiConfig().HttpProxy().WithValue(value),
	})
}

type filterCndBuilderStatusProxyConfigStatusApiConfigHttpsProxy struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusProxyConfigStatusApiConfigHttpsProxy) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().ApiConfig().HttpsProxy().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusProxyConfigStatusApiConfigHttpsProxy) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().ApiConfig().HttpsProxy().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusProxyConfigStatusApiConfigHttpsProxy) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().ApiConfig().HttpsProxy().FieldPath(),
	})
}

func (b *filterCndBuilderStatusProxyConfigStatusApiConfigHttpsProxy) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().ApiConfig().HttpsProxy().FieldPath(),
	})
}

func (b *filterCndBuilderStatusProxyConfigStatusApiConfigHttpsProxy) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().ApiConfig().HttpsProxy().WithValue(value),
	})
}

type filterCndBuilderStatusProxyConfigStatusApiConfigNoProxy struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusProxyConfigStatusApiConfigNoProxy) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().ApiConfig().NoProxy().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusProxyConfigStatusApiConfigNoProxy) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().ApiConfig().NoProxy().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusProxyConfigStatusApiConfigNoProxy) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().ApiConfig().NoProxy().FieldPath(),
	})
}

func (b *filterCndBuilderStatusProxyConfigStatusApiConfigNoProxy) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().ApiConfig().NoProxy().FieldPath(),
	})
}

func (b *filterCndBuilderStatusProxyConfigStatusApiConfigNoProxy) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().ApiConfig().NoProxy().WithValue(value),
	})
}

type filterCndBuilderStatusProxyConfigStatusApiConfigProxyInterfaces struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusProxyConfigStatusApiConfigProxyInterfaces) In(values [][]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().ApiConfig().ProxyInterfaces().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusProxyConfigStatusApiConfigProxyInterfaces) NotIn(values [][]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().ApiConfig().ProxyInterfaces().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusProxyConfigStatusApiConfigProxyInterfaces) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().ApiConfig().ProxyInterfaces().FieldPath(),
	})
}

func (b *filterCndBuilderStatusProxyConfigStatusApiConfigProxyInterfaces) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().ApiConfig().ProxyInterfaces().FieldPath(),
	})
}

func (b *filterCndBuilderStatusProxyConfigStatusApiConfigProxyInterfaces) Contains(value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().ApiConfig().ProxyInterfaces().FieldPath(),
		Value:     NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().ApiConfig().ProxyInterfaces().WithItemValue(value),
	})
}

func (b *filterCndBuilderStatusProxyConfigStatusApiConfigProxyInterfaces) ContainsAnyOf(values []string) *FilterBuilder {
	pathSelector := NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().ApiConfig().ProxyInterfaces()
	itemValues := make([]Device_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().ApiConfig().ProxyInterfaces().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderStatusProxyConfigStatusApiConfigProxyInterfaces) ContainsAll(values []string) *FilterBuilder {
	pathSelector := NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().ApiConfig().ProxyInterfaces()
	itemValues := make([]Device_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().ApiConfig().ProxyInterfaces().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderStatusProxyConfigStatusApiConfigProxyInterfaces) compare(op gotenfilter.CompareOperator, value []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().ProxyConfigStatus().ApiConfig().ProxyInterfaces().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfo struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfo) Eq(value *Device_Status_DeviceInfo) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfo) Neq(value *Device_Status_DeviceInfo) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfo) Gt(value *Device_Status_DeviceInfo) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfo) Gte(value *Device_Status_DeviceInfo) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfo) Lt(value *Device_Status_DeviceInfo) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfo) Lte(value *Device_Status_DeviceInfo) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfo) In(values []*Device_Status_DeviceInfo) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfo) NotIn(values []*Device_Status_DeviceInfo) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfo) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfo) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfo) compare(op gotenfilter.CompareOperator, value *Device_Status_DeviceInfo) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().WithValue(value),
	})
}

func (b *filterCndBuilderStatusDeviceInfo) Architecture() *filterCndBuilderStatusDeviceInfoArchitecture {
	return &filterCndBuilderStatusDeviceInfoArchitecture{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfo) Hardware() *filterCndBuilderStatusDeviceInfoHardware {
	return &filterCndBuilderStatusDeviceInfoHardware{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfo) OperatingSystem() *filterCndBuilderStatusDeviceInfoOperatingSystem {
	return &filterCndBuilderStatusDeviceInfoOperatingSystem{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfo) KernelVersion() *filterCndBuilderStatusDeviceInfoKernelVersion {
	return &filterCndBuilderStatusDeviceInfoKernelVersion{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfo) OsImage() *filterCndBuilderStatusDeviceInfoOsImage {
	return &filterCndBuilderStatusDeviceInfoOsImage{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfo) ContainerRuntimeVersion() *filterCndBuilderStatusDeviceInfoContainerRuntimeVersion {
	return &filterCndBuilderStatusDeviceInfoContainerRuntimeVersion{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfo) OsVersion() *filterCndBuilderStatusDeviceInfoOsVersion {
	return &filterCndBuilderStatusDeviceInfoOsVersion{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfo) Driver() *filterCndBuilderStatusDeviceInfoDriver {
	return &filterCndBuilderStatusDeviceInfoDriver{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfo) HardwareInformation() *filterCndBuilderStatusDeviceInfoHardwareInformation {
	return &filterCndBuilderStatusDeviceInfoHardwareInformation{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfo) NetworkInterfaces() *filterCndBuilderStatusDeviceInfoNetworkInterfaces {
	return &filterCndBuilderStatusDeviceInfoNetworkInterfaces{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfo) ControlPlaneInterfaceInfo() *filterCndBuilderStatusDeviceInfoControlPlaneInterfaceInfo {
	return &filterCndBuilderStatusDeviceInfoControlPlaneInterfaceInfo{builder: b.builder}
}

type filterCndBuilderStatusDeviceInfoArchitecture struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusDeviceInfoArchitecture) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().Architecture().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoArchitecture) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().Architecture().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoArchitecture) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().Architecture().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoArchitecture) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().Architecture().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoArchitecture) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().Architecture().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardware struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusDeviceInfoHardware) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().Hardware().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardware) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().Hardware().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardware) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().Hardware().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardware) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().Hardware().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardware) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().Hardware().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoOperatingSystem struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusDeviceInfoOperatingSystem) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().OperatingSystem().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoOperatingSystem) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().OperatingSystem().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoOperatingSystem) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().OperatingSystem().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoOperatingSystem) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().OperatingSystem().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoOperatingSystem) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().OperatingSystem().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoKernelVersion struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusDeviceInfoKernelVersion) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().KernelVersion().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoKernelVersion) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().KernelVersion().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoKernelVersion) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().KernelVersion().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoKernelVersion) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().KernelVersion().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoKernelVersion) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().KernelVersion().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoOsImage struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusDeviceInfoOsImage) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().OsImage().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoOsImage) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().OsImage().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoOsImage) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().OsImage().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoOsImage) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().OsImage().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoOsImage) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().OsImage().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoContainerRuntimeVersion struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusDeviceInfoContainerRuntimeVersion) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().ContainerRuntimeVersion().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoContainerRuntimeVersion) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().ContainerRuntimeVersion().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoContainerRuntimeVersion) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().ContainerRuntimeVersion().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoContainerRuntimeVersion) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().ContainerRuntimeVersion().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoContainerRuntimeVersion) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().ContainerRuntimeVersion().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoOsVersion struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusDeviceInfoOsVersion) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().OsVersion().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoOsVersion) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().OsVersion().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoOsVersion) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().OsVersion().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoOsVersion) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().OsVersion().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoOsVersion) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().OsVersion().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoDriver struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusDeviceInfoDriver) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().Driver().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoDriver) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().Driver().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoDriver) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().Driver().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoDriver) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().Driver().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoDriver) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().Driver().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformation struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformation) Eq(value *Device_Status_DeviceInfo_HardwareInformation) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformation) Neq(value *Device_Status_DeviceInfo_HardwareInformation) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformation) Gt(value *Device_Status_DeviceInfo_HardwareInformation) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformation) Gte(value *Device_Status_DeviceInfo_HardwareInformation) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformation) Lt(value *Device_Status_DeviceInfo_HardwareInformation) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformation) Lte(value *Device_Status_DeviceInfo_HardwareInformation) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformation) In(values []*Device_Status_DeviceInfo_HardwareInformation) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformation) NotIn(values []*Device_Status_DeviceInfo_HardwareInformation) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformation) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformation) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformation) compare(op gotenfilter.CompareOperator, value *Device_Status_DeviceInfo_HardwareInformation) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().WithValue(value),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformation) Os() *filterCndBuilderStatusDeviceInfoHardwareInformationOs {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationOs{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformation) Bios() *filterCndBuilderStatusDeviceInfoHardwareInformationBios {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationBios{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformation) System() *filterCndBuilderStatusDeviceInfoHardwareInformationSystem {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationSystem{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformation) Cpu() *filterCndBuilderStatusDeviceInfoHardwareInformationCpu {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationCpu{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformation) Block() *filterCndBuilderStatusDeviceInfoHardwareInformationBlock {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationBlock{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformation) Network() *filterCndBuilderStatusDeviceInfoHardwareInformationNetwork {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationNetwork{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformation) Gpu() *filterCndBuilderStatusDeviceInfoHardwareInformationGpu {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationGpu{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformation) MemoryInfo() *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfo {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfo{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformation) HailoInfo() *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfo {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfo{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformation) NvidiaInfo() *filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfo {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfo{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformation) ModemStatus() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatus {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatus{builder: b.builder}
}

type filterCndBuilderStatusDeviceInfoHardwareInformationOs struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationOs) Eq(value *Device_Status_DeviceInfo_HardwareInformation_OS) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationOs) Neq(value *Device_Status_DeviceInfo_HardwareInformation_OS) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationOs) Gt(value *Device_Status_DeviceInfo_HardwareInformation_OS) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationOs) Gte(value *Device_Status_DeviceInfo_HardwareInformation_OS) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationOs) Lt(value *Device_Status_DeviceInfo_HardwareInformation_OS) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationOs) Lte(value *Device_Status_DeviceInfo_HardwareInformation_OS) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationOs) In(values []*Device_Status_DeviceInfo_HardwareInformation_OS) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Os().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationOs) NotIn(values []*Device_Status_DeviceInfo_HardwareInformation_OS) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Os().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationOs) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Os().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationOs) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Os().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationOs) compare(op gotenfilter.CompareOperator, value *Device_Status_DeviceInfo_HardwareInformation_OS) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Os().WithValue(value),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationOs) OperatingSystem() *filterCndBuilderStatusDeviceInfoHardwareInformationOsOperatingSystem {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationOsOperatingSystem{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationOs) KernelVersion() *filterCndBuilderStatusDeviceInfoHardwareInformationOsKernelVersion {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationOsKernelVersion{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationOs) OsImage() *filterCndBuilderStatusDeviceInfoHardwareInformationOsOsImage {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationOsOsImage{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationOs) ContainerRuntimeVersion() *filterCndBuilderStatusDeviceInfoHardwareInformationOsContainerRuntimeVersion {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationOsContainerRuntimeVersion{builder: b.builder}
}

type filterCndBuilderStatusDeviceInfoHardwareInformationOsOperatingSystem struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationOsOperatingSystem) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Os().OperatingSystem().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationOsOperatingSystem) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Os().OperatingSystem().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationOsOperatingSystem) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Os().OperatingSystem().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationOsOperatingSystem) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Os().OperatingSystem().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationOsOperatingSystem) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Os().OperatingSystem().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationOsKernelVersion struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationOsKernelVersion) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Os().KernelVersion().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationOsKernelVersion) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Os().KernelVersion().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationOsKernelVersion) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Os().KernelVersion().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationOsKernelVersion) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Os().KernelVersion().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationOsKernelVersion) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Os().KernelVersion().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationOsOsImage struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationOsOsImage) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Os().OsImage().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationOsOsImage) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Os().OsImage().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationOsOsImage) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Os().OsImage().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationOsOsImage) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Os().OsImage().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationOsOsImage) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Os().OsImage().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationOsContainerRuntimeVersion struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationOsContainerRuntimeVersion) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Os().ContainerRuntimeVersion().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationOsContainerRuntimeVersion) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Os().ContainerRuntimeVersion().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationOsContainerRuntimeVersion) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Os().ContainerRuntimeVersion().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationOsContainerRuntimeVersion) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Os().ContainerRuntimeVersion().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationOsContainerRuntimeVersion) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Os().ContainerRuntimeVersion().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationBios struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBios) Eq(value *Device_Status_DeviceInfo_HardwareInformation_BIOS) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBios) Neq(value *Device_Status_DeviceInfo_HardwareInformation_BIOS) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBios) Gt(value *Device_Status_DeviceInfo_HardwareInformation_BIOS) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBios) Gte(value *Device_Status_DeviceInfo_HardwareInformation_BIOS) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBios) Lt(value *Device_Status_DeviceInfo_HardwareInformation_BIOS) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBios) Lte(value *Device_Status_DeviceInfo_HardwareInformation_BIOS) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBios) In(values []*Device_Status_DeviceInfo_HardwareInformation_BIOS) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Bios().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBios) NotIn(values []*Device_Status_DeviceInfo_HardwareInformation_BIOS) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Bios().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBios) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Bios().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBios) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Bios().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBios) compare(op gotenfilter.CompareOperator, value *Device_Status_DeviceInfo_HardwareInformation_BIOS) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Bios().WithValue(value),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBios) Vendor() *filterCndBuilderStatusDeviceInfoHardwareInformationBiosVendor {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationBiosVendor{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBios) BiosVersion() *filterCndBuilderStatusDeviceInfoHardwareInformationBiosBiosVersion {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationBiosBiosVersion{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBios) ReleaseDate() *filterCndBuilderStatusDeviceInfoHardwareInformationBiosReleaseDate {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationBiosReleaseDate{builder: b.builder}
}

type filterCndBuilderStatusDeviceInfoHardwareInformationBiosVendor struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBiosVendor) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Bios().Vendor().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBiosVendor) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Bios().Vendor().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBiosVendor) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Bios().Vendor().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBiosVendor) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Bios().Vendor().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBiosVendor) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Bios().Vendor().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationBiosBiosVersion struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBiosBiosVersion) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Bios().BiosVersion().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBiosBiosVersion) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Bios().BiosVersion().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBiosBiosVersion) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Bios().BiosVersion().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBiosBiosVersion) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Bios().BiosVersion().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBiosBiosVersion) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Bios().BiosVersion().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationBiosReleaseDate struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBiosReleaseDate) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Bios().ReleaseDate().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBiosReleaseDate) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Bios().ReleaseDate().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBiosReleaseDate) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Bios().ReleaseDate().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBiosReleaseDate) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Bios().ReleaseDate().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBiosReleaseDate) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Bios().ReleaseDate().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationSystem struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationSystem) Eq(value *Device_Status_DeviceInfo_HardwareInformation_System) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationSystem) Neq(value *Device_Status_DeviceInfo_HardwareInformation_System) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationSystem) Gt(value *Device_Status_DeviceInfo_HardwareInformation_System) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationSystem) Gte(value *Device_Status_DeviceInfo_HardwareInformation_System) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationSystem) Lt(value *Device_Status_DeviceInfo_HardwareInformation_System) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationSystem) Lte(value *Device_Status_DeviceInfo_HardwareInformation_System) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationSystem) In(values []*Device_Status_DeviceInfo_HardwareInformation_System) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().System().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationSystem) NotIn(values []*Device_Status_DeviceInfo_HardwareInformation_System) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().System().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationSystem) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().System().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationSystem) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().System().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationSystem) compare(op gotenfilter.CompareOperator, value *Device_Status_DeviceInfo_HardwareInformation_System) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().System().WithValue(value),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationSystem) Manufacturer() *filterCndBuilderStatusDeviceInfoHardwareInformationSystemManufacturer {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationSystemManufacturer{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationSystem) ProductName() *filterCndBuilderStatusDeviceInfoHardwareInformationSystemProductName {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationSystemProductName{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationSystem) Version() *filterCndBuilderStatusDeviceInfoHardwareInformationSystemVersion {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationSystemVersion{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationSystem) SerialNumber() *filterCndBuilderStatusDeviceInfoHardwareInformationSystemSerialNumber {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationSystemSerialNumber{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationSystem) Configuration() *filterCndBuilderStatusDeviceInfoHardwareInformationSystemConfiguration {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationSystemConfiguration{builder: b.builder}
}

type filterCndBuilderStatusDeviceInfoHardwareInformationSystemManufacturer struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationSystemManufacturer) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().System().Manufacturer().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationSystemManufacturer) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().System().Manufacturer().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationSystemManufacturer) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().System().Manufacturer().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationSystemManufacturer) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().System().Manufacturer().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationSystemManufacturer) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().System().Manufacturer().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationSystemProductName struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationSystemProductName) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().System().ProductName().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationSystemProductName) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().System().ProductName().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationSystemProductName) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().System().ProductName().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationSystemProductName) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().System().ProductName().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationSystemProductName) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().System().ProductName().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationSystemVersion struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationSystemVersion) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().System().Version().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationSystemVersion) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().System().Version().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationSystemVersion) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().System().Version().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationSystemVersion) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().System().Version().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationSystemVersion) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().System().Version().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationSystemSerialNumber struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationSystemSerialNumber) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().System().SerialNumber().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationSystemSerialNumber) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().System().SerialNumber().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationSystemSerialNumber) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().System().SerialNumber().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationSystemSerialNumber) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().System().SerialNumber().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationSystemSerialNumber) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().System().SerialNumber().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationSystemConfiguration struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationSystemConfiguration) Eq(value *Device_Status_DeviceInfo_HardwareInformation_System_Configuration) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationSystemConfiguration) Neq(value *Device_Status_DeviceInfo_HardwareInformation_System_Configuration) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationSystemConfiguration) Gt(value *Device_Status_DeviceInfo_HardwareInformation_System_Configuration) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationSystemConfiguration) Gte(value *Device_Status_DeviceInfo_HardwareInformation_System_Configuration) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationSystemConfiguration) Lt(value *Device_Status_DeviceInfo_HardwareInformation_System_Configuration) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationSystemConfiguration) Lte(value *Device_Status_DeviceInfo_HardwareInformation_System_Configuration) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationSystemConfiguration) In(values []*Device_Status_DeviceInfo_HardwareInformation_System_Configuration) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().System().Configuration().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationSystemConfiguration) NotIn(values []*Device_Status_DeviceInfo_HardwareInformation_System_Configuration) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().System().Configuration().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationSystemConfiguration) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().System().Configuration().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationSystemConfiguration) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().System().Configuration().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationSystemConfiguration) compare(op gotenfilter.CompareOperator, value *Device_Status_DeviceInfo_HardwareInformation_System_Configuration) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().System().Configuration().WithValue(value),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationSystemConfiguration) Chassis() *filterCndBuilderStatusDeviceInfoHardwareInformationSystemConfigurationChassis {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationSystemConfigurationChassis{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationSystemConfiguration) Uuid() *filterCndBuilderStatusDeviceInfoHardwareInformationSystemConfigurationUuid {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationSystemConfigurationUuid{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationSystemConfiguration) SkuNumber() *filterCndBuilderStatusDeviceInfoHardwareInformationSystemConfigurationSkuNumber {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationSystemConfigurationSkuNumber{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationSystemConfiguration) Family() *filterCndBuilderStatusDeviceInfoHardwareInformationSystemConfigurationFamily {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationSystemConfigurationFamily{builder: b.builder}
}

type filterCndBuilderStatusDeviceInfoHardwareInformationSystemConfigurationChassis struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationSystemConfigurationChassis) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().System().Configuration().Chassis().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationSystemConfigurationChassis) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().System().Configuration().Chassis().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationSystemConfigurationChassis) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().System().Configuration().Chassis().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationSystemConfigurationChassis) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().System().Configuration().Chassis().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationSystemConfigurationChassis) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().System().Configuration().Chassis().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationSystemConfigurationUuid struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationSystemConfigurationUuid) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().System().Configuration().Uuid().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationSystemConfigurationUuid) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().System().Configuration().Uuid().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationSystemConfigurationUuid) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().System().Configuration().Uuid().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationSystemConfigurationUuid) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().System().Configuration().Uuid().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationSystemConfigurationUuid) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().System().Configuration().Uuid().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationSystemConfigurationSkuNumber struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationSystemConfigurationSkuNumber) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().System().Configuration().SkuNumber().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationSystemConfigurationSkuNumber) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().System().Configuration().SkuNumber().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationSystemConfigurationSkuNumber) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().System().Configuration().SkuNumber().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationSystemConfigurationSkuNumber) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().System().Configuration().SkuNumber().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationSystemConfigurationSkuNumber) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().System().Configuration().SkuNumber().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationSystemConfigurationFamily struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationSystemConfigurationFamily) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().System().Configuration().Family().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationSystemConfigurationFamily) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().System().Configuration().Family().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationSystemConfigurationFamily) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().System().Configuration().Family().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationSystemConfigurationFamily) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().System().Configuration().Family().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationSystemConfigurationFamily) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().System().Configuration().Family().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationCpu struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpu) Eq(value *Device_Status_DeviceInfo_HardwareInformation_CPU) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpu) Neq(value *Device_Status_DeviceInfo_HardwareInformation_CPU) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpu) Gt(value *Device_Status_DeviceInfo_HardwareInformation_CPU) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpu) Gte(value *Device_Status_DeviceInfo_HardwareInformation_CPU) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpu) Lt(value *Device_Status_DeviceInfo_HardwareInformation_CPU) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpu) Lte(value *Device_Status_DeviceInfo_HardwareInformation_CPU) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpu) In(values []*Device_Status_DeviceInfo_HardwareInformation_CPU) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpu) NotIn(values []*Device_Status_DeviceInfo_HardwareInformation_CPU) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpu) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpu) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpu) compare(op gotenfilter.CompareOperator, value *Device_Status_DeviceInfo_HardwareInformation_CPU) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().WithValue(value),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpu) Processors() *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessors {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessors{builder: b.builder}
}

type filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessors struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessors) In(values [][]*Device_Status_DeviceInfo_HardwareInformation_CPU_Processor) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessors) NotIn(values [][]*Device_Status_DeviceInfo_HardwareInformation_CPU_Processor) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessors) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessors) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessors) Contains(value *Device_Status_DeviceInfo_HardwareInformation_CPU_Processor) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().FieldPath(),
		Value:     NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().WithItemValue(value),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessors) ContainsAnyOf(values []*Device_Status_DeviceInfo_HardwareInformation_CPU_Processor) *FilterBuilder {
	pathSelector := NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors()
	itemValues := make([]Device_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessors) ContainsAll(values []*Device_Status_DeviceInfo_HardwareInformation_CPU_Processor) *FilterBuilder {
	pathSelector := NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors()
	itemValues := make([]Device_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessors) compare(op gotenfilter.CompareOperator, value []*Device_Status_DeviceInfo_HardwareInformation_CPU_Processor) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().WithValue(value),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessors) Vendor() *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsVendor {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsVendor{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessors) Model() *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsModel {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsModel{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessors) Capabilities() *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsCapabilities {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsCapabilities{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessors) NumThreads() *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsNumThreads {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsNumThreads{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessors) NumCores() *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsNumCores {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsNumCores{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessors) NumEnabledCores() *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsNumEnabledCores {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsNumEnabledCores{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessors) Name() *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsName {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsName{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessors) Serial() *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsSerial {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsSerial{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessors) FrequencyMhz() *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsFrequencyMhz {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsFrequencyMhz{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessors) MaxFrequencyMhz() *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsMaxFrequencyMhz {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsMaxFrequencyMhz{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessors) CacheInfo() *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsCacheInfo {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsCacheInfo{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessors) Driver() *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsDriver {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsDriver{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessors) Latency() *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsLatency {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsLatency{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessors) Clock() *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsClock {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsClock{builder: b.builder}
}

type filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsVendor struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsVendor) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().Vendor().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsVendor) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().Vendor().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsVendor) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().Vendor().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsVendor) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().Vendor().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsVendor) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().Vendor().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsModel struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsModel) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().Model().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsModel) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().Model().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsModel) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().Model().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsModel) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().Model().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsModel) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().Model().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsCapabilities struct {
	builder *FilterBuilder
}

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

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsCapabilities) Neq(value []*Device_Status_DeviceInfo_HardwareInformation_Capability) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsCapabilities) Gt(value []*Device_Status_DeviceInfo_HardwareInformation_Capability) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsCapabilities) Gte(value []*Device_Status_DeviceInfo_HardwareInformation_Capability) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsCapabilities) Lt(value []*Device_Status_DeviceInfo_HardwareInformation_Capability) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsCapabilities) Lte(value []*Device_Status_DeviceInfo_HardwareInformation_Capability) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsCapabilities) In(values [][]*Device_Status_DeviceInfo_HardwareInformation_Capability) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().Capabilities().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsCapabilities) NotIn(values [][]*Device_Status_DeviceInfo_HardwareInformation_Capability) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().Capabilities().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsCapabilities) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().Capabilities().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsCapabilities) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().Capabilities().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsCapabilities) Contains(value *Device_Status_DeviceInfo_HardwareInformation_Capability) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().Capabilities().FieldPath(),
		Value:     NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().Capabilities().WithItemValue(value),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsCapabilities) ContainsAnyOf(values []*Device_Status_DeviceInfo_HardwareInformation_Capability) *FilterBuilder {
	pathSelector := NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().Capabilities()
	itemValues := make([]Device_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().Capabilities().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsCapabilities) ContainsAll(values []*Device_Status_DeviceInfo_HardwareInformation_Capability) *FilterBuilder {
	pathSelector := NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().Capabilities()
	itemValues := make([]Device_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().Capabilities().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsCapabilities) compare(op gotenfilter.CompareOperator, value []*Device_Status_DeviceInfo_HardwareInformation_Capability) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().Capabilities().WithValue(value),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsCapabilities) Name() *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsCapabilitiesName {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsCapabilitiesName{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsCapabilities) Description() *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsCapabilitiesDescription {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsCapabilitiesDescription{builder: b.builder}
}

type filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsCapabilitiesName struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsCapabilitiesName) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsCapabilitiesName) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsCapabilitiesName) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsCapabilitiesName) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsCapabilitiesName) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsCapabilitiesName) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsCapabilitiesName) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().Capabilities().Name().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsCapabilitiesName) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().Capabilities().Name().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsCapabilitiesName) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().Capabilities().Name().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsCapabilitiesName) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().Capabilities().Name().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsCapabilitiesName) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().Capabilities().Name().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsCapabilitiesDescription struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsCapabilitiesDescription) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsCapabilitiesDescription) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsCapabilitiesDescription) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsCapabilitiesDescription) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsCapabilitiesDescription) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsCapabilitiesDescription) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsCapabilitiesDescription) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().Capabilities().Description().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsCapabilitiesDescription) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().Capabilities().Description().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsCapabilitiesDescription) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().Capabilities().Description().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsCapabilitiesDescription) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().Capabilities().Description().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsCapabilitiesDescription) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().Capabilities().Description().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsNumThreads struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsNumThreads) Eq(value uint32) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsNumThreads) Neq(value uint32) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsNumThreads) Gt(value uint32) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsNumThreads) Gte(value uint32) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsNumThreads) Lt(value uint32) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsNumThreads) Lte(value uint32) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsNumThreads) In(values []uint32) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().NumThreads().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsNumThreads) NotIn(values []uint32) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().NumThreads().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsNumThreads) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().NumThreads().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsNumThreads) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().NumThreads().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsNumThreads) compare(op gotenfilter.CompareOperator, value uint32) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().NumThreads().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsNumCores struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsNumCores) Eq(value uint32) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsNumCores) Neq(value uint32) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsNumCores) Gt(value uint32) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsNumCores) Gte(value uint32) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsNumCores) Lt(value uint32) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsNumCores) Lte(value uint32) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsNumCores) In(values []uint32) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().NumCores().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsNumCores) NotIn(values []uint32) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().NumCores().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsNumCores) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().NumCores().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsNumCores) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().NumCores().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsNumCores) compare(op gotenfilter.CompareOperator, value uint32) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().NumCores().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsNumEnabledCores struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsNumEnabledCores) Eq(value uint32) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsNumEnabledCores) Neq(value uint32) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsNumEnabledCores) Gt(value uint32) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsNumEnabledCores) Gte(value uint32) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsNumEnabledCores) Lt(value uint32) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsNumEnabledCores) Lte(value uint32) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsNumEnabledCores) In(values []uint32) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().NumEnabledCores().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsNumEnabledCores) NotIn(values []uint32) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().NumEnabledCores().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsNumEnabledCores) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().NumEnabledCores().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsNumEnabledCores) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().NumEnabledCores().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsNumEnabledCores) compare(op gotenfilter.CompareOperator, value uint32) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().NumEnabledCores().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsName struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsName) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsName) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsName) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsName) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsName) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsName) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsName) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().Name().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsName) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().Name().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsName) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().Name().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsName) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().Name().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsName) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().Name().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsSerial struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsSerial) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsSerial) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsSerial) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsSerial) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsSerial) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsSerial) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsSerial) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().Serial().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsSerial) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().Serial().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsSerial) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().Serial().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsSerial) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().Serial().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsSerial) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().Serial().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsFrequencyMhz struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsFrequencyMhz) Eq(value int64) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsFrequencyMhz) Neq(value int64) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsFrequencyMhz) Gt(value int64) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsFrequencyMhz) Gte(value int64) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsFrequencyMhz) Lt(value int64) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsFrequencyMhz) Lte(value int64) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsFrequencyMhz) In(values []int64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().FrequencyMhz().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsFrequencyMhz) NotIn(values []int64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().FrequencyMhz().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsFrequencyMhz) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().FrequencyMhz().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsFrequencyMhz) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().FrequencyMhz().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsFrequencyMhz) compare(op gotenfilter.CompareOperator, value int64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().FrequencyMhz().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsMaxFrequencyMhz struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsMaxFrequencyMhz) Eq(value int64) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsMaxFrequencyMhz) Neq(value int64) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsMaxFrequencyMhz) Gt(value int64) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsMaxFrequencyMhz) Gte(value int64) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsMaxFrequencyMhz) Lt(value int64) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsMaxFrequencyMhz) Lte(value int64) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsMaxFrequencyMhz) In(values []int64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().MaxFrequencyMhz().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsMaxFrequencyMhz) NotIn(values []int64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().MaxFrequencyMhz().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsMaxFrequencyMhz) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().MaxFrequencyMhz().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsMaxFrequencyMhz) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().MaxFrequencyMhz().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsMaxFrequencyMhz) compare(op gotenfilter.CompareOperator, value int64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().MaxFrequencyMhz().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsCacheInfo struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsCacheInfo) Eq(value []*Device_Status_DeviceInfo_HardwareInformation_CPU_Processor_Cache) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsCacheInfo) Neq(value []*Device_Status_DeviceInfo_HardwareInformation_CPU_Processor_Cache) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsCacheInfo) Gt(value []*Device_Status_DeviceInfo_HardwareInformation_CPU_Processor_Cache) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsCacheInfo) Gte(value []*Device_Status_DeviceInfo_HardwareInformation_CPU_Processor_Cache) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsCacheInfo) Lt(value []*Device_Status_DeviceInfo_HardwareInformation_CPU_Processor_Cache) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsCacheInfo) Lte(value []*Device_Status_DeviceInfo_HardwareInformation_CPU_Processor_Cache) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsCacheInfo) In(values [][]*Device_Status_DeviceInfo_HardwareInformation_CPU_Processor_Cache) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().CacheInfo().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsCacheInfo) NotIn(values [][]*Device_Status_DeviceInfo_HardwareInformation_CPU_Processor_Cache) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().CacheInfo().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsCacheInfo) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().CacheInfo().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsCacheInfo) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().CacheInfo().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsCacheInfo) Contains(value *Device_Status_DeviceInfo_HardwareInformation_CPU_Processor_Cache) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().CacheInfo().FieldPath(),
		Value:     NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().CacheInfo().WithItemValue(value),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsCacheInfo) ContainsAnyOf(values []*Device_Status_DeviceInfo_HardwareInformation_CPU_Processor_Cache) *FilterBuilder {
	pathSelector := NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().CacheInfo()
	itemValues := make([]Device_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().CacheInfo().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsCacheInfo) ContainsAll(values []*Device_Status_DeviceInfo_HardwareInformation_CPU_Processor_Cache) *FilterBuilder {
	pathSelector := NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().CacheInfo()
	itemValues := make([]Device_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().CacheInfo().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsCacheInfo) compare(op gotenfilter.CompareOperator, value []*Device_Status_DeviceInfo_HardwareInformation_CPU_Processor_Cache) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().CacheInfo().WithValue(value),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsCacheInfo) Type() *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsCacheInfoType {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsCacheInfoType{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsCacheInfo) SizeBytes() *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsCacheInfoSizeBytes {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsCacheInfoSizeBytes{builder: b.builder}
}

type filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsCacheInfoType struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsCacheInfoType) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsCacheInfoType) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsCacheInfoType) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsCacheInfoType) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsCacheInfoType) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsCacheInfoType) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsCacheInfoType) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().CacheInfo().Type().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsCacheInfoType) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().CacheInfo().Type().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsCacheInfoType) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().CacheInfo().Type().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsCacheInfoType) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().CacheInfo().Type().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsCacheInfoType) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().CacheInfo().Type().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsCacheInfoSizeBytes struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsCacheInfoSizeBytes) Eq(value int64) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsCacheInfoSizeBytes) Neq(value int64) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsCacheInfoSizeBytes) Gt(value int64) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsCacheInfoSizeBytes) Gte(value int64) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsCacheInfoSizeBytes) Lt(value int64) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsCacheInfoSizeBytes) Lte(value int64) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsCacheInfoSizeBytes) In(values []int64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().CacheInfo().SizeBytes().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsCacheInfoSizeBytes) NotIn(values []int64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().CacheInfo().SizeBytes().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsCacheInfoSizeBytes) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().CacheInfo().SizeBytes().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsCacheInfoSizeBytes) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().CacheInfo().SizeBytes().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsCacheInfoSizeBytes) compare(op gotenfilter.CompareOperator, value int64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().CacheInfo().SizeBytes().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsDriver struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsDriver) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsDriver) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsDriver) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsDriver) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsDriver) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsDriver) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsDriver) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().Driver().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsDriver) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().Driver().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsDriver) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().Driver().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsDriver) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().Driver().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsDriver) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().Driver().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsLatency struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsLatency) Eq(value int64) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsLatency) Neq(value int64) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsLatency) Gt(value int64) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsLatency) Gte(value int64) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsLatency) Lt(value int64) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsLatency) Lte(value int64) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsLatency) In(values []int64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().Latency().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsLatency) NotIn(values []int64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().Latency().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsLatency) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().Latency().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsLatency) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().Latency().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsLatency) compare(op gotenfilter.CompareOperator, value int64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().Latency().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsClock struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsClock) Eq(value int64) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsClock) Neq(value int64) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsClock) Gt(value int64) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsClock) Gte(value int64) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsClock) Lt(value int64) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsClock) Lte(value int64) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsClock) In(values []int64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().Clock().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsClock) NotIn(values []int64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().Clock().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsClock) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().Clock().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsClock) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().Clock().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationCpuProcessorsClock) compare(op gotenfilter.CompareOperator, value int64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Cpu().Processors().Clock().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationBlock struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlock) Eq(value *Device_Status_DeviceInfo_HardwareInformation_Block) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlock) Neq(value *Device_Status_DeviceInfo_HardwareInformation_Block) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlock) Gt(value *Device_Status_DeviceInfo_HardwareInformation_Block) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlock) Gte(value *Device_Status_DeviceInfo_HardwareInformation_Block) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlock) Lt(value *Device_Status_DeviceInfo_HardwareInformation_Block) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlock) Lte(value *Device_Status_DeviceInfo_HardwareInformation_Block) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlock) In(values []*Device_Status_DeviceInfo_HardwareInformation_Block) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Block().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlock) NotIn(values []*Device_Status_DeviceInfo_HardwareInformation_Block) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Block().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlock) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Block().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlock) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Block().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlock) compare(op gotenfilter.CompareOperator, value *Device_Status_DeviceInfo_HardwareInformation_Block) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Block().WithValue(value),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlock) Disks() *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisks {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisks{builder: b.builder}
}

type filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisks struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisks) Eq(value []*Device_Status_DeviceInfo_HardwareInformation_Block_Disk) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisks) Neq(value []*Device_Status_DeviceInfo_HardwareInformation_Block_Disk) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisks) Gt(value []*Device_Status_DeviceInfo_HardwareInformation_Block_Disk) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisks) Gte(value []*Device_Status_DeviceInfo_HardwareInformation_Block_Disk) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisks) Lt(value []*Device_Status_DeviceInfo_HardwareInformation_Block_Disk) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisks) Lte(value []*Device_Status_DeviceInfo_HardwareInformation_Block_Disk) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisks) In(values [][]*Device_Status_DeviceInfo_HardwareInformation_Block_Disk) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Block().Disks().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisks) NotIn(values [][]*Device_Status_DeviceInfo_HardwareInformation_Block_Disk) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Block().Disks().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisks) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Block().Disks().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisks) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Block().Disks().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisks) Contains(value *Device_Status_DeviceInfo_HardwareInformation_Block_Disk) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Block().Disks().FieldPath(),
		Value:     NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Block().Disks().WithItemValue(value),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisks) ContainsAnyOf(values []*Device_Status_DeviceInfo_HardwareInformation_Block_Disk) *FilterBuilder {
	pathSelector := NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Block().Disks()
	itemValues := make([]Device_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Block().Disks().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisks) ContainsAll(values []*Device_Status_DeviceInfo_HardwareInformation_Block_Disk) *FilterBuilder {
	pathSelector := NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Block().Disks()
	itemValues := make([]Device_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Block().Disks().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisks) compare(op gotenfilter.CompareOperator, value []*Device_Status_DeviceInfo_HardwareInformation_Block_Disk) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Block().Disks().WithValue(value),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisks) Name() *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksName {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksName{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisks) SizeBytes() *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksSizeBytes {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksSizeBytes{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisks) DriveType() *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksDriveType {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksDriveType{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisks) Vendor() *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksVendor {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksVendor{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisks) Model() *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksModel {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksModel{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisks) SerialNumber() *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksSerialNumber {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksSerialNumber{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisks) Wwn() *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksWwn {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksWwn{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisks) Partitions() *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksPartitions {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksPartitions{builder: b.builder}
}

type filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksName struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksName) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksName) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksName) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksName) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksName) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksName) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksName) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Block().Disks().Name().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksName) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Block().Disks().Name().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksName) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Block().Disks().Name().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksName) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Block().Disks().Name().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksName) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Block().Disks().Name().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksSizeBytes struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksSizeBytes) Eq(value int64) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksSizeBytes) Neq(value int64) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksSizeBytes) Gt(value int64) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksSizeBytes) Gte(value int64) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksSizeBytes) Lt(value int64) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksSizeBytes) Lte(value int64) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksSizeBytes) In(values []int64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Block().Disks().SizeBytes().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksSizeBytes) NotIn(values []int64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Block().Disks().SizeBytes().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksSizeBytes) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Block().Disks().SizeBytes().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksSizeBytes) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Block().Disks().SizeBytes().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksSizeBytes) compare(op gotenfilter.CompareOperator, value int64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Block().Disks().SizeBytes().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksDriveType struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksDriveType) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksDriveType) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksDriveType) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksDriveType) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksDriveType) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksDriveType) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksDriveType) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Block().Disks().DriveType().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksDriveType) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Block().Disks().DriveType().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksDriveType) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Block().Disks().DriveType().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksDriveType) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Block().Disks().DriveType().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksDriveType) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Block().Disks().DriveType().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksVendor struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksVendor) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksVendor) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksVendor) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksVendor) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksVendor) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksVendor) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksVendor) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Block().Disks().Vendor().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksVendor) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Block().Disks().Vendor().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksVendor) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Block().Disks().Vendor().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksVendor) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Block().Disks().Vendor().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksVendor) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Block().Disks().Vendor().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksModel struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksModel) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksModel) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksModel) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksModel) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksModel) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksModel) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksModel) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Block().Disks().Model().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksModel) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Block().Disks().Model().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksModel) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Block().Disks().Model().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksModel) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Block().Disks().Model().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksModel) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Block().Disks().Model().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksSerialNumber struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksSerialNumber) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksSerialNumber) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksSerialNumber) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksSerialNumber) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksSerialNumber) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksSerialNumber) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksSerialNumber) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Block().Disks().SerialNumber().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksSerialNumber) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Block().Disks().SerialNumber().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksSerialNumber) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Block().Disks().SerialNumber().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksSerialNumber) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Block().Disks().SerialNumber().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksSerialNumber) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Block().Disks().SerialNumber().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksWwn struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksWwn) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksWwn) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksWwn) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksWwn) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksWwn) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksWwn) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksWwn) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Block().Disks().Wwn().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksWwn) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Block().Disks().Wwn().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksWwn) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Block().Disks().Wwn().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksWwn) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Block().Disks().Wwn().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksWwn) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Block().Disks().Wwn().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksPartitions struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksPartitions) Eq(value []*Device_Status_DeviceInfo_HardwareInformation_Block_Disk_Partition) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksPartitions) Neq(value []*Device_Status_DeviceInfo_HardwareInformation_Block_Disk_Partition) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksPartitions) Gt(value []*Device_Status_DeviceInfo_HardwareInformation_Block_Disk_Partition) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksPartitions) Gte(value []*Device_Status_DeviceInfo_HardwareInformation_Block_Disk_Partition) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksPartitions) Lt(value []*Device_Status_DeviceInfo_HardwareInformation_Block_Disk_Partition) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksPartitions) Lte(value []*Device_Status_DeviceInfo_HardwareInformation_Block_Disk_Partition) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksPartitions) In(values [][]*Device_Status_DeviceInfo_HardwareInformation_Block_Disk_Partition) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Block().Disks().Partitions().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksPartitions) NotIn(values [][]*Device_Status_DeviceInfo_HardwareInformation_Block_Disk_Partition) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Block().Disks().Partitions().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksPartitions) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Block().Disks().Partitions().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksPartitions) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Block().Disks().Partitions().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksPartitions) Contains(value *Device_Status_DeviceInfo_HardwareInformation_Block_Disk_Partition) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Block().Disks().Partitions().FieldPath(),
		Value:     NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Block().Disks().Partitions().WithItemValue(value),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksPartitions) ContainsAnyOf(values []*Device_Status_DeviceInfo_HardwareInformation_Block_Disk_Partition) *FilterBuilder {
	pathSelector := NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Block().Disks().Partitions()
	itemValues := make([]Device_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Block().Disks().Partitions().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksPartitions) ContainsAll(values []*Device_Status_DeviceInfo_HardwareInformation_Block_Disk_Partition) *FilterBuilder {
	pathSelector := NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Block().Disks().Partitions()
	itemValues := make([]Device_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Block().Disks().Partitions().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksPartitions) compare(op gotenfilter.CompareOperator, value []*Device_Status_DeviceInfo_HardwareInformation_Block_Disk_Partition) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Block().Disks().Partitions().WithValue(value),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksPartitions) Name() *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksPartitionsName {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksPartitionsName{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksPartitions) SizeBytes() *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksPartitionsSizeBytes {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksPartitionsSizeBytes{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksPartitions) MountPoint() *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksPartitionsMountPoint {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksPartitionsMountPoint{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksPartitions) Type() *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksPartitionsType {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksPartitionsType{builder: b.builder}
}

type filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksPartitionsName struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksPartitionsName) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksPartitionsName) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksPartitionsName) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksPartitionsName) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksPartitionsName) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksPartitionsName) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksPartitionsName) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Block().Disks().Partitions().Name().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksPartitionsName) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Block().Disks().Partitions().Name().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksPartitionsName) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Block().Disks().Partitions().Name().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksPartitionsName) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Block().Disks().Partitions().Name().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksPartitionsName) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Block().Disks().Partitions().Name().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksPartitionsSizeBytes struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksPartitionsSizeBytes) Eq(value int64) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksPartitionsSizeBytes) Neq(value int64) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksPartitionsSizeBytes) Gt(value int64) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksPartitionsSizeBytes) Gte(value int64) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksPartitionsSizeBytes) Lt(value int64) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksPartitionsSizeBytes) Lte(value int64) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksPartitionsSizeBytes) In(values []int64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Block().Disks().Partitions().SizeBytes().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksPartitionsSizeBytes) NotIn(values []int64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Block().Disks().Partitions().SizeBytes().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksPartitionsSizeBytes) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Block().Disks().Partitions().SizeBytes().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksPartitionsSizeBytes) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Block().Disks().Partitions().SizeBytes().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksPartitionsSizeBytes) compare(op gotenfilter.CompareOperator, value int64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Block().Disks().Partitions().SizeBytes().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksPartitionsMountPoint struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksPartitionsMountPoint) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksPartitionsMountPoint) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksPartitionsMountPoint) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksPartitionsMountPoint) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksPartitionsMountPoint) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksPartitionsMountPoint) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksPartitionsMountPoint) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Block().Disks().Partitions().MountPoint().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksPartitionsMountPoint) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Block().Disks().Partitions().MountPoint().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksPartitionsMountPoint) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Block().Disks().Partitions().MountPoint().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksPartitionsMountPoint) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Block().Disks().Partitions().MountPoint().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksPartitionsMountPoint) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Block().Disks().Partitions().MountPoint().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksPartitionsType struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksPartitionsType) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksPartitionsType) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksPartitionsType) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksPartitionsType) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksPartitionsType) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksPartitionsType) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksPartitionsType) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Block().Disks().Partitions().Type().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksPartitionsType) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Block().Disks().Partitions().Type().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksPartitionsType) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Block().Disks().Partitions().Type().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksPartitionsType) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Block().Disks().Partitions().Type().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationBlockDisksPartitionsType) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Block().Disks().Partitions().Type().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationNetwork struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetwork) Eq(value *Device_Status_DeviceInfo_HardwareInformation_Network) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetwork) Neq(value *Device_Status_DeviceInfo_HardwareInformation_Network) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetwork) Gt(value *Device_Status_DeviceInfo_HardwareInformation_Network) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetwork) Gte(value *Device_Status_DeviceInfo_HardwareInformation_Network) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetwork) Lt(value *Device_Status_DeviceInfo_HardwareInformation_Network) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetwork) Lte(value *Device_Status_DeviceInfo_HardwareInformation_Network) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetwork) In(values []*Device_Status_DeviceInfo_HardwareInformation_Network) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Network().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetwork) NotIn(values []*Device_Status_DeviceInfo_HardwareInformation_Network) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Network().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetwork) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Network().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetwork) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Network().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetwork) compare(op gotenfilter.CompareOperator, value *Device_Status_DeviceInfo_HardwareInformation_Network) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Network().WithValue(value),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetwork) Nics() *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNics {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNics{builder: b.builder}
}

type filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNics struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNics) Eq(value []*Device_Status_DeviceInfo_HardwareInformation_Network_NIC) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNics) Neq(value []*Device_Status_DeviceInfo_HardwareInformation_Network_NIC) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNics) Gt(value []*Device_Status_DeviceInfo_HardwareInformation_Network_NIC) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNics) Gte(value []*Device_Status_DeviceInfo_HardwareInformation_Network_NIC) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNics) Lt(value []*Device_Status_DeviceInfo_HardwareInformation_Network_NIC) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNics) Lte(value []*Device_Status_DeviceInfo_HardwareInformation_Network_NIC) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNics) In(values [][]*Device_Status_DeviceInfo_HardwareInformation_Network_NIC) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Network().Nics().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNics) NotIn(values [][]*Device_Status_DeviceInfo_HardwareInformation_Network_NIC) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Network().Nics().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNics) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Network().Nics().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNics) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Network().Nics().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNics) Contains(value *Device_Status_DeviceInfo_HardwareInformation_Network_NIC) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Network().Nics().FieldPath(),
		Value:     NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Network().Nics().WithItemValue(value),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNics) ContainsAnyOf(values []*Device_Status_DeviceInfo_HardwareInformation_Network_NIC) *FilterBuilder {
	pathSelector := NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Network().Nics()
	itemValues := make([]Device_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Network().Nics().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNics) ContainsAll(values []*Device_Status_DeviceInfo_HardwareInformation_Network_NIC) *FilterBuilder {
	pathSelector := NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Network().Nics()
	itemValues := make([]Device_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Network().Nics().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNics) compare(op gotenfilter.CompareOperator, value []*Device_Status_DeviceInfo_HardwareInformation_Network_NIC) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Network().Nics().WithValue(value),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNics) Name() *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsName {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsName{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNics) MacAddress() *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsMacAddress {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsMacAddress{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNics) Virtual() *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsVirtual {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsVirtual{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNics) Description() *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsDescription {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsDescription{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNics) ProductName() *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsProductName {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsProductName{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNics) Vendor() *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsVendor {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsVendor{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNics) Subvendor() *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsSubvendor {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsSubvendor{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNics) Setting() *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsSetting {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsSetting{builder: b.builder}
}

type filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsName struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsName) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsName) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsName) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsName) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsName) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsName) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsName) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Network().Nics().Name().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsName) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Network().Nics().Name().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsName) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Network().Nics().Name().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsName) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Network().Nics().Name().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsName) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Network().Nics().Name().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsMacAddress struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsMacAddress) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsMacAddress) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsMacAddress) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsMacAddress) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsMacAddress) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsMacAddress) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsMacAddress) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Network().Nics().MacAddress().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsMacAddress) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Network().Nics().MacAddress().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsMacAddress) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Network().Nics().MacAddress().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsMacAddress) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Network().Nics().MacAddress().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsMacAddress) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Network().Nics().MacAddress().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsVirtual struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsVirtual) Eq(value bool) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsVirtual) Neq(value bool) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsVirtual) Gt(value bool) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsVirtual) Gte(value bool) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsVirtual) Lt(value bool) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsVirtual) Lte(value bool) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsVirtual) In(values []bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Network().Nics().Virtual().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsVirtual) NotIn(values []bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Network().Nics().Virtual().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsVirtual) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Network().Nics().Virtual().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsVirtual) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Network().Nics().Virtual().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsVirtual) compare(op gotenfilter.CompareOperator, value bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Network().Nics().Virtual().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsDescription struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsDescription) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsDescription) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsDescription) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsDescription) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsDescription) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsDescription) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsDescription) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Network().Nics().Description().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsDescription) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Network().Nics().Description().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsDescription) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Network().Nics().Description().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsDescription) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Network().Nics().Description().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsDescription) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Network().Nics().Description().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsProductName struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsProductName) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsProductName) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsProductName) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsProductName) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsProductName) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsProductName) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsProductName) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Network().Nics().ProductName().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsProductName) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Network().Nics().ProductName().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsProductName) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Network().Nics().ProductName().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsProductName) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Network().Nics().ProductName().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsProductName) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Network().Nics().ProductName().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsVendor struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsVendor) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsVendor) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsVendor) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsVendor) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsVendor) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsVendor) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsVendor) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Network().Nics().Vendor().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsVendor) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Network().Nics().Vendor().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsVendor) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Network().Nics().Vendor().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsVendor) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Network().Nics().Vendor().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsVendor) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Network().Nics().Vendor().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsSubvendor struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsSubvendor) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsSubvendor) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsSubvendor) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsSubvendor) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsSubvendor) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsSubvendor) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsSubvendor) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Network().Nics().Subvendor().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsSubvendor) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Network().Nics().Subvendor().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsSubvendor) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Network().Nics().Subvendor().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsSubvendor) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Network().Nics().Subvendor().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsSubvendor) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Network().Nics().Subvendor().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsSetting struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsSetting) Eq(value map[string]string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsSetting) Neq(value map[string]string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsSetting) Gt(value map[string]string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsSetting) Gte(value map[string]string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsSetting) Lt(value map[string]string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsSetting) Lte(value map[string]string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsSetting) In(values []map[string]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Network().Nics().Setting().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsSetting) NotIn(values []map[string]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Network().Nics().Setting().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsSetting) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Network().Nics().Setting().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsSetting) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Network().Nics().Setting().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsSetting) compare(op gotenfilter.CompareOperator, value map[string]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Network().Nics().Setting().WithValue(value),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsSetting) WithKey(key string) *mapFilterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsSetting {
	return &mapFilterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsSetting{builder: b.builder, key: key}
}

type mapFilterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsSetting struct {
	builder *FilterBuilder
	key     string
}

func (b *mapFilterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsSetting) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *mapFilterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsSetting) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *mapFilterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsSetting) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *mapFilterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsSetting) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *mapFilterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsSetting) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *mapFilterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsSetting) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *mapFilterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsSetting) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Network().Nics().Setting().WithKey(b.key).WithArrayOfValues(values),
	})
}

func (b *mapFilterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsSetting) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Network().Nics().Setting().WithKey(b.key).WithArrayOfValues(values),
	})
}

func (b *mapFilterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsSetting) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Network().Nics().Setting().WithKey(b.key).FieldPath(),
	})
}

func (b *mapFilterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsSetting) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Network().Nics().Setting().WithKey(b.key).FieldPath(),
	})
}

func (b *mapFilterCndBuilderStatusDeviceInfoHardwareInformationNetworkNicsSetting) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Network().Nics().Setting().WithKey(b.key).WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationGpu struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpu) Eq(value *Device_Status_DeviceInfo_HardwareInformation_GPU) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpu) Neq(value *Device_Status_DeviceInfo_HardwareInformation_GPU) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpu) Gt(value *Device_Status_DeviceInfo_HardwareInformation_GPU) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpu) Gte(value *Device_Status_DeviceInfo_HardwareInformation_GPU) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpu) Lt(value *Device_Status_DeviceInfo_HardwareInformation_GPU) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpu) Lte(value *Device_Status_DeviceInfo_HardwareInformation_GPU) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpu) In(values []*Device_Status_DeviceInfo_HardwareInformation_GPU) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Gpu().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpu) NotIn(values []*Device_Status_DeviceInfo_HardwareInformation_GPU) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Gpu().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpu) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Gpu().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpu) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Gpu().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpu) compare(op gotenfilter.CompareOperator, value *Device_Status_DeviceInfo_HardwareInformation_GPU) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Gpu().WithValue(value),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpu) GraphicCards() *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCards {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCards{builder: b.builder}
}

type filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCards struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCards) Eq(value []*Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCards) Neq(value []*Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCards) Gt(value []*Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCards) Gte(value []*Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCards) Lt(value []*Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCards) Lte(value []*Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCards) In(values [][]*Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Gpu().GraphicCards().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCards) NotIn(values [][]*Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Gpu().GraphicCards().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCards) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Gpu().GraphicCards().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCards) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Gpu().GraphicCards().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCards) Contains(value *Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Gpu().GraphicCards().FieldPath(),
		Value:     NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Gpu().GraphicCards().WithItemValue(value),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCards) ContainsAnyOf(values []*Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard) *FilterBuilder {
	pathSelector := NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Gpu().GraphicCards()
	itemValues := make([]Device_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Gpu().GraphicCards().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCards) ContainsAll(values []*Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard) *FilterBuilder {
	pathSelector := NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Gpu().GraphicCards()
	itemValues := make([]Device_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Gpu().GraphicCards().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCards) compare(op gotenfilter.CompareOperator, value []*Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Gpu().GraphicCards().WithValue(value),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCards) Index() *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsIndex {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsIndex{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCards) Device() *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsDevice {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsDevice{builder: b.builder}
}

type filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsIndex struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsIndex) Eq(value int64) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsIndex) Neq(value int64) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsIndex) Gt(value int64) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsIndex) Gte(value int64) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsIndex) Lt(value int64) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsIndex) Lte(value int64) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsIndex) In(values []int64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Gpu().GraphicCards().Index().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsIndex) NotIn(values []int64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Gpu().GraphicCards().Index().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsIndex) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Gpu().GraphicCards().Index().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsIndex) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Gpu().GraphicCards().Index().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsIndex) compare(op gotenfilter.CompareOperator, value int64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Gpu().GraphicCards().Index().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsDevice struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsDevice) Eq(value *Device_Status_DeviceInfo_HardwareInformation_PCIDevice) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsDevice) Neq(value *Device_Status_DeviceInfo_HardwareInformation_PCIDevice) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsDevice) Gt(value *Device_Status_DeviceInfo_HardwareInformation_PCIDevice) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsDevice) Gte(value *Device_Status_DeviceInfo_HardwareInformation_PCIDevice) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsDevice) Lt(value *Device_Status_DeviceInfo_HardwareInformation_PCIDevice) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsDevice) Lte(value *Device_Status_DeviceInfo_HardwareInformation_PCIDevice) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsDevice) In(values []*Device_Status_DeviceInfo_HardwareInformation_PCIDevice) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Gpu().GraphicCards().Device().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsDevice) NotIn(values []*Device_Status_DeviceInfo_HardwareInformation_PCIDevice) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Gpu().GraphicCards().Device().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsDevice) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Gpu().GraphicCards().Device().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsDevice) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Gpu().GraphicCards().Device().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsDevice) compare(op gotenfilter.CompareOperator, value *Device_Status_DeviceInfo_HardwareInformation_PCIDevice) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Gpu().GraphicCards().Device().WithValue(value),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsDevice) Address() *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsDeviceAddress {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsDeviceAddress{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsDevice) Vendor() *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsDeviceVendor {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsDeviceVendor{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsDevice) Product() *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsDeviceProduct {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsDeviceProduct{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsDevice) Name() *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsDeviceName {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsDeviceName{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsDevice) Subvendor() *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsDeviceSubvendor {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsDeviceSubvendor{builder: b.builder}
}

type filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsDeviceAddress struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsDeviceAddress) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsDeviceAddress) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsDeviceAddress) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsDeviceAddress) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsDeviceAddress) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsDeviceAddress) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsDeviceAddress) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Gpu().GraphicCards().Device().Address().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsDeviceAddress) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Gpu().GraphicCards().Device().Address().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsDeviceAddress) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Gpu().GraphicCards().Device().Address().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsDeviceAddress) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Gpu().GraphicCards().Device().Address().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsDeviceAddress) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Gpu().GraphicCards().Device().Address().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsDeviceVendor struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsDeviceVendor) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsDeviceVendor) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsDeviceVendor) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsDeviceVendor) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsDeviceVendor) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsDeviceVendor) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsDeviceVendor) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Gpu().GraphicCards().Device().Vendor().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsDeviceVendor) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Gpu().GraphicCards().Device().Vendor().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsDeviceVendor) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Gpu().GraphicCards().Device().Vendor().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsDeviceVendor) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Gpu().GraphicCards().Device().Vendor().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsDeviceVendor) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Gpu().GraphicCards().Device().Vendor().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsDeviceProduct struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsDeviceProduct) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsDeviceProduct) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsDeviceProduct) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsDeviceProduct) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsDeviceProduct) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsDeviceProduct) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsDeviceProduct) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Gpu().GraphicCards().Device().Product().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsDeviceProduct) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Gpu().GraphicCards().Device().Product().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsDeviceProduct) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Gpu().GraphicCards().Device().Product().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsDeviceProduct) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Gpu().GraphicCards().Device().Product().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsDeviceProduct) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Gpu().GraphicCards().Device().Product().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsDeviceName struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsDeviceName) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsDeviceName) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsDeviceName) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsDeviceName) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsDeviceName) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsDeviceName) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsDeviceName) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Gpu().GraphicCards().Device().Name().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsDeviceName) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Gpu().GraphicCards().Device().Name().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsDeviceName) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Gpu().GraphicCards().Device().Name().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsDeviceName) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Gpu().GraphicCards().Device().Name().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsDeviceName) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Gpu().GraphicCards().Device().Name().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsDeviceSubvendor struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsDeviceSubvendor) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsDeviceSubvendor) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsDeviceSubvendor) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsDeviceSubvendor) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsDeviceSubvendor) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsDeviceSubvendor) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsDeviceSubvendor) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Gpu().GraphicCards().Device().Subvendor().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsDeviceSubvendor) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Gpu().GraphicCards().Device().Subvendor().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsDeviceSubvendor) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Gpu().GraphicCards().Device().Subvendor().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsDeviceSubvendor) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Gpu().GraphicCards().Device().Subvendor().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationGpuGraphicCardsDeviceSubvendor) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().Gpu().GraphicCards().Device().Subvendor().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfo struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfo) Eq(value *Device_Status_DeviceInfo_HardwareInformation_MemoryInfo) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfo) Neq(value *Device_Status_DeviceInfo_HardwareInformation_MemoryInfo) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfo) Gt(value *Device_Status_DeviceInfo_HardwareInformation_MemoryInfo) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfo) Gte(value *Device_Status_DeviceInfo_HardwareInformation_MemoryInfo) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfo) Lt(value *Device_Status_DeviceInfo_HardwareInformation_MemoryInfo) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfo) Lte(value *Device_Status_DeviceInfo_HardwareInformation_MemoryInfo) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfo) In(values []*Device_Status_DeviceInfo_HardwareInformation_MemoryInfo) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfo) NotIn(values []*Device_Status_DeviceInfo_HardwareInformation_MemoryInfo) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfo) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfo) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfo) compare(op gotenfilter.CompareOperator, value *Device_Status_DeviceInfo_HardwareInformation_MemoryInfo) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().WithValue(value),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfo) Description() *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoDescription {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoDescription{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfo) SizeBytes() *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoSizeBytes {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoSizeBytes{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfo) MemoryBanks() *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanks {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanks{builder: b.builder}
}

type filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoDescription struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoDescription) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoDescription) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoDescription) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoDescription) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoDescription) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoDescription) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoDescription) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().Description().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoDescription) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().Description().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoDescription) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().Description().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoDescription) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().Description().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoDescription) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().Description().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoSizeBytes struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoSizeBytes) Eq(value int64) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoSizeBytes) Neq(value int64) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoSizeBytes) Gt(value int64) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoSizeBytes) Gte(value int64) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoSizeBytes) Lt(value int64) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoSizeBytes) Lte(value int64) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoSizeBytes) In(values []int64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().SizeBytes().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoSizeBytes) NotIn(values []int64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().SizeBytes().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoSizeBytes) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().SizeBytes().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoSizeBytes) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().SizeBytes().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoSizeBytes) compare(op gotenfilter.CompareOperator, value int64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().SizeBytes().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanks struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanks) Eq(value []*Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_MemoryBank) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanks) Neq(value []*Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_MemoryBank) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanks) Gt(value []*Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_MemoryBank) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanks) Gte(value []*Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_MemoryBank) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanks) Lt(value []*Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_MemoryBank) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanks) Lte(value []*Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_MemoryBank) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanks) In(values [][]*Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_MemoryBank) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().MemoryBanks().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanks) NotIn(values [][]*Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_MemoryBank) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().MemoryBanks().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanks) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().MemoryBanks().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanks) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().MemoryBanks().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanks) Contains(value *Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_MemoryBank) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().MemoryBanks().FieldPath(),
		Value:     NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().MemoryBanks().WithItemValue(value),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanks) ContainsAnyOf(values []*Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_MemoryBank) *FilterBuilder {
	pathSelector := NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().MemoryBanks()
	itemValues := make([]Device_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().MemoryBanks().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanks) ContainsAll(values []*Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_MemoryBank) *FilterBuilder {
	pathSelector := NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().MemoryBanks()
	itemValues := make([]Device_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().MemoryBanks().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanks) compare(op gotenfilter.CompareOperator, value []*Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_MemoryBank) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().MemoryBanks().WithValue(value),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanks) Description() *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksDescription {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksDescription{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanks) Product() *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksProduct {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksProduct{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanks) Vendor() *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksVendor {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksVendor{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanks) Serial() *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksSerial {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksSerial{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanks) Slot() *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksSlot {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksSlot{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanks) SizeBytes() *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksSizeBytes {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksSizeBytes{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanks) FrequencyHz() *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksFrequencyHz {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksFrequencyHz{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanks) WidthBits() *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksWidthBits {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksWidthBits{builder: b.builder}
}

type filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksDescription struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksDescription) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksDescription) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksDescription) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksDescription) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksDescription) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksDescription) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksDescription) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().MemoryBanks().Description().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksDescription) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().MemoryBanks().Description().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksDescription) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().MemoryBanks().Description().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksDescription) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().MemoryBanks().Description().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksDescription) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().MemoryBanks().Description().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksProduct struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksProduct) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksProduct) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksProduct) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksProduct) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksProduct) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksProduct) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksProduct) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().MemoryBanks().Product().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksProduct) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().MemoryBanks().Product().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksProduct) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().MemoryBanks().Product().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksProduct) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().MemoryBanks().Product().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksProduct) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().MemoryBanks().Product().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksVendor struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksVendor) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksVendor) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksVendor) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksVendor) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksVendor) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksVendor) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksVendor) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().MemoryBanks().Vendor().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksVendor) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().MemoryBanks().Vendor().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksVendor) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().MemoryBanks().Vendor().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksVendor) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().MemoryBanks().Vendor().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksVendor) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().MemoryBanks().Vendor().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksSerial struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksSerial) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksSerial) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksSerial) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksSerial) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksSerial) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksSerial) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksSerial) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().MemoryBanks().Serial().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksSerial) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().MemoryBanks().Serial().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksSerial) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().MemoryBanks().Serial().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksSerial) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().MemoryBanks().Serial().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksSerial) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().MemoryBanks().Serial().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksSlot struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksSlot) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksSlot) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksSlot) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksSlot) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksSlot) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksSlot) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksSlot) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().MemoryBanks().Slot().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksSlot) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().MemoryBanks().Slot().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksSlot) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().MemoryBanks().Slot().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksSlot) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().MemoryBanks().Slot().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksSlot) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().MemoryBanks().Slot().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksSizeBytes struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksSizeBytes) Eq(value int64) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksSizeBytes) Neq(value int64) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksSizeBytes) Gt(value int64) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksSizeBytes) Gte(value int64) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksSizeBytes) Lt(value int64) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksSizeBytes) Lte(value int64) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksSizeBytes) In(values []int64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().MemoryBanks().SizeBytes().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksSizeBytes) NotIn(values []int64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().MemoryBanks().SizeBytes().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksSizeBytes) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().MemoryBanks().SizeBytes().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksSizeBytes) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().MemoryBanks().SizeBytes().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksSizeBytes) compare(op gotenfilter.CompareOperator, value int64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().MemoryBanks().SizeBytes().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksFrequencyHz struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksFrequencyHz) Eq(value int64) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksFrequencyHz) Neq(value int64) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksFrequencyHz) Gt(value int64) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksFrequencyHz) Gte(value int64) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksFrequencyHz) Lt(value int64) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksFrequencyHz) Lte(value int64) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksFrequencyHz) In(values []int64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().MemoryBanks().FrequencyHz().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksFrequencyHz) NotIn(values []int64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().MemoryBanks().FrequencyHz().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksFrequencyHz) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().MemoryBanks().FrequencyHz().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksFrequencyHz) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().MemoryBanks().FrequencyHz().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksFrequencyHz) compare(op gotenfilter.CompareOperator, value int64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().MemoryBanks().FrequencyHz().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksWidthBits struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksWidthBits) Eq(value int32) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksWidthBits) Neq(value int32) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksWidthBits) Gt(value int32) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksWidthBits) Gte(value int32) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksWidthBits) Lt(value int32) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksWidthBits) Lte(value int32) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksWidthBits) In(values []int32) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().MemoryBanks().WidthBits().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksWidthBits) NotIn(values []int32) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().MemoryBanks().WidthBits().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksWidthBits) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().MemoryBanks().WidthBits().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksWidthBits) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().MemoryBanks().WidthBits().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryBanksWidthBits) compare(op gotenfilter.CompareOperator, value int32) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().MemoryBanks().WidthBits().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfo struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfo) Eq(value *Device_Status_DeviceInfo_HardwareInformation_HailoInfo) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfo) Neq(value *Device_Status_DeviceInfo_HardwareInformation_HailoInfo) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfo) Gt(value *Device_Status_DeviceInfo_HardwareInformation_HailoInfo) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfo) Gte(value *Device_Status_DeviceInfo_HardwareInformation_HailoInfo) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfo) Lt(value *Device_Status_DeviceInfo_HardwareInformation_HailoInfo) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfo) Lte(value *Device_Status_DeviceInfo_HardwareInformation_HailoInfo) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfo) In(values []*Device_Status_DeviceInfo_HardwareInformation_HailoInfo) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().HailoInfo().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfo) NotIn(values []*Device_Status_DeviceInfo_HardwareInformation_HailoInfo) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().HailoInfo().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfo) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().HailoInfo().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfo) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().HailoInfo().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfo) compare(op gotenfilter.CompareOperator, value *Device_Status_DeviceInfo_HardwareInformation_HailoInfo) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().HailoInfo().WithValue(value),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfo) Status() *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoStatus {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoStatus{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfo) CliVersion() *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoCliVersion {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoCliVersion{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfo) Modules() *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModules {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModules{builder: b.builder}
}

type filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoStatus struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoStatus) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoStatus) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoStatus) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoStatus) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoStatus) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoStatus) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoStatus) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().HailoInfo().Status().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoStatus) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().HailoInfo().Status().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoStatus) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().HailoInfo().Status().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoStatus) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().HailoInfo().Status().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoStatus) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().HailoInfo().Status().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoCliVersion struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoCliVersion) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoCliVersion) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoCliVersion) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoCliVersion) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoCliVersion) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoCliVersion) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoCliVersion) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().HailoInfo().CliVersion().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoCliVersion) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().HailoInfo().CliVersion().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoCliVersion) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().HailoInfo().CliVersion().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoCliVersion) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().HailoInfo().CliVersion().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoCliVersion) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().HailoInfo().CliVersion().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModules struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModules) Eq(value []*Device_Status_DeviceInfo_HardwareInformation_HailoInfo_HailoModuleInfo) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModules) Neq(value []*Device_Status_DeviceInfo_HardwareInformation_HailoInfo_HailoModuleInfo) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModules) Gt(value []*Device_Status_DeviceInfo_HardwareInformation_HailoInfo_HailoModuleInfo) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModules) Gte(value []*Device_Status_DeviceInfo_HardwareInformation_HailoInfo_HailoModuleInfo) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModules) Lt(value []*Device_Status_DeviceInfo_HardwareInformation_HailoInfo_HailoModuleInfo) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModules) Lte(value []*Device_Status_DeviceInfo_HardwareInformation_HailoInfo_HailoModuleInfo) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModules) In(values [][]*Device_Status_DeviceInfo_HardwareInformation_HailoInfo_HailoModuleInfo) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().HailoInfo().Modules().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModules) NotIn(values [][]*Device_Status_DeviceInfo_HardwareInformation_HailoInfo_HailoModuleInfo) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().HailoInfo().Modules().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModules) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().HailoInfo().Modules().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModules) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().HailoInfo().Modules().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModules) Contains(value *Device_Status_DeviceInfo_HardwareInformation_HailoInfo_HailoModuleInfo) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().HailoInfo().Modules().FieldPath(),
		Value:     NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().HailoInfo().Modules().WithItemValue(value),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModules) ContainsAnyOf(values []*Device_Status_DeviceInfo_HardwareInformation_HailoInfo_HailoModuleInfo) *FilterBuilder {
	pathSelector := NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().HailoInfo().Modules()
	itemValues := make([]Device_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().HailoInfo().Modules().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModules) ContainsAll(values []*Device_Status_DeviceInfo_HardwareInformation_HailoInfo_HailoModuleInfo) *FilterBuilder {
	pathSelector := NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().HailoInfo().Modules()
	itemValues := make([]Device_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().HailoInfo().Modules().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModules) compare(op gotenfilter.CompareOperator, value []*Device_Status_DeviceInfo_HardwareInformation_HailoInfo_HailoModuleInfo) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().HailoInfo().Modules().WithValue(value),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModules) DevId() *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesDevId {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesDevId{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModules) ControlProtoVersion() *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesControlProtoVersion {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesControlProtoVersion{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModules) FirmwareVersion() *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesFirmwareVersion {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesFirmwareVersion{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModules) LoggerVersion() *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesLoggerVersion {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesLoggerVersion{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModules) BoardName() *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesBoardName {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesBoardName{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModules) SerialNumber() *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesSerialNumber {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesSerialNumber{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModules) PartNumber() *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesPartNumber {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesPartNumber{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModules) ProductName() *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesProductName {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesProductName{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModules) NeuralNetworkCoreClockRate() *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesNeuralNetworkCoreClockRate {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesNeuralNetworkCoreClockRate{builder: b.builder}
}

type filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesDevId struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesDevId) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesDevId) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesDevId) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesDevId) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesDevId) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesDevId) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesDevId) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().HailoInfo().Modules().DevId().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesDevId) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().HailoInfo().Modules().DevId().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesDevId) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().HailoInfo().Modules().DevId().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesDevId) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().HailoInfo().Modules().DevId().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesDevId) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().HailoInfo().Modules().DevId().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesControlProtoVersion struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesControlProtoVersion) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesControlProtoVersion) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesControlProtoVersion) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesControlProtoVersion) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesControlProtoVersion) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesControlProtoVersion) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesControlProtoVersion) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().HailoInfo().Modules().ControlProtoVersion().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesControlProtoVersion) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().HailoInfo().Modules().ControlProtoVersion().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesControlProtoVersion) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().HailoInfo().Modules().ControlProtoVersion().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesControlProtoVersion) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().HailoInfo().Modules().ControlProtoVersion().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesControlProtoVersion) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().HailoInfo().Modules().ControlProtoVersion().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesFirmwareVersion struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesFirmwareVersion) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesFirmwareVersion) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesFirmwareVersion) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesFirmwareVersion) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesFirmwareVersion) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesFirmwareVersion) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesFirmwareVersion) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().HailoInfo().Modules().FirmwareVersion().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesFirmwareVersion) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().HailoInfo().Modules().FirmwareVersion().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesFirmwareVersion) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().HailoInfo().Modules().FirmwareVersion().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesFirmwareVersion) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().HailoInfo().Modules().FirmwareVersion().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesFirmwareVersion) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().HailoInfo().Modules().FirmwareVersion().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesLoggerVersion struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesLoggerVersion) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesLoggerVersion) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesLoggerVersion) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesLoggerVersion) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesLoggerVersion) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesLoggerVersion) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesLoggerVersion) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().HailoInfo().Modules().LoggerVersion().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesLoggerVersion) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().HailoInfo().Modules().LoggerVersion().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesLoggerVersion) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().HailoInfo().Modules().LoggerVersion().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesLoggerVersion) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().HailoInfo().Modules().LoggerVersion().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesLoggerVersion) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().HailoInfo().Modules().LoggerVersion().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesBoardName struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesBoardName) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesBoardName) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesBoardName) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesBoardName) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesBoardName) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesBoardName) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesBoardName) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().HailoInfo().Modules().BoardName().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesBoardName) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().HailoInfo().Modules().BoardName().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesBoardName) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().HailoInfo().Modules().BoardName().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesBoardName) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().HailoInfo().Modules().BoardName().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesBoardName) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().HailoInfo().Modules().BoardName().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesSerialNumber struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesSerialNumber) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesSerialNumber) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesSerialNumber) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesSerialNumber) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesSerialNumber) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesSerialNumber) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesSerialNumber) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().HailoInfo().Modules().SerialNumber().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesSerialNumber) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().HailoInfo().Modules().SerialNumber().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesSerialNumber) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().HailoInfo().Modules().SerialNumber().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesSerialNumber) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().HailoInfo().Modules().SerialNumber().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesSerialNumber) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().HailoInfo().Modules().SerialNumber().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesPartNumber struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesPartNumber) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesPartNumber) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesPartNumber) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesPartNumber) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesPartNumber) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesPartNumber) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesPartNumber) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().HailoInfo().Modules().PartNumber().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesPartNumber) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().HailoInfo().Modules().PartNumber().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesPartNumber) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().HailoInfo().Modules().PartNumber().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesPartNumber) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().HailoInfo().Modules().PartNumber().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesPartNumber) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().HailoInfo().Modules().PartNumber().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesProductName struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesProductName) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesProductName) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesProductName) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesProductName) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesProductName) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesProductName) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesProductName) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().HailoInfo().Modules().ProductName().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesProductName) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().HailoInfo().Modules().ProductName().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesProductName) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().HailoInfo().Modules().ProductName().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesProductName) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().HailoInfo().Modules().ProductName().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesProductName) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().HailoInfo().Modules().ProductName().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesNeuralNetworkCoreClockRate struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesNeuralNetworkCoreClockRate) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesNeuralNetworkCoreClockRate) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesNeuralNetworkCoreClockRate) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesNeuralNetworkCoreClockRate) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesNeuralNetworkCoreClockRate) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesNeuralNetworkCoreClockRate) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesNeuralNetworkCoreClockRate) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().HailoInfo().Modules().NeuralNetworkCoreClockRate().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesNeuralNetworkCoreClockRate) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().HailoInfo().Modules().NeuralNetworkCoreClockRate().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesNeuralNetworkCoreClockRate) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().HailoInfo().Modules().NeuralNetworkCoreClockRate().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesNeuralNetworkCoreClockRate) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().HailoInfo().Modules().NeuralNetworkCoreClockRate().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationHailoInfoModulesNeuralNetworkCoreClockRate) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().HailoInfo().Modules().NeuralNetworkCoreClockRate().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfo struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfo) Eq(value *Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfo) Neq(value *Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfo) Gt(value *Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfo) Gte(value *Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfo) Lt(value *Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfo) Lte(value *Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfo) In(values []*Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().NvidiaInfo().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfo) NotIn(values []*Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().NvidiaInfo().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfo) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().NvidiaInfo().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfo) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().NvidiaInfo().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfo) compare(op gotenfilter.CompareOperator, value *Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().NvidiaInfo().WithValue(value),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfo) Status() *filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfoStatus {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfoStatus{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfo) DriverVersion() *filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfoDriverVersion {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfoDriverVersion{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfo) CudaVersion() *filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfoCudaVersion {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfoCudaVersion{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfo) Gpus() *filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfoGpus {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfoGpus{builder: b.builder}
}

type filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfoStatus struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfoStatus) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfoStatus) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfoStatus) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfoStatus) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfoStatus) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfoStatus) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfoStatus) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().NvidiaInfo().Status().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfoStatus) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().NvidiaInfo().Status().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfoStatus) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().NvidiaInfo().Status().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfoStatus) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().NvidiaInfo().Status().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfoStatus) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().NvidiaInfo().Status().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfoDriverVersion struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfoDriverVersion) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfoDriverVersion) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfoDriverVersion) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfoDriverVersion) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfoDriverVersion) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfoDriverVersion) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfoDriverVersion) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().NvidiaInfo().DriverVersion().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfoDriverVersion) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().NvidiaInfo().DriverVersion().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfoDriverVersion) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().NvidiaInfo().DriverVersion().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfoDriverVersion) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().NvidiaInfo().DriverVersion().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfoDriverVersion) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().NvidiaInfo().DriverVersion().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfoCudaVersion struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfoCudaVersion) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfoCudaVersion) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfoCudaVersion) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfoCudaVersion) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfoCudaVersion) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfoCudaVersion) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfoCudaVersion) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().NvidiaInfo().CudaVersion().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfoCudaVersion) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().NvidiaInfo().CudaVersion().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfoCudaVersion) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().NvidiaInfo().CudaVersion().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfoCudaVersion) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().NvidiaInfo().CudaVersion().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfoCudaVersion) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().NvidiaInfo().CudaVersion().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfoGpus struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfoGpus) Eq(value []*Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo_GpuInfo) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfoGpus) Neq(value []*Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo_GpuInfo) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfoGpus) Gt(value []*Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo_GpuInfo) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfoGpus) Gte(value []*Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo_GpuInfo) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfoGpus) Lt(value []*Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo_GpuInfo) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfoGpus) Lte(value []*Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo_GpuInfo) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfoGpus) In(values [][]*Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo_GpuInfo) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().NvidiaInfo().Gpus().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfoGpus) NotIn(values [][]*Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo_GpuInfo) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().NvidiaInfo().Gpus().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfoGpus) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().NvidiaInfo().Gpus().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfoGpus) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().NvidiaInfo().Gpus().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfoGpus) Contains(value *Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo_GpuInfo) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().NvidiaInfo().Gpus().FieldPath(),
		Value:     NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().NvidiaInfo().Gpus().WithItemValue(value),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfoGpus) ContainsAnyOf(values []*Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo_GpuInfo) *FilterBuilder {
	pathSelector := NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().NvidiaInfo().Gpus()
	itemValues := make([]Device_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().NvidiaInfo().Gpus().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfoGpus) ContainsAll(values []*Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo_GpuInfo) *FilterBuilder {
	pathSelector := NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().NvidiaInfo().Gpus()
	itemValues := make([]Device_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().NvidiaInfo().Gpus().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfoGpus) compare(op gotenfilter.CompareOperator, value []*Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo_GpuInfo) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().NvidiaInfo().Gpus().WithValue(value),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfoGpus) Id() *filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfoGpusId {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfoGpusId{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfoGpus) ProductName() *filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfoGpusProductName {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfoGpusProductName{builder: b.builder}
}

type filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfoGpusId struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfoGpusId) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfoGpusId) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfoGpusId) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfoGpusId) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfoGpusId) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfoGpusId) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfoGpusId) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().NvidiaInfo().Gpus().Id().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfoGpusId) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().NvidiaInfo().Gpus().Id().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfoGpusId) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().NvidiaInfo().Gpus().Id().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfoGpusId) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().NvidiaInfo().Gpus().Id().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfoGpusId) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().NvidiaInfo().Gpus().Id().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfoGpusProductName struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfoGpusProductName) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfoGpusProductName) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfoGpusProductName) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfoGpusProductName) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfoGpusProductName) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfoGpusProductName) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfoGpusProductName) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().NvidiaInfo().Gpus().ProductName().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfoGpusProductName) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().NvidiaInfo().Gpus().ProductName().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfoGpusProductName) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().NvidiaInfo().Gpus().ProductName().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfoGpusProductName) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().NvidiaInfo().Gpus().ProductName().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationNvidiaInfoGpusProductName) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().NvidiaInfo().Gpus().ProductName().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatus struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatus) Eq(value []*Device_Status_DeviceInfo_HardwareInformation_ModemStatus) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatus) Neq(value []*Device_Status_DeviceInfo_HardwareInformation_ModemStatus) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatus) Gt(value []*Device_Status_DeviceInfo_HardwareInformation_ModemStatus) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatus) Gte(value []*Device_Status_DeviceInfo_HardwareInformation_ModemStatus) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatus) Lt(value []*Device_Status_DeviceInfo_HardwareInformation_ModemStatus) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatus) Lte(value []*Device_Status_DeviceInfo_HardwareInformation_ModemStatus) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatus) In(values [][]*Device_Status_DeviceInfo_HardwareInformation_ModemStatus) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatus) NotIn(values [][]*Device_Status_DeviceInfo_HardwareInformation_ModemStatus) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatus) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatus) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatus) Contains(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().FieldPath(),
		Value:     NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().WithItemValue(value),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatus) ContainsAnyOf(values []*Device_Status_DeviceInfo_HardwareInformation_ModemStatus) *FilterBuilder {
	pathSelector := NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus()
	itemValues := make([]Device_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatus) ContainsAll(values []*Device_Status_DeviceInfo_HardwareInformation_ModemStatus) *FilterBuilder {
	pathSelector := NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus()
	itemValues := make([]Device_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatus) compare(op gotenfilter.CompareOperator, value []*Device_Status_DeviceInfo_HardwareInformation_ModemStatus) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().WithValue(value),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatus) Modem() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModem {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModem{builder: b.builder}
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModem struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModem) Eq(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModem) Neq(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModem) Gt(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModem) Gte(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModem) Lt(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModem) Lte(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModem) In(values []*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModem) NotIn(values []*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModem) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModem) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModem) compare(op gotenfilter.CompareOperator, value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().WithValue(value),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModem) ThreeGPp() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPp {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPp{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModem) Cdma() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdma {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdma{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModem) DbusPath() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemDbusPath {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemDbusPath{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModem) Generic() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGeneric {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGeneric{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModem) SimStatus() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSimStatus {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSimStatus{builder: b.builder}
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPp struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPp) Eq(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_ThreeGpp) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPp) Neq(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_ThreeGpp) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPp) Gt(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_ThreeGpp) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPp) Gte(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_ThreeGpp) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPp) Lt(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_ThreeGpp) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPp) Lte(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_ThreeGpp) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPp) In(values []*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_ThreeGpp) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPp) NotIn(values []*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_ThreeGpp) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPp) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPp) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPp) compare(op gotenfilter.CompareOperator, value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_ThreeGpp) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().WithValue(value),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPp) FivegNr() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpFivegNr {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpFivegNr{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPp) EnabledLocks() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEnabledLocks {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEnabledLocks{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPp) Eps() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEps {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEps{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPp) Imei() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpImei {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpImei{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPp) OperatorCode() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpOperatorCode {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpOperatorCode{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPp) OperatorName() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpOperatorName {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpOperatorName{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPp) PacketServiceState() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpPacketServiceState {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpPacketServiceState{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPp) Pco() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpPco {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpPco{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPp) RegistrationState() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpRegistrationState {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpRegistrationState{builder: b.builder}
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpFivegNr struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpFivegNr) Eq(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FiveGNr) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpFivegNr) Neq(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FiveGNr) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpFivegNr) Gt(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FiveGNr) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpFivegNr) Gte(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FiveGNr) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpFivegNr) Lt(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FiveGNr) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpFivegNr) Lte(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FiveGNr) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpFivegNr) In(values []*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FiveGNr) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().FivegNr().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpFivegNr) NotIn(values []*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FiveGNr) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().FivegNr().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpFivegNr) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().FivegNr().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpFivegNr) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().FivegNr().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpFivegNr) compare(op gotenfilter.CompareOperator, value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FiveGNr) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().FivegNr().WithValue(value),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpFivegNr) RegistrationSettings() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpFivegNrRegistrationSettings {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpFivegNrRegistrationSettings{builder: b.builder}
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpFivegNrRegistrationSettings struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpFivegNrRegistrationSettings) Eq(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_RegistrationSettings) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpFivegNrRegistrationSettings) Neq(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_RegistrationSettings) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpFivegNrRegistrationSettings) Gt(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_RegistrationSettings) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpFivegNrRegistrationSettings) Gte(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_RegistrationSettings) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpFivegNrRegistrationSettings) Lt(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_RegistrationSettings) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpFivegNrRegistrationSettings) Lte(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_RegistrationSettings) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpFivegNrRegistrationSettings) In(values []*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_RegistrationSettings) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().FivegNr().RegistrationSettings().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpFivegNrRegistrationSettings) NotIn(values []*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_RegistrationSettings) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().FivegNr().RegistrationSettings().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpFivegNrRegistrationSettings) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().FivegNr().RegistrationSettings().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpFivegNrRegistrationSettings) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().FivegNr().RegistrationSettings().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpFivegNrRegistrationSettings) compare(op gotenfilter.CompareOperator, value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_RegistrationSettings) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().FivegNr().RegistrationSettings().WithValue(value),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpFivegNrRegistrationSettings) DrxCycle() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpFivegNrRegistrationSettingsDrxCycle {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpFivegNrRegistrationSettingsDrxCycle{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpFivegNrRegistrationSettings) MicoMode() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpFivegNrRegistrationSettingsMicoMode {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpFivegNrRegistrationSettingsMicoMode{builder: b.builder}
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpFivegNrRegistrationSettingsDrxCycle struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpFivegNrRegistrationSettingsDrxCycle) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpFivegNrRegistrationSettingsDrxCycle) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpFivegNrRegistrationSettingsDrxCycle) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpFivegNrRegistrationSettingsDrxCycle) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpFivegNrRegistrationSettingsDrxCycle) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpFivegNrRegistrationSettingsDrxCycle) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpFivegNrRegistrationSettingsDrxCycle) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().FivegNr().RegistrationSettings().DrxCycle().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpFivegNrRegistrationSettingsDrxCycle) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().FivegNr().RegistrationSettings().DrxCycle().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpFivegNrRegistrationSettingsDrxCycle) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().FivegNr().RegistrationSettings().DrxCycle().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpFivegNrRegistrationSettingsDrxCycle) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().FivegNr().RegistrationSettings().DrxCycle().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpFivegNrRegistrationSettingsDrxCycle) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().FivegNr().RegistrationSettings().DrxCycle().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpFivegNrRegistrationSettingsMicoMode struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpFivegNrRegistrationSettingsMicoMode) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpFivegNrRegistrationSettingsMicoMode) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpFivegNrRegistrationSettingsMicoMode) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpFivegNrRegistrationSettingsMicoMode) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpFivegNrRegistrationSettingsMicoMode) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpFivegNrRegistrationSettingsMicoMode) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpFivegNrRegistrationSettingsMicoMode) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().FivegNr().RegistrationSettings().MicoMode().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpFivegNrRegistrationSettingsMicoMode) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().FivegNr().RegistrationSettings().MicoMode().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpFivegNrRegistrationSettingsMicoMode) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().FivegNr().RegistrationSettings().MicoMode().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpFivegNrRegistrationSettingsMicoMode) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().FivegNr().RegistrationSettings().MicoMode().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpFivegNrRegistrationSettingsMicoMode) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().FivegNr().RegistrationSettings().MicoMode().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEnabledLocks struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEnabledLocks) Eq(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEnabledLocks) Neq(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEnabledLocks) Gt(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEnabledLocks) Gte(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEnabledLocks) Lt(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEnabledLocks) Lte(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEnabledLocks) In(values [][]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().EnabledLocks().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEnabledLocks) NotIn(values [][]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().EnabledLocks().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEnabledLocks) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().EnabledLocks().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEnabledLocks) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().EnabledLocks().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEnabledLocks) Contains(value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().EnabledLocks().FieldPath(),
		Value:     NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().EnabledLocks().WithItemValue(value),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEnabledLocks) ContainsAnyOf(values []string) *FilterBuilder {
	pathSelector := NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().EnabledLocks()
	itemValues := make([]Device_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().EnabledLocks().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEnabledLocks) ContainsAll(values []string) *FilterBuilder {
	pathSelector := NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().EnabledLocks()
	itemValues := make([]Device_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().EnabledLocks().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEnabledLocks) compare(op gotenfilter.CompareOperator, value []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().EnabledLocks().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEps struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEps) Eq(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Eps) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEps) Neq(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Eps) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEps) Gt(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Eps) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEps) Gte(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Eps) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEps) Lt(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Eps) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEps) Lte(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Eps) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEps) In(values []*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Eps) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().Eps().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEps) NotIn(values []*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Eps) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().Eps().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEps) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().Eps().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEps) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().Eps().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEps) compare(op gotenfilter.CompareOperator, value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Eps) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().Eps().WithValue(value),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEps) InitialBearer() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearer {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearer{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEps) UeModeOperation() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsUeModeOperation {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsUeModeOperation{builder: b.builder}
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearer struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearer) Eq(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_InitialBearer) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearer) Neq(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_InitialBearer) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearer) Gt(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_InitialBearer) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearer) Gte(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_InitialBearer) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearer) Lt(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_InitialBearer) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearer) Lte(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_InitialBearer) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearer) In(values []*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_InitialBearer) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().Eps().InitialBearer().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearer) NotIn(values []*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_InitialBearer) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().Eps().InitialBearer().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearer) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().Eps().InitialBearer().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearer) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().Eps().InitialBearer().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearer) compare(op gotenfilter.CompareOperator, value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_InitialBearer) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().Eps().InitialBearer().WithValue(value),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearer) DbusPath() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearerDbusPath {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearerDbusPath{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearer) Settings() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearerSettings {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearerSettings{builder: b.builder}
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearerDbusPath struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearerDbusPath) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearerDbusPath) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearerDbusPath) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearerDbusPath) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearerDbusPath) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearerDbusPath) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearerDbusPath) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().Eps().InitialBearer().DbusPath().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearerDbusPath) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().Eps().InitialBearer().DbusPath().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearerDbusPath) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().Eps().InitialBearer().DbusPath().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearerDbusPath) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().Eps().InitialBearer().DbusPath().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearerDbusPath) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().Eps().InitialBearer().DbusPath().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearerSettings struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearerSettings) Eq(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Settings) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearerSettings) Neq(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Settings) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearerSettings) Gt(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Settings) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearerSettings) Gte(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Settings) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearerSettings) Lt(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Settings) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearerSettings) Lte(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Settings) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearerSettings) In(values []*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Settings) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().Eps().InitialBearer().Settings().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearerSettings) NotIn(values []*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Settings) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().Eps().InitialBearer().Settings().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearerSettings) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().Eps().InitialBearer().Settings().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearerSettings) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().Eps().InitialBearer().Settings().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearerSettings) compare(op gotenfilter.CompareOperator, value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Settings) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().Eps().InitialBearer().Settings().WithValue(value),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearerSettings) Apn() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearerSettingsApn {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearerSettingsApn{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearerSettings) IpType() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearerSettingsIpType {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearerSettingsIpType{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearerSettings) Password() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearerSettingsPassword {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearerSettingsPassword{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearerSettings) User() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearerSettingsUser {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearerSettingsUser{builder: b.builder}
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearerSettingsApn struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearerSettingsApn) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearerSettingsApn) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearerSettingsApn) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearerSettingsApn) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearerSettingsApn) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearerSettingsApn) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearerSettingsApn) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().Eps().InitialBearer().Settings().Apn().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearerSettingsApn) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().Eps().InitialBearer().Settings().Apn().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearerSettingsApn) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().Eps().InitialBearer().Settings().Apn().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearerSettingsApn) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().Eps().InitialBearer().Settings().Apn().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearerSettingsApn) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().Eps().InitialBearer().Settings().Apn().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearerSettingsIpType struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearerSettingsIpType) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearerSettingsIpType) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearerSettingsIpType) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearerSettingsIpType) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearerSettingsIpType) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearerSettingsIpType) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearerSettingsIpType) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().Eps().InitialBearer().Settings().IpType().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearerSettingsIpType) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().Eps().InitialBearer().Settings().IpType().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearerSettingsIpType) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().Eps().InitialBearer().Settings().IpType().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearerSettingsIpType) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().Eps().InitialBearer().Settings().IpType().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearerSettingsIpType) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().Eps().InitialBearer().Settings().IpType().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearerSettingsPassword struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearerSettingsPassword) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearerSettingsPassword) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearerSettingsPassword) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearerSettingsPassword) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearerSettingsPassword) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearerSettingsPassword) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearerSettingsPassword) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().Eps().InitialBearer().Settings().Password().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearerSettingsPassword) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().Eps().InitialBearer().Settings().Password().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearerSettingsPassword) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().Eps().InitialBearer().Settings().Password().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearerSettingsPassword) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().Eps().InitialBearer().Settings().Password().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearerSettingsPassword) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().Eps().InitialBearer().Settings().Password().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearerSettingsUser struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearerSettingsUser) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearerSettingsUser) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearerSettingsUser) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearerSettingsUser) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearerSettingsUser) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearerSettingsUser) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearerSettingsUser) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().Eps().InitialBearer().Settings().User().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearerSettingsUser) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().Eps().InitialBearer().Settings().User().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearerSettingsUser) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().Eps().InitialBearer().Settings().User().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearerSettingsUser) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().Eps().InitialBearer().Settings().User().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsInitialBearerSettingsUser) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().Eps().InitialBearer().Settings().User().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsUeModeOperation struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsUeModeOperation) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsUeModeOperation) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsUeModeOperation) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsUeModeOperation) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsUeModeOperation) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsUeModeOperation) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsUeModeOperation) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().Eps().UeModeOperation().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsUeModeOperation) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().Eps().UeModeOperation().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsUeModeOperation) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().Eps().UeModeOperation().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsUeModeOperation) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().Eps().UeModeOperation().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpEpsUeModeOperation) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().Eps().UeModeOperation().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpImei struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpImei) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpImei) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpImei) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpImei) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpImei) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpImei) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpImei) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().Imei().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpImei) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().Imei().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpImei) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().Imei().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpImei) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().Imei().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpImei) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().Imei().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpOperatorCode struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpOperatorCode) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpOperatorCode) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpOperatorCode) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpOperatorCode) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpOperatorCode) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpOperatorCode) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpOperatorCode) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().OperatorCode().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpOperatorCode) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().OperatorCode().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpOperatorCode) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().OperatorCode().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpOperatorCode) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().OperatorCode().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpOperatorCode) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().OperatorCode().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpOperatorName struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpOperatorName) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpOperatorName) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpOperatorName) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpOperatorName) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpOperatorName) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpOperatorName) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpOperatorName) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().OperatorName().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpOperatorName) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().OperatorName().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpOperatorName) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().OperatorName().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpOperatorName) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().OperatorName().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpOperatorName) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().OperatorName().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpPacketServiceState struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpPacketServiceState) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpPacketServiceState) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpPacketServiceState) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpPacketServiceState) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpPacketServiceState) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpPacketServiceState) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpPacketServiceState) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().PacketServiceState().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpPacketServiceState) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().PacketServiceState().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpPacketServiceState) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().PacketServiceState().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpPacketServiceState) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().PacketServiceState().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpPacketServiceState) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().PacketServiceState().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpPco struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpPco) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpPco) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpPco) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpPco) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpPco) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpPco) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpPco) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().Pco().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpPco) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().Pco().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpPco) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().Pco().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpPco) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().Pco().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpPco) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().Pco().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpRegistrationState struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpRegistrationState) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpRegistrationState) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpRegistrationState) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpRegistrationState) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpRegistrationState) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpRegistrationState) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpRegistrationState) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().RegistrationState().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpRegistrationState) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().RegistrationState().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpRegistrationState) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().RegistrationState().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpRegistrationState) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().RegistrationState().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemThreeGPpRegistrationState) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().ThreeGPp().RegistrationState().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdma struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdma) Eq(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Cdma) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdma) Neq(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Cdma) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdma) Gt(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Cdma) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdma) Gte(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Cdma) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdma) Lt(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Cdma) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdma) Lte(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Cdma) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdma) In(values []*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Cdma) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Cdma().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdma) NotIn(values []*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Cdma) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Cdma().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdma) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Cdma().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdma) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Cdma().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdma) compare(op gotenfilter.CompareOperator, value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Cdma) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Cdma().WithValue(value),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdma) ActivationState() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaActivationState {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaActivationState{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdma) Cdma1XRegistrationState() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaCdma1XRegistrationState {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaCdma1XRegistrationState{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdma) Esn() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaEsn {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaEsn{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdma) EvdoRegistrationState() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaEvdoRegistrationState {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaEvdoRegistrationState{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdma) Meid() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaMeid {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaMeid{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdma) Nid() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaNid {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaNid{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdma) Sid() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaSid {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaSid{builder: b.builder}
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaActivationState struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaActivationState) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaActivationState) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaActivationState) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaActivationState) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaActivationState) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaActivationState) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaActivationState) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Cdma().ActivationState().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaActivationState) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Cdma().ActivationState().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaActivationState) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Cdma().ActivationState().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaActivationState) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Cdma().ActivationState().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaActivationState) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Cdma().ActivationState().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaCdma1XRegistrationState struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaCdma1XRegistrationState) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaCdma1XRegistrationState) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaCdma1XRegistrationState) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaCdma1XRegistrationState) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaCdma1XRegistrationState) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaCdma1XRegistrationState) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaCdma1XRegistrationState) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Cdma().Cdma1XRegistrationState().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaCdma1XRegistrationState) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Cdma().Cdma1XRegistrationState().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaCdma1XRegistrationState) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Cdma().Cdma1XRegistrationState().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaCdma1XRegistrationState) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Cdma().Cdma1XRegistrationState().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaCdma1XRegistrationState) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Cdma().Cdma1XRegistrationState().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaEsn struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaEsn) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaEsn) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaEsn) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaEsn) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaEsn) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaEsn) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaEsn) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Cdma().Esn().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaEsn) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Cdma().Esn().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaEsn) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Cdma().Esn().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaEsn) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Cdma().Esn().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaEsn) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Cdma().Esn().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaEvdoRegistrationState struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaEvdoRegistrationState) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaEvdoRegistrationState) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaEvdoRegistrationState) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaEvdoRegistrationState) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaEvdoRegistrationState) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaEvdoRegistrationState) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaEvdoRegistrationState) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Cdma().EvdoRegistrationState().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaEvdoRegistrationState) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Cdma().EvdoRegistrationState().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaEvdoRegistrationState) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Cdma().EvdoRegistrationState().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaEvdoRegistrationState) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Cdma().EvdoRegistrationState().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaEvdoRegistrationState) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Cdma().EvdoRegistrationState().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaMeid struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaMeid) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaMeid) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaMeid) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaMeid) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaMeid) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaMeid) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaMeid) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Cdma().Meid().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaMeid) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Cdma().Meid().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaMeid) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Cdma().Meid().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaMeid) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Cdma().Meid().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaMeid) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Cdma().Meid().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaNid struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaNid) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaNid) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaNid) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaNid) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaNid) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaNid) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaNid) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Cdma().Nid().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaNid) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Cdma().Nid().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaNid) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Cdma().Nid().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaNid) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Cdma().Nid().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaNid) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Cdma().Nid().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaSid struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaSid) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaSid) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaSid) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaSid) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaSid) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaSid) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaSid) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Cdma().Sid().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaSid) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Cdma().Sid().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaSid) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Cdma().Sid().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaSid) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Cdma().Sid().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemCdmaSid) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Cdma().Sid().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemDbusPath struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemDbusPath) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemDbusPath) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemDbusPath) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemDbusPath) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemDbusPath) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemDbusPath) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemDbusPath) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().DbusPath().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemDbusPath) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().DbusPath().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemDbusPath) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().DbusPath().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemDbusPath) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().DbusPath().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemDbusPath) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().DbusPath().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGeneric struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGeneric) Eq(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Generic) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGeneric) Neq(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Generic) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGeneric) Gt(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Generic) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGeneric) Gte(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Generic) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGeneric) Lt(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Generic) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGeneric) Lte(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Generic) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGeneric) In(values []*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Generic) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGeneric) NotIn(values []*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Generic) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGeneric) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGeneric) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGeneric) compare(op gotenfilter.CompareOperator, value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Generic) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().WithValue(value),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGeneric) AccessTechnologies() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericAccessTechnologies {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericAccessTechnologies{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGeneric) Bearers() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericBearers {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericBearers{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGeneric) CarrierConfiguration() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericCarrierConfiguration {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericCarrierConfiguration{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGeneric) CarrierConfigurationRevision() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericCarrierConfigurationRevision {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericCarrierConfigurationRevision{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGeneric) CurrentBands() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericCurrentBands {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericCurrentBands{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGeneric) CurrentCapabilities() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericCurrentCapabilities {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericCurrentCapabilities{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGeneric) CurrentModes() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericCurrentModes {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericCurrentModes{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGeneric) Device() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericDevice {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericDevice{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGeneric) DeviceIdentifier() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericDeviceIdentifier {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericDeviceIdentifier{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGeneric) Drivers() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericDrivers {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericDrivers{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGeneric) EquipmentIdentifier() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericEquipmentIdentifier {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericEquipmentIdentifier{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGeneric) HardwareRevision() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericHardwareRevision {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericHardwareRevision{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGeneric) Manufacturer() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericManufacturer {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericManufacturer{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGeneric) Model() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericModel {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericModel{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGeneric) OwnNumbers() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericOwnNumbers {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericOwnNumbers{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGeneric) Plugin() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericPlugin {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericPlugin{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGeneric) Ports() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericPorts {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericPorts{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGeneric) PowerState() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericPowerState {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericPowerState{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGeneric) PrimaryPort() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericPrimaryPort {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericPrimaryPort{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGeneric) PrimarySimSlot() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericPrimarySimSlot {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericPrimarySimSlot{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGeneric) Revision() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericRevision {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericRevision{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGeneric) SignalQuality() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSignalQuality {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSignalQuality{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGeneric) Sim() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSim {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSim{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGeneric) SimSlots() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSimSlots {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSimSlots{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGeneric) State() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericState {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericState{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGeneric) StateFailedReason() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericStateFailedReason {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericStateFailedReason{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGeneric) SupportedBands() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSupportedBands {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSupportedBands{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGeneric) SupportedCapabilities() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSupportedCapabilities {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSupportedCapabilities{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGeneric) SupportedIpFamilies() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSupportedIpFamilies {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSupportedIpFamilies{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGeneric) SupportedModes() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSupportedModes {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSupportedModes{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGeneric) UnlockRequired() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericUnlockRequired {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericUnlockRequired{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGeneric) UnlockRetries() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericUnlockRetries {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericUnlockRetries{builder: b.builder}
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericAccessTechnologies struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericAccessTechnologies) Eq(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericAccessTechnologies) Neq(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericAccessTechnologies) Gt(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericAccessTechnologies) Gte(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericAccessTechnologies) Lt(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericAccessTechnologies) Lte(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericAccessTechnologies) In(values [][]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().AccessTechnologies().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericAccessTechnologies) NotIn(values [][]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().AccessTechnologies().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericAccessTechnologies) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().AccessTechnologies().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericAccessTechnologies) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().AccessTechnologies().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericAccessTechnologies) Contains(value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().AccessTechnologies().FieldPath(),
		Value:     NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().AccessTechnologies().WithItemValue(value),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericAccessTechnologies) ContainsAnyOf(values []string) *FilterBuilder {
	pathSelector := NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().AccessTechnologies()
	itemValues := make([]Device_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().AccessTechnologies().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericAccessTechnologies) ContainsAll(values []string) *FilterBuilder {
	pathSelector := NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().AccessTechnologies()
	itemValues := make([]Device_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().AccessTechnologies().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericAccessTechnologies) compare(op gotenfilter.CompareOperator, value []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().AccessTechnologies().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericBearers struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericBearers) Eq(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericBearers) Neq(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericBearers) Gt(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericBearers) Gte(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericBearers) Lt(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericBearers) Lte(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericBearers) In(values [][]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().Bearers().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericBearers) NotIn(values [][]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().Bearers().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericBearers) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().Bearers().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericBearers) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().Bearers().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericBearers) Contains(value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().Bearers().FieldPath(),
		Value:     NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().Bearers().WithItemValue(value),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericBearers) ContainsAnyOf(values []string) *FilterBuilder {
	pathSelector := NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().Bearers()
	itemValues := make([]Device_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().Bearers().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericBearers) ContainsAll(values []string) *FilterBuilder {
	pathSelector := NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().Bearers()
	itemValues := make([]Device_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().Bearers().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericBearers) compare(op gotenfilter.CompareOperator, value []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().Bearers().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericCarrierConfiguration struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericCarrierConfiguration) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericCarrierConfiguration) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericCarrierConfiguration) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericCarrierConfiguration) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericCarrierConfiguration) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericCarrierConfiguration) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericCarrierConfiguration) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().CarrierConfiguration().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericCarrierConfiguration) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().CarrierConfiguration().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericCarrierConfiguration) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().CarrierConfiguration().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericCarrierConfiguration) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().CarrierConfiguration().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericCarrierConfiguration) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().CarrierConfiguration().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericCarrierConfigurationRevision struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericCarrierConfigurationRevision) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericCarrierConfigurationRevision) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericCarrierConfigurationRevision) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericCarrierConfigurationRevision) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericCarrierConfigurationRevision) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericCarrierConfigurationRevision) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericCarrierConfigurationRevision) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().CarrierConfigurationRevision().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericCarrierConfigurationRevision) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().CarrierConfigurationRevision().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericCarrierConfigurationRevision) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().CarrierConfigurationRevision().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericCarrierConfigurationRevision) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().CarrierConfigurationRevision().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericCarrierConfigurationRevision) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().CarrierConfigurationRevision().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericCurrentBands struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericCurrentBands) Eq(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericCurrentBands) Neq(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericCurrentBands) Gt(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericCurrentBands) Gte(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericCurrentBands) Lt(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericCurrentBands) Lte(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericCurrentBands) In(values [][]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().CurrentBands().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericCurrentBands) NotIn(values [][]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().CurrentBands().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericCurrentBands) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().CurrentBands().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericCurrentBands) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().CurrentBands().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericCurrentBands) Contains(value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().CurrentBands().FieldPath(),
		Value:     NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().CurrentBands().WithItemValue(value),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericCurrentBands) ContainsAnyOf(values []string) *FilterBuilder {
	pathSelector := NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().CurrentBands()
	itemValues := make([]Device_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().CurrentBands().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericCurrentBands) ContainsAll(values []string) *FilterBuilder {
	pathSelector := NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().CurrentBands()
	itemValues := make([]Device_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().CurrentBands().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericCurrentBands) compare(op gotenfilter.CompareOperator, value []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().CurrentBands().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericCurrentCapabilities struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericCurrentCapabilities) Eq(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericCurrentCapabilities) Neq(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericCurrentCapabilities) Gt(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericCurrentCapabilities) Gte(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericCurrentCapabilities) Lt(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericCurrentCapabilities) Lte(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericCurrentCapabilities) In(values [][]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().CurrentCapabilities().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericCurrentCapabilities) NotIn(values [][]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().CurrentCapabilities().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericCurrentCapabilities) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().CurrentCapabilities().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericCurrentCapabilities) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().CurrentCapabilities().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericCurrentCapabilities) Contains(value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().CurrentCapabilities().FieldPath(),
		Value:     NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().CurrentCapabilities().WithItemValue(value),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericCurrentCapabilities) ContainsAnyOf(values []string) *FilterBuilder {
	pathSelector := NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().CurrentCapabilities()
	itemValues := make([]Device_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().CurrentCapabilities().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericCurrentCapabilities) ContainsAll(values []string) *FilterBuilder {
	pathSelector := NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().CurrentCapabilities()
	itemValues := make([]Device_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().CurrentCapabilities().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericCurrentCapabilities) compare(op gotenfilter.CompareOperator, value []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().CurrentCapabilities().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericCurrentModes struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericCurrentModes) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericCurrentModes) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericCurrentModes) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericCurrentModes) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericCurrentModes) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericCurrentModes) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericCurrentModes) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().CurrentModes().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericCurrentModes) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().CurrentModes().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericCurrentModes) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().CurrentModes().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericCurrentModes) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().CurrentModes().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericCurrentModes) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().CurrentModes().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericDevice struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericDevice) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericDevice) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericDevice) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericDevice) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericDevice) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericDevice) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericDevice) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().Device().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericDevice) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().Device().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericDevice) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().Device().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericDevice) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().Device().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericDevice) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().Device().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericDeviceIdentifier struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericDeviceIdentifier) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericDeviceIdentifier) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericDeviceIdentifier) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericDeviceIdentifier) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericDeviceIdentifier) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericDeviceIdentifier) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericDeviceIdentifier) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().DeviceIdentifier().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericDeviceIdentifier) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().DeviceIdentifier().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericDeviceIdentifier) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().DeviceIdentifier().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericDeviceIdentifier) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().DeviceIdentifier().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericDeviceIdentifier) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().DeviceIdentifier().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericDrivers struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericDrivers) Eq(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericDrivers) Neq(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericDrivers) Gt(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericDrivers) Gte(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericDrivers) Lt(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericDrivers) Lte(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericDrivers) In(values [][]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().Drivers().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericDrivers) NotIn(values [][]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().Drivers().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericDrivers) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().Drivers().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericDrivers) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().Drivers().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericDrivers) Contains(value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().Drivers().FieldPath(),
		Value:     NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().Drivers().WithItemValue(value),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericDrivers) ContainsAnyOf(values []string) *FilterBuilder {
	pathSelector := NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().Drivers()
	itemValues := make([]Device_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().Drivers().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericDrivers) ContainsAll(values []string) *FilterBuilder {
	pathSelector := NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().Drivers()
	itemValues := make([]Device_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().Drivers().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericDrivers) compare(op gotenfilter.CompareOperator, value []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().Drivers().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericEquipmentIdentifier struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericEquipmentIdentifier) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericEquipmentIdentifier) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericEquipmentIdentifier) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericEquipmentIdentifier) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericEquipmentIdentifier) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericEquipmentIdentifier) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericEquipmentIdentifier) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().EquipmentIdentifier().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericEquipmentIdentifier) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().EquipmentIdentifier().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericEquipmentIdentifier) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().EquipmentIdentifier().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericEquipmentIdentifier) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().EquipmentIdentifier().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericEquipmentIdentifier) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().EquipmentIdentifier().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericHardwareRevision struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericHardwareRevision) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericHardwareRevision) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericHardwareRevision) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericHardwareRevision) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericHardwareRevision) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericHardwareRevision) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericHardwareRevision) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().HardwareRevision().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericHardwareRevision) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().HardwareRevision().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericHardwareRevision) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().HardwareRevision().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericHardwareRevision) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().HardwareRevision().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericHardwareRevision) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().HardwareRevision().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericManufacturer struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericManufacturer) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericManufacturer) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericManufacturer) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericManufacturer) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericManufacturer) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericManufacturer) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericManufacturer) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().Manufacturer().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericManufacturer) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().Manufacturer().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericManufacturer) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().Manufacturer().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericManufacturer) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().Manufacturer().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericManufacturer) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().Manufacturer().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericModel struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericModel) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericModel) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericModel) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericModel) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericModel) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericModel) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericModel) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().Model().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericModel) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().Model().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericModel) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().Model().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericModel) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().Model().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericModel) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().Model().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericOwnNumbers struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericOwnNumbers) Eq(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericOwnNumbers) Neq(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericOwnNumbers) Gt(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericOwnNumbers) Gte(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericOwnNumbers) Lt(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericOwnNumbers) Lte(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericOwnNumbers) In(values [][]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().OwnNumbers().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericOwnNumbers) NotIn(values [][]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().OwnNumbers().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericOwnNumbers) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().OwnNumbers().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericOwnNumbers) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().OwnNumbers().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericOwnNumbers) Contains(value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().OwnNumbers().FieldPath(),
		Value:     NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().OwnNumbers().WithItemValue(value),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericOwnNumbers) ContainsAnyOf(values []string) *FilterBuilder {
	pathSelector := NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().OwnNumbers()
	itemValues := make([]Device_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().OwnNumbers().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericOwnNumbers) ContainsAll(values []string) *FilterBuilder {
	pathSelector := NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().OwnNumbers()
	itemValues := make([]Device_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().OwnNumbers().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericOwnNumbers) compare(op gotenfilter.CompareOperator, value []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().OwnNumbers().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericPlugin struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericPlugin) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericPlugin) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericPlugin) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericPlugin) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericPlugin) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericPlugin) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericPlugin) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().Plugin().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericPlugin) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().Plugin().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericPlugin) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().Plugin().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericPlugin) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().Plugin().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericPlugin) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().Plugin().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericPorts struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericPorts) Eq(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericPorts) Neq(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericPorts) Gt(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericPorts) Gte(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericPorts) Lt(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericPorts) Lte(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericPorts) In(values [][]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().Ports().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericPorts) NotIn(values [][]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().Ports().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericPorts) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().Ports().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericPorts) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().Ports().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericPorts) Contains(value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().Ports().FieldPath(),
		Value:     NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().Ports().WithItemValue(value),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericPorts) ContainsAnyOf(values []string) *FilterBuilder {
	pathSelector := NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().Ports()
	itemValues := make([]Device_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().Ports().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericPorts) ContainsAll(values []string) *FilterBuilder {
	pathSelector := NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().Ports()
	itemValues := make([]Device_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().Ports().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericPorts) compare(op gotenfilter.CompareOperator, value []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().Ports().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericPowerState struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericPowerState) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericPowerState) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericPowerState) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericPowerState) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericPowerState) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericPowerState) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericPowerState) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().PowerState().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericPowerState) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().PowerState().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericPowerState) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().PowerState().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericPowerState) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().PowerState().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericPowerState) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().PowerState().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericPrimaryPort struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericPrimaryPort) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericPrimaryPort) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericPrimaryPort) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericPrimaryPort) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericPrimaryPort) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericPrimaryPort) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericPrimaryPort) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().PrimaryPort().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericPrimaryPort) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().PrimaryPort().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericPrimaryPort) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().PrimaryPort().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericPrimaryPort) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().PrimaryPort().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericPrimaryPort) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().PrimaryPort().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericPrimarySimSlot struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericPrimarySimSlot) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericPrimarySimSlot) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericPrimarySimSlot) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericPrimarySimSlot) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericPrimarySimSlot) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericPrimarySimSlot) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericPrimarySimSlot) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().PrimarySimSlot().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericPrimarySimSlot) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().PrimarySimSlot().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericPrimarySimSlot) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().PrimarySimSlot().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericPrimarySimSlot) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().PrimarySimSlot().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericPrimarySimSlot) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().PrimarySimSlot().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericRevision struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericRevision) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericRevision) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericRevision) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericRevision) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericRevision) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericRevision) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericRevision) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().Revision().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericRevision) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().Revision().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericRevision) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().Revision().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericRevision) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().Revision().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericRevision) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().Revision().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSignalQuality struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSignalQuality) Eq(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalQuality) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSignalQuality) Neq(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalQuality) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSignalQuality) Gt(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalQuality) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSignalQuality) Gte(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalQuality) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSignalQuality) Lt(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalQuality) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSignalQuality) Lte(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalQuality) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSignalQuality) In(values []*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalQuality) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().SignalQuality().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSignalQuality) NotIn(values []*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalQuality) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().SignalQuality().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSignalQuality) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().SignalQuality().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSignalQuality) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().SignalQuality().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSignalQuality) compare(op gotenfilter.CompareOperator, value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalQuality) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().SignalQuality().WithValue(value),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSignalQuality) Recent() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSignalQualityRecent {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSignalQualityRecent{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSignalQuality) Value() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSignalQualityValue {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSignalQualityValue{builder: b.builder}
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSignalQualityRecent struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSignalQualityRecent) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSignalQualityRecent) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSignalQualityRecent) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSignalQualityRecent) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSignalQualityRecent) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSignalQualityRecent) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSignalQualityRecent) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().SignalQuality().Recent().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSignalQualityRecent) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().SignalQuality().Recent().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSignalQualityRecent) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().SignalQuality().Recent().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSignalQualityRecent) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().SignalQuality().Recent().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSignalQualityRecent) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().SignalQuality().Recent().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSignalQualityValue struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSignalQualityValue) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSignalQualityValue) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSignalQualityValue) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSignalQualityValue) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSignalQualityValue) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSignalQualityValue) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSignalQualityValue) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().SignalQuality().Value().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSignalQualityValue) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().SignalQuality().Value().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSignalQualityValue) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().SignalQuality().Value().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSignalQualityValue) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().SignalQuality().Value().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSignalQualityValue) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().SignalQuality().Value().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSim struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSim) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSim) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSim) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSim) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSim) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSim) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSim) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().Sim().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSim) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().Sim().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSim) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().Sim().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSim) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().Sim().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSim) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().Sim().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSimSlots struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSimSlots) Eq(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSimSlots) Neq(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSimSlots) Gt(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSimSlots) Gte(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSimSlots) Lt(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSimSlots) Lte(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSimSlots) In(values [][]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().SimSlots().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSimSlots) NotIn(values [][]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().SimSlots().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSimSlots) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().SimSlots().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSimSlots) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().SimSlots().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSimSlots) Contains(value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().SimSlots().FieldPath(),
		Value:     NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().SimSlots().WithItemValue(value),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSimSlots) ContainsAnyOf(values []string) *FilterBuilder {
	pathSelector := NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().SimSlots()
	itemValues := make([]Device_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().SimSlots().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSimSlots) ContainsAll(values []string) *FilterBuilder {
	pathSelector := NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().SimSlots()
	itemValues := make([]Device_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().SimSlots().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSimSlots) compare(op gotenfilter.CompareOperator, value []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().SimSlots().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericState struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericState) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericState) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericState) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericState) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericState) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericState) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericState) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().State().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericState) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().State().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericState) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().State().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericState) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().State().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericState) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().State().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericStateFailedReason struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericStateFailedReason) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericStateFailedReason) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericStateFailedReason) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericStateFailedReason) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericStateFailedReason) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericStateFailedReason) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericStateFailedReason) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().StateFailedReason().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericStateFailedReason) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().StateFailedReason().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericStateFailedReason) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().StateFailedReason().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericStateFailedReason) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().StateFailedReason().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericStateFailedReason) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().StateFailedReason().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSupportedBands struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSupportedBands) Eq(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSupportedBands) Neq(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSupportedBands) Gt(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSupportedBands) Gte(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSupportedBands) Lt(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSupportedBands) Lte(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSupportedBands) In(values [][]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().SupportedBands().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSupportedBands) NotIn(values [][]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().SupportedBands().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSupportedBands) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().SupportedBands().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSupportedBands) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().SupportedBands().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSupportedBands) Contains(value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().SupportedBands().FieldPath(),
		Value:     NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().SupportedBands().WithItemValue(value),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSupportedBands) ContainsAnyOf(values []string) *FilterBuilder {
	pathSelector := NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().SupportedBands()
	itemValues := make([]Device_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().SupportedBands().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSupportedBands) ContainsAll(values []string) *FilterBuilder {
	pathSelector := NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().SupportedBands()
	itemValues := make([]Device_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().SupportedBands().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSupportedBands) compare(op gotenfilter.CompareOperator, value []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().SupportedBands().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSupportedCapabilities struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSupportedCapabilities) Eq(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSupportedCapabilities) Neq(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSupportedCapabilities) Gt(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSupportedCapabilities) Gte(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSupportedCapabilities) Lt(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSupportedCapabilities) Lte(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSupportedCapabilities) In(values [][]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().SupportedCapabilities().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSupportedCapabilities) NotIn(values [][]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().SupportedCapabilities().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSupportedCapabilities) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().SupportedCapabilities().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSupportedCapabilities) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().SupportedCapabilities().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSupportedCapabilities) Contains(value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().SupportedCapabilities().FieldPath(),
		Value:     NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().SupportedCapabilities().WithItemValue(value),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSupportedCapabilities) ContainsAnyOf(values []string) *FilterBuilder {
	pathSelector := NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().SupportedCapabilities()
	itemValues := make([]Device_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().SupportedCapabilities().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSupportedCapabilities) ContainsAll(values []string) *FilterBuilder {
	pathSelector := NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().SupportedCapabilities()
	itemValues := make([]Device_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().SupportedCapabilities().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSupportedCapabilities) compare(op gotenfilter.CompareOperator, value []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().SupportedCapabilities().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSupportedIpFamilies struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSupportedIpFamilies) Eq(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSupportedIpFamilies) Neq(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSupportedIpFamilies) Gt(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSupportedIpFamilies) Gte(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSupportedIpFamilies) Lt(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSupportedIpFamilies) Lte(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSupportedIpFamilies) In(values [][]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().SupportedIpFamilies().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSupportedIpFamilies) NotIn(values [][]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().SupportedIpFamilies().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSupportedIpFamilies) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().SupportedIpFamilies().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSupportedIpFamilies) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().SupportedIpFamilies().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSupportedIpFamilies) Contains(value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().SupportedIpFamilies().FieldPath(),
		Value:     NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().SupportedIpFamilies().WithItemValue(value),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSupportedIpFamilies) ContainsAnyOf(values []string) *FilterBuilder {
	pathSelector := NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().SupportedIpFamilies()
	itemValues := make([]Device_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().SupportedIpFamilies().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSupportedIpFamilies) ContainsAll(values []string) *FilterBuilder {
	pathSelector := NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().SupportedIpFamilies()
	itemValues := make([]Device_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().SupportedIpFamilies().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSupportedIpFamilies) compare(op gotenfilter.CompareOperator, value []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().SupportedIpFamilies().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSupportedModes struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSupportedModes) Eq(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSupportedModes) Neq(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSupportedModes) Gt(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSupportedModes) Gte(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSupportedModes) Lt(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSupportedModes) Lte(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSupportedModes) In(values [][]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().SupportedModes().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSupportedModes) NotIn(values [][]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().SupportedModes().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSupportedModes) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().SupportedModes().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSupportedModes) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().SupportedModes().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSupportedModes) Contains(value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().SupportedModes().FieldPath(),
		Value:     NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().SupportedModes().WithItemValue(value),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSupportedModes) ContainsAnyOf(values []string) *FilterBuilder {
	pathSelector := NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().SupportedModes()
	itemValues := make([]Device_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().SupportedModes().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSupportedModes) ContainsAll(values []string) *FilterBuilder {
	pathSelector := NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().SupportedModes()
	itemValues := make([]Device_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().SupportedModes().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericSupportedModes) compare(op gotenfilter.CompareOperator, value []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().SupportedModes().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericUnlockRequired struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericUnlockRequired) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericUnlockRequired) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericUnlockRequired) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericUnlockRequired) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericUnlockRequired) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericUnlockRequired) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericUnlockRequired) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().UnlockRequired().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericUnlockRequired) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().UnlockRequired().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericUnlockRequired) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().UnlockRequired().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericUnlockRequired) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().UnlockRequired().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericUnlockRequired) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().UnlockRequired().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericUnlockRetries struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericUnlockRetries) Eq(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericUnlockRetries) Neq(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericUnlockRetries) Gt(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericUnlockRetries) Gte(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericUnlockRetries) Lt(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericUnlockRetries) Lte(value []string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericUnlockRetries) In(values [][]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().UnlockRetries().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericUnlockRetries) NotIn(values [][]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().UnlockRetries().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericUnlockRetries) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().UnlockRetries().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericUnlockRetries) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().UnlockRetries().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericUnlockRetries) Contains(value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().UnlockRetries().FieldPath(),
		Value:     NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().UnlockRetries().WithItemValue(value),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericUnlockRetries) ContainsAnyOf(values []string) *FilterBuilder {
	pathSelector := NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().UnlockRetries()
	itemValues := make([]Device_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().UnlockRetries().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericUnlockRetries) ContainsAll(values []string) *FilterBuilder {
	pathSelector := NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().UnlockRetries()
	itemValues := make([]Device_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().UnlockRetries().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemGenericUnlockRetries) compare(op gotenfilter.CompareOperator, value []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Generic().UnlockRetries().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSimStatus struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSimStatus) Eq(value map[string]*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSimStatus) Neq(value map[string]*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSimStatus) Gt(value map[string]*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSimStatus) Gte(value map[string]*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSimStatus) Lt(value map[string]*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSimStatus) Lte(value map[string]*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSimStatus) In(values []map[string]*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().SimStatus().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSimStatus) NotIn(values []map[string]*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().SimStatus().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSimStatus) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().SimStatus().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSimStatus) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().SimStatus().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSimStatus) compare(op gotenfilter.CompareOperator, value map[string]*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().SimStatus().WithValue(value),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSimStatus) WithKey(key string) *mapFilterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSimStatus {
	return &mapFilterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSimStatus{builder: b.builder, key: key}
}

type mapFilterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSimStatus struct {
	builder *FilterBuilder
	key     string
}

func (b *mapFilterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSimStatus) Eq(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *mapFilterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSimStatus) Neq(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *mapFilterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSimStatus) Gt(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *mapFilterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSimStatus) Gte(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *mapFilterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSimStatus) Lt(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *mapFilterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSimStatus) Lte(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *mapFilterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSimStatus) In(values []*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().SimStatus().WithKey(b.key).WithArrayOfValues(values),
	})
}

func (b *mapFilterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSimStatus) NotIn(values []*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().SimStatus().WithKey(b.key).WithArrayOfValues(values),
	})
}

func (b *mapFilterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSimStatus) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().SimStatus().WithKey(b.key).FieldPath(),
	})
}

func (b *mapFilterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSimStatus) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().SimStatus().WithKey(b.key).FieldPath(),
	})
}

func (b *mapFilterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSimStatus) compare(op gotenfilter.CompareOperator, value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().SimStatus().WithKey(b.key).WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoNetworkInterfaces struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoNetworkInterfaces) Eq(value map[string]*Device_Status_DeviceInfo_NetworkInterface) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoNetworkInterfaces) Neq(value map[string]*Device_Status_DeviceInfo_NetworkInterface) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoNetworkInterfaces) Gt(value map[string]*Device_Status_DeviceInfo_NetworkInterface) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoNetworkInterfaces) Gte(value map[string]*Device_Status_DeviceInfo_NetworkInterface) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoNetworkInterfaces) Lt(value map[string]*Device_Status_DeviceInfo_NetworkInterface) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoNetworkInterfaces) Lte(value map[string]*Device_Status_DeviceInfo_NetworkInterface) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoNetworkInterfaces) In(values []map[string]*Device_Status_DeviceInfo_NetworkInterface) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().NetworkInterfaces().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoNetworkInterfaces) NotIn(values []map[string]*Device_Status_DeviceInfo_NetworkInterface) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().NetworkInterfaces().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoNetworkInterfaces) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().NetworkInterfaces().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoNetworkInterfaces) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().NetworkInterfaces().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoNetworkInterfaces) compare(op gotenfilter.CompareOperator, value map[string]*Device_Status_DeviceInfo_NetworkInterface) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().NetworkInterfaces().WithValue(value),
	})
}

func (b *filterCndBuilderStatusDeviceInfoNetworkInterfaces) WithKey(key string) *mapFilterCndBuilderStatusDeviceInfoNetworkInterfaces {
	return &mapFilterCndBuilderStatusDeviceInfoNetworkInterfaces{builder: b.builder, key: key}
}

type mapFilterCndBuilderStatusDeviceInfoNetworkInterfaces struct {
	builder *FilterBuilder
	key     string
}

func (b *mapFilterCndBuilderStatusDeviceInfoNetworkInterfaces) Eq(value *Device_Status_DeviceInfo_NetworkInterface) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *mapFilterCndBuilderStatusDeviceInfoNetworkInterfaces) Neq(value *Device_Status_DeviceInfo_NetworkInterface) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *mapFilterCndBuilderStatusDeviceInfoNetworkInterfaces) Gt(value *Device_Status_DeviceInfo_NetworkInterface) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *mapFilterCndBuilderStatusDeviceInfoNetworkInterfaces) Gte(value *Device_Status_DeviceInfo_NetworkInterface) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *mapFilterCndBuilderStatusDeviceInfoNetworkInterfaces) Lt(value *Device_Status_DeviceInfo_NetworkInterface) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *mapFilterCndBuilderStatusDeviceInfoNetworkInterfaces) Lte(value *Device_Status_DeviceInfo_NetworkInterface) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *mapFilterCndBuilderStatusDeviceInfoNetworkInterfaces) In(values []*Device_Status_DeviceInfo_NetworkInterface) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().NetworkInterfaces().WithKey(b.key).WithArrayOfValues(values),
	})
}

func (b *mapFilterCndBuilderStatusDeviceInfoNetworkInterfaces) NotIn(values []*Device_Status_DeviceInfo_NetworkInterface) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().NetworkInterfaces().WithKey(b.key).WithArrayOfValues(values),
	})
}

func (b *mapFilterCndBuilderStatusDeviceInfoNetworkInterfaces) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().NetworkInterfaces().WithKey(b.key).FieldPath(),
	})
}

func (b *mapFilterCndBuilderStatusDeviceInfoNetworkInterfaces) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().NetworkInterfaces().WithKey(b.key).FieldPath(),
	})
}

func (b *mapFilterCndBuilderStatusDeviceInfoNetworkInterfaces) compare(op gotenfilter.CompareOperator, value *Device_Status_DeviceInfo_NetworkInterface) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().NetworkInterfaces().WithKey(b.key).WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoControlPlaneInterfaceInfo struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoControlPlaneInterfaceInfo) Eq(value *Device_Status_DeviceInfo_ControlPlaneInterfaceInfo) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoControlPlaneInterfaceInfo) Neq(value *Device_Status_DeviceInfo_ControlPlaneInterfaceInfo) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoControlPlaneInterfaceInfo) Gt(value *Device_Status_DeviceInfo_ControlPlaneInterfaceInfo) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoControlPlaneInterfaceInfo) Gte(value *Device_Status_DeviceInfo_ControlPlaneInterfaceInfo) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoControlPlaneInterfaceInfo) Lt(value *Device_Status_DeviceInfo_ControlPlaneInterfaceInfo) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoControlPlaneInterfaceInfo) Lte(value *Device_Status_DeviceInfo_ControlPlaneInterfaceInfo) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoControlPlaneInterfaceInfo) In(values []*Device_Status_DeviceInfo_ControlPlaneInterfaceInfo) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().ControlPlaneInterfaceInfo().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoControlPlaneInterfaceInfo) NotIn(values []*Device_Status_DeviceInfo_ControlPlaneInterfaceInfo) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().ControlPlaneInterfaceInfo().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoControlPlaneInterfaceInfo) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().ControlPlaneInterfaceInfo().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoControlPlaneInterfaceInfo) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().ControlPlaneInterfaceInfo().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoControlPlaneInterfaceInfo) compare(op gotenfilter.CompareOperator, value *Device_Status_DeviceInfo_ControlPlaneInterfaceInfo) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().ControlPlaneInterfaceInfo().WithValue(value),
	})
}

func (b *filterCndBuilderStatusDeviceInfoControlPlaneInterfaceInfo) ActiveControlPlaneInterface() *filterCndBuilderStatusDeviceInfoControlPlaneInterfaceInfoActiveControlPlaneInterface {
	return &filterCndBuilderStatusDeviceInfoControlPlaneInterfaceInfoActiveControlPlaneInterface{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoControlPlaneInterfaceInfo) UsesProxy() *filterCndBuilderStatusDeviceInfoControlPlaneInterfaceInfoUsesProxy {
	return &filterCndBuilderStatusDeviceInfoControlPlaneInterfaceInfoUsesProxy{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoControlPlaneInterfaceInfo) IsFallback() *filterCndBuilderStatusDeviceInfoControlPlaneInterfaceInfoIsFallback {
	return &filterCndBuilderStatusDeviceInfoControlPlaneInterfaceInfoIsFallback{builder: b.builder}
}

type filterCndBuilderStatusDeviceInfoControlPlaneInterfaceInfoActiveControlPlaneInterface struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoControlPlaneInterfaceInfoActiveControlPlaneInterface) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoControlPlaneInterfaceInfoActiveControlPlaneInterface) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoControlPlaneInterfaceInfoActiveControlPlaneInterface) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoControlPlaneInterfaceInfoActiveControlPlaneInterface) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoControlPlaneInterfaceInfoActiveControlPlaneInterface) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoControlPlaneInterfaceInfoActiveControlPlaneInterface) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoControlPlaneInterfaceInfoActiveControlPlaneInterface) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().ControlPlaneInterfaceInfo().ActiveControlPlaneInterface().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoControlPlaneInterfaceInfoActiveControlPlaneInterface) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().ControlPlaneInterfaceInfo().ActiveControlPlaneInterface().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoControlPlaneInterfaceInfoActiveControlPlaneInterface) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().ControlPlaneInterfaceInfo().ActiveControlPlaneInterface().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoControlPlaneInterfaceInfoActiveControlPlaneInterface) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().ControlPlaneInterfaceInfo().ActiveControlPlaneInterface().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoControlPlaneInterfaceInfoActiveControlPlaneInterface) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().ControlPlaneInterfaceInfo().ActiveControlPlaneInterface().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoControlPlaneInterfaceInfoUsesProxy struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoControlPlaneInterfaceInfoUsesProxy) Eq(value bool) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoControlPlaneInterfaceInfoUsesProxy) Neq(value bool) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoControlPlaneInterfaceInfoUsesProxy) Gt(value bool) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoControlPlaneInterfaceInfoUsesProxy) Gte(value bool) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoControlPlaneInterfaceInfoUsesProxy) Lt(value bool) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoControlPlaneInterfaceInfoUsesProxy) Lte(value bool) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoControlPlaneInterfaceInfoUsesProxy) In(values []bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().ControlPlaneInterfaceInfo().UsesProxy().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoControlPlaneInterfaceInfoUsesProxy) NotIn(values []bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().ControlPlaneInterfaceInfo().UsesProxy().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoControlPlaneInterfaceInfoUsesProxy) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().ControlPlaneInterfaceInfo().UsesProxy().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoControlPlaneInterfaceInfoUsesProxy) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().ControlPlaneInterfaceInfo().UsesProxy().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoControlPlaneInterfaceInfoUsesProxy) compare(op gotenfilter.CompareOperator, value bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().ControlPlaneInterfaceInfo().UsesProxy().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoControlPlaneInterfaceInfoIsFallback struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoControlPlaneInterfaceInfoIsFallback) Eq(value bool) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoControlPlaneInterfaceInfoIsFallback) Neq(value bool) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoControlPlaneInterfaceInfoIsFallback) Gt(value bool) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoControlPlaneInterfaceInfoIsFallback) Gte(value bool) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoControlPlaneInterfaceInfoIsFallback) Lt(value bool) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoControlPlaneInterfaceInfoIsFallback) Lte(value bool) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoControlPlaneInterfaceInfoIsFallback) In(values []bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().ControlPlaneInterfaceInfo().IsFallback().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoControlPlaneInterfaceInfoIsFallback) NotIn(values []bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().ControlPlaneInterfaceInfo().IsFallback().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoControlPlaneInterfaceInfoIsFallback) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().ControlPlaneInterfaceInfo().IsFallback().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoControlPlaneInterfaceInfoIsFallback) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().ControlPlaneInterfaceInfo().IsFallback().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoControlPlaneInterfaceInfoIsFallback) compare(op gotenfilter.CompareOperator, value bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().ControlPlaneInterfaceInfo().IsFallback().WithValue(value),
	})
}

type filterCndBuilderStatusAttestationStatus struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusAttestationStatus) Eq(value []*iam_iam_common.PCR) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusAttestationStatus) Neq(value []*iam_iam_common.PCR) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusAttestationStatus) Gt(value []*iam_iam_common.PCR) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusAttestationStatus) Gte(value []*iam_iam_common.PCR) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusAttestationStatus) Lt(value []*iam_iam_common.PCR) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusAttestationStatus) Lte(value []*iam_iam_common.PCR) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusAttestationStatus) In(values [][]*iam_iam_common.PCR) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().AttestationStatus().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusAttestationStatus) NotIn(values [][]*iam_iam_common.PCR) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().AttestationStatus().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusAttestationStatus) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().AttestationStatus().FieldPath(),
	})
}

func (b *filterCndBuilderStatusAttestationStatus) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().AttestationStatus().FieldPath(),
	})
}

func (b *filterCndBuilderStatusAttestationStatus) Contains(value *iam_iam_common.PCR) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewDeviceFieldPathBuilder().Status().AttestationStatus().FieldPath(),
		Value:     NewDeviceFieldPathBuilder().Status().AttestationStatus().WithItemValue(value),
	})
}

func (b *filterCndBuilderStatusAttestationStatus) ContainsAnyOf(values []*iam_iam_common.PCR) *FilterBuilder {
	pathSelector := NewDeviceFieldPathBuilder().Status().AttestationStatus()
	itemValues := make([]Device_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewDeviceFieldPathBuilder().Status().AttestationStatus().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderStatusAttestationStatus) ContainsAll(values []*iam_iam_common.PCR) *FilterBuilder {
	pathSelector := NewDeviceFieldPathBuilder().Status().AttestationStatus()
	itemValues := make([]Device_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewDeviceFieldPathBuilder().Status().AttestationStatus().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderStatusAttestationStatus) compare(op gotenfilter.CompareOperator, value []*iam_iam_common.PCR) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().AttestationStatus().WithValue(value),
	})
}

func (b *filterCndBuilderStatusAttestationStatus) Index() *filterCndBuilderStatusAttestationStatusIndex {
	return &filterCndBuilderStatusAttestationStatusIndex{builder: b.builder}
}

func (b *filterCndBuilderStatusAttestationStatus) DigestHex() *filterCndBuilderStatusAttestationStatusDigestHex {
	return &filterCndBuilderStatusAttestationStatusDigestHex{builder: b.builder}
}

func (b *filterCndBuilderStatusAttestationStatus) DigestAlg() *filterCndBuilderStatusAttestationStatusDigestAlg {
	return &filterCndBuilderStatusAttestationStatusDigestAlg{builder: b.builder}
}

func (b *filterCndBuilderStatusAttestationStatus) Comment() *filterCndBuilderStatusAttestationStatusComment {
	return &filterCndBuilderStatusAttestationStatusComment{builder: b.builder}
}

type filterCndBuilderStatusAttestationStatusIndex struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusAttestationStatusIndex) Eq(value uint32) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusAttestationStatusIndex) Neq(value uint32) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusAttestationStatusIndex) Gt(value uint32) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusAttestationStatusIndex) Gte(value uint32) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusAttestationStatusIndex) Lt(value uint32) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusAttestationStatusIndex) Lte(value uint32) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusAttestationStatusIndex) In(values []uint32) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().AttestationStatus().Index().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusAttestationStatusIndex) NotIn(values []uint32) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().AttestationStatus().Index().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusAttestationStatusIndex) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().AttestationStatus().Index().FieldPath(),
	})
}

func (b *filterCndBuilderStatusAttestationStatusIndex) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().AttestationStatus().Index().FieldPath(),
	})
}

func (b *filterCndBuilderStatusAttestationStatusIndex) compare(op gotenfilter.CompareOperator, value uint32) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().AttestationStatus().Index().WithValue(value),
	})
}

type filterCndBuilderStatusAttestationStatusDigestHex struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusAttestationStatusDigestHex) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusAttestationStatusDigestHex) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusAttestationStatusDigestHex) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusAttestationStatusDigestHex) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusAttestationStatusDigestHex) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusAttestationStatusDigestHex) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusAttestationStatusDigestHex) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().AttestationStatus().DigestHex().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusAttestationStatusDigestHex) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().AttestationStatus().DigestHex().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusAttestationStatusDigestHex) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().AttestationStatus().DigestHex().FieldPath(),
	})
}

func (b *filterCndBuilderStatusAttestationStatusDigestHex) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().AttestationStatus().DigestHex().FieldPath(),
	})
}

func (b *filterCndBuilderStatusAttestationStatusDigestHex) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().AttestationStatus().DigestHex().WithValue(value),
	})
}

type filterCndBuilderStatusAttestationStatusDigestAlg struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusAttestationStatusDigestAlg) Eq(value iam_iam_common.DigestAlg) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusAttestationStatusDigestAlg) Neq(value iam_iam_common.DigestAlg) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusAttestationStatusDigestAlg) Gt(value iam_iam_common.DigestAlg) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusAttestationStatusDigestAlg) Gte(value iam_iam_common.DigestAlg) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusAttestationStatusDigestAlg) Lt(value iam_iam_common.DigestAlg) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusAttestationStatusDigestAlg) Lte(value iam_iam_common.DigestAlg) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusAttestationStatusDigestAlg) In(values []iam_iam_common.DigestAlg) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().AttestationStatus().DigestAlg().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusAttestationStatusDigestAlg) NotIn(values []iam_iam_common.DigestAlg) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().AttestationStatus().DigestAlg().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusAttestationStatusDigestAlg) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().AttestationStatus().DigestAlg().FieldPath(),
	})
}

func (b *filterCndBuilderStatusAttestationStatusDigestAlg) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().AttestationStatus().DigestAlg().FieldPath(),
	})
}

func (b *filterCndBuilderStatusAttestationStatusDigestAlg) compare(op gotenfilter.CompareOperator, value iam_iam_common.DigestAlg) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().AttestationStatus().DigestAlg().WithValue(value),
	})
}

type filterCndBuilderStatusAttestationStatusComment struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusAttestationStatusComment) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusAttestationStatusComment) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusAttestationStatusComment) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusAttestationStatusComment) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusAttestationStatusComment) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusAttestationStatusComment) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusAttestationStatusComment) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().AttestationStatus().Comment().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusAttestationStatusComment) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().AttestationStatus().Comment().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusAttestationStatusComment) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().AttestationStatus().Comment().FieldPath(),
	})
}

func (b *filterCndBuilderStatusAttestationStatusComment) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().AttestationStatus().Comment().FieldPath(),
	})
}

func (b *filterCndBuilderStatusAttestationStatusComment) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().AttestationStatus().Comment().WithValue(value),
	})
}

type filterCndBuilderStatusNormalizedAddress struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusNormalizedAddress) Eq(value *Device_Status_NormalizedAddress) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusNormalizedAddress) Neq(value *Device_Status_NormalizedAddress) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusNormalizedAddress) Gt(value *Device_Status_NormalizedAddress) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusNormalizedAddress) Gte(value *Device_Status_NormalizedAddress) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusNormalizedAddress) Lt(value *Device_Status_NormalizedAddress) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusNormalizedAddress) Lte(value *Device_Status_NormalizedAddress) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusNormalizedAddress) In(values []*Device_Status_NormalizedAddress) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NormalizedAddress().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNormalizedAddress) NotIn(values []*Device_Status_NormalizedAddress) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NormalizedAddress().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNormalizedAddress) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().NormalizedAddress().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNormalizedAddress) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().NormalizedAddress().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNormalizedAddress) compare(op gotenfilter.CompareOperator, value *Device_Status_NormalizedAddress) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().NormalizedAddress().WithValue(value),
	})
}

func (b *filterCndBuilderStatusNormalizedAddress) PostalCode() *filterCndBuilderStatusNormalizedAddressPostalCode {
	return &filterCndBuilderStatusNormalizedAddressPostalCode{builder: b.builder}
}

func (b *filterCndBuilderStatusNormalizedAddress) CountryCode() *filterCndBuilderStatusNormalizedAddressCountryCode {
	return &filterCndBuilderStatusNormalizedAddressCountryCode{builder: b.builder}
}

func (b *filterCndBuilderStatusNormalizedAddress) Continent() *filterCndBuilderStatusNormalizedAddressContinent {
	return &filterCndBuilderStatusNormalizedAddressContinent{builder: b.builder}
}

func (b *filterCndBuilderStatusNormalizedAddress) ContinentId() *filterCndBuilderStatusNormalizedAddressContinentId {
	return &filterCndBuilderStatusNormalizedAddressContinentId{builder: b.builder}
}

func (b *filterCndBuilderStatusNormalizedAddress) Country() *filterCndBuilderStatusNormalizedAddressCountry {
	return &filterCndBuilderStatusNormalizedAddressCountry{builder: b.builder}
}

func (b *filterCndBuilderStatusNormalizedAddress) CountryId() *filterCndBuilderStatusNormalizedAddressCountryId {
	return &filterCndBuilderStatusNormalizedAddressCountryId{builder: b.builder}
}

func (b *filterCndBuilderStatusNormalizedAddress) AdminArea1() *filterCndBuilderStatusNormalizedAddressAdminArea1 {
	return &filterCndBuilderStatusNormalizedAddressAdminArea1{builder: b.builder}
}

func (b *filterCndBuilderStatusNormalizedAddress) AdminArea1Id() *filterCndBuilderStatusNormalizedAddressAdminArea1Id {
	return &filterCndBuilderStatusNormalizedAddressAdminArea1Id{builder: b.builder}
}

func (b *filterCndBuilderStatusNormalizedAddress) AdminArea2() *filterCndBuilderStatusNormalizedAddressAdminArea2 {
	return &filterCndBuilderStatusNormalizedAddressAdminArea2{builder: b.builder}
}

func (b *filterCndBuilderStatusNormalizedAddress) AdminArea2Id() *filterCndBuilderStatusNormalizedAddressAdminArea2Id {
	return &filterCndBuilderStatusNormalizedAddressAdminArea2Id{builder: b.builder}
}

func (b *filterCndBuilderStatusNormalizedAddress) AdminArea3() *filterCndBuilderStatusNormalizedAddressAdminArea3 {
	return &filterCndBuilderStatusNormalizedAddressAdminArea3{builder: b.builder}
}

func (b *filterCndBuilderStatusNormalizedAddress) AdminArea3Id() *filterCndBuilderStatusNormalizedAddressAdminArea3Id {
	return &filterCndBuilderStatusNormalizedAddressAdminArea3Id{builder: b.builder}
}

func (b *filterCndBuilderStatusNormalizedAddress) AdminArea4() *filterCndBuilderStatusNormalizedAddressAdminArea4 {
	return &filterCndBuilderStatusNormalizedAddressAdminArea4{builder: b.builder}
}

func (b *filterCndBuilderStatusNormalizedAddress) AdminArea4Id() *filterCndBuilderStatusNormalizedAddressAdminArea4Id {
	return &filterCndBuilderStatusNormalizedAddressAdminArea4Id{builder: b.builder}
}

func (b *filterCndBuilderStatusNormalizedAddress) Address() *filterCndBuilderStatusNormalizedAddressAddress {
	return &filterCndBuilderStatusNormalizedAddressAddress{builder: b.builder}
}

func (b *filterCndBuilderStatusNormalizedAddress) Coordinates() *filterCndBuilderStatusNormalizedAddressCoordinates {
	return &filterCndBuilderStatusNormalizedAddressCoordinates{builder: b.builder}
}

func (b *filterCndBuilderStatusNormalizedAddress) Accuracy() *filterCndBuilderStatusNormalizedAddressAccuracy {
	return &filterCndBuilderStatusNormalizedAddressAccuracy{builder: b.builder}
}

type filterCndBuilderStatusNormalizedAddressPostalCode struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusNormalizedAddressPostalCode) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusNormalizedAddressPostalCode) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusNormalizedAddressPostalCode) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusNormalizedAddressPostalCode) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusNormalizedAddressPostalCode) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusNormalizedAddressPostalCode) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusNormalizedAddressPostalCode) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NormalizedAddress().PostalCode().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNormalizedAddressPostalCode) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NormalizedAddress().PostalCode().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNormalizedAddressPostalCode) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().NormalizedAddress().PostalCode().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNormalizedAddressPostalCode) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().NormalizedAddress().PostalCode().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNormalizedAddressPostalCode) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().NormalizedAddress().PostalCode().WithValue(value),
	})
}

type filterCndBuilderStatusNormalizedAddressCountryCode struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusNormalizedAddressCountryCode) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusNormalizedAddressCountryCode) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusNormalizedAddressCountryCode) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusNormalizedAddressCountryCode) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusNormalizedAddressCountryCode) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusNormalizedAddressCountryCode) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusNormalizedAddressCountryCode) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NormalizedAddress().CountryCode().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNormalizedAddressCountryCode) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NormalizedAddress().CountryCode().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNormalizedAddressCountryCode) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().NormalizedAddress().CountryCode().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNormalizedAddressCountryCode) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().NormalizedAddress().CountryCode().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNormalizedAddressCountryCode) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().NormalizedAddress().CountryCode().WithValue(value),
	})
}

type filterCndBuilderStatusNormalizedAddressContinent struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusNormalizedAddressContinent) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusNormalizedAddressContinent) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusNormalizedAddressContinent) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusNormalizedAddressContinent) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusNormalizedAddressContinent) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusNormalizedAddressContinent) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusNormalizedAddressContinent) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NormalizedAddress().Continent().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNormalizedAddressContinent) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NormalizedAddress().Continent().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNormalizedAddressContinent) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().NormalizedAddress().Continent().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNormalizedAddressContinent) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().NormalizedAddress().Continent().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNormalizedAddressContinent) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().NormalizedAddress().Continent().WithValue(value),
	})
}

type filterCndBuilderStatusNormalizedAddressContinentId struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusNormalizedAddressContinentId) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusNormalizedAddressContinentId) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusNormalizedAddressContinentId) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusNormalizedAddressContinentId) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusNormalizedAddressContinentId) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusNormalizedAddressContinentId) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusNormalizedAddressContinentId) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NormalizedAddress().ContinentId().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNormalizedAddressContinentId) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NormalizedAddress().ContinentId().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNormalizedAddressContinentId) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().NormalizedAddress().ContinentId().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNormalizedAddressContinentId) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().NormalizedAddress().ContinentId().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNormalizedAddressContinentId) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().NormalizedAddress().ContinentId().WithValue(value),
	})
}

type filterCndBuilderStatusNormalizedAddressCountry struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusNormalizedAddressCountry) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusNormalizedAddressCountry) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusNormalizedAddressCountry) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusNormalizedAddressCountry) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusNormalizedAddressCountry) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusNormalizedAddressCountry) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusNormalizedAddressCountry) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NormalizedAddress().Country().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNormalizedAddressCountry) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NormalizedAddress().Country().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNormalizedAddressCountry) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().NormalizedAddress().Country().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNormalizedAddressCountry) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().NormalizedAddress().Country().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNormalizedAddressCountry) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().NormalizedAddress().Country().WithValue(value),
	})
}

type filterCndBuilderStatusNormalizedAddressCountryId struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusNormalizedAddressCountryId) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusNormalizedAddressCountryId) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusNormalizedAddressCountryId) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusNormalizedAddressCountryId) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusNormalizedAddressCountryId) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusNormalizedAddressCountryId) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusNormalizedAddressCountryId) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NormalizedAddress().CountryId().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNormalizedAddressCountryId) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NormalizedAddress().CountryId().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNormalizedAddressCountryId) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().NormalizedAddress().CountryId().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNormalizedAddressCountryId) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().NormalizedAddress().CountryId().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNormalizedAddressCountryId) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().NormalizedAddress().CountryId().WithValue(value),
	})
}

type filterCndBuilderStatusNormalizedAddressAdminArea1 struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusNormalizedAddressAdminArea1) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusNormalizedAddressAdminArea1) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusNormalizedAddressAdminArea1) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusNormalizedAddressAdminArea1) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusNormalizedAddressAdminArea1) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusNormalizedAddressAdminArea1) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusNormalizedAddressAdminArea1) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NormalizedAddress().AdminArea1().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNormalizedAddressAdminArea1) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NormalizedAddress().AdminArea1().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNormalizedAddressAdminArea1) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().NormalizedAddress().AdminArea1().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNormalizedAddressAdminArea1) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().NormalizedAddress().AdminArea1().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNormalizedAddressAdminArea1) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().NormalizedAddress().AdminArea1().WithValue(value),
	})
}

type filterCndBuilderStatusNormalizedAddressAdminArea1Id struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusNormalizedAddressAdminArea1Id) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusNormalizedAddressAdminArea1Id) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusNormalizedAddressAdminArea1Id) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusNormalizedAddressAdminArea1Id) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusNormalizedAddressAdminArea1Id) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusNormalizedAddressAdminArea1Id) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusNormalizedAddressAdminArea1Id) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NormalizedAddress().AdminArea1Id().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNormalizedAddressAdminArea1Id) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NormalizedAddress().AdminArea1Id().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNormalizedAddressAdminArea1Id) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().NormalizedAddress().AdminArea1Id().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNormalizedAddressAdminArea1Id) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().NormalizedAddress().AdminArea1Id().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNormalizedAddressAdminArea1Id) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().NormalizedAddress().AdminArea1Id().WithValue(value),
	})
}

type filterCndBuilderStatusNormalizedAddressAdminArea2 struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusNormalizedAddressAdminArea2) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusNormalizedAddressAdminArea2) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusNormalizedAddressAdminArea2) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusNormalizedAddressAdminArea2) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusNormalizedAddressAdminArea2) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusNormalizedAddressAdminArea2) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusNormalizedAddressAdminArea2) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NormalizedAddress().AdminArea2().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNormalizedAddressAdminArea2) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NormalizedAddress().AdminArea2().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNormalizedAddressAdminArea2) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().NormalizedAddress().AdminArea2().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNormalizedAddressAdminArea2) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().NormalizedAddress().AdminArea2().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNormalizedAddressAdminArea2) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().NormalizedAddress().AdminArea2().WithValue(value),
	})
}

type filterCndBuilderStatusNormalizedAddressAdminArea2Id struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusNormalizedAddressAdminArea2Id) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusNormalizedAddressAdminArea2Id) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusNormalizedAddressAdminArea2Id) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusNormalizedAddressAdminArea2Id) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusNormalizedAddressAdminArea2Id) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusNormalizedAddressAdminArea2Id) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusNormalizedAddressAdminArea2Id) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NormalizedAddress().AdminArea2Id().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNormalizedAddressAdminArea2Id) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NormalizedAddress().AdminArea2Id().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNormalizedAddressAdminArea2Id) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().NormalizedAddress().AdminArea2Id().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNormalizedAddressAdminArea2Id) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().NormalizedAddress().AdminArea2Id().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNormalizedAddressAdminArea2Id) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().NormalizedAddress().AdminArea2Id().WithValue(value),
	})
}

type filterCndBuilderStatusNormalizedAddressAdminArea3 struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusNormalizedAddressAdminArea3) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusNormalizedAddressAdminArea3) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusNormalizedAddressAdminArea3) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusNormalizedAddressAdminArea3) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusNormalizedAddressAdminArea3) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusNormalizedAddressAdminArea3) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusNormalizedAddressAdminArea3) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NormalizedAddress().AdminArea3().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNormalizedAddressAdminArea3) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NormalizedAddress().AdminArea3().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNormalizedAddressAdminArea3) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().NormalizedAddress().AdminArea3().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNormalizedAddressAdminArea3) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().NormalizedAddress().AdminArea3().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNormalizedAddressAdminArea3) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().NormalizedAddress().AdminArea3().WithValue(value),
	})
}

type filterCndBuilderStatusNormalizedAddressAdminArea3Id struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusNormalizedAddressAdminArea3Id) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusNormalizedAddressAdminArea3Id) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusNormalizedAddressAdminArea3Id) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusNormalizedAddressAdminArea3Id) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusNormalizedAddressAdminArea3Id) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusNormalizedAddressAdminArea3Id) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusNormalizedAddressAdminArea3Id) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NormalizedAddress().AdminArea3Id().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNormalizedAddressAdminArea3Id) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NormalizedAddress().AdminArea3Id().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNormalizedAddressAdminArea3Id) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().NormalizedAddress().AdminArea3Id().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNormalizedAddressAdminArea3Id) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().NormalizedAddress().AdminArea3Id().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNormalizedAddressAdminArea3Id) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().NormalizedAddress().AdminArea3Id().WithValue(value),
	})
}

type filterCndBuilderStatusNormalizedAddressAdminArea4 struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusNormalizedAddressAdminArea4) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusNormalizedAddressAdminArea4) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusNormalizedAddressAdminArea4) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusNormalizedAddressAdminArea4) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusNormalizedAddressAdminArea4) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusNormalizedAddressAdminArea4) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusNormalizedAddressAdminArea4) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NormalizedAddress().AdminArea4().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNormalizedAddressAdminArea4) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NormalizedAddress().AdminArea4().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNormalizedAddressAdminArea4) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().NormalizedAddress().AdminArea4().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNormalizedAddressAdminArea4) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().NormalizedAddress().AdminArea4().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNormalizedAddressAdminArea4) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().NormalizedAddress().AdminArea4().WithValue(value),
	})
}

type filterCndBuilderStatusNormalizedAddressAdminArea4Id struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusNormalizedAddressAdminArea4Id) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusNormalizedAddressAdminArea4Id) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusNormalizedAddressAdminArea4Id) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusNormalizedAddressAdminArea4Id) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusNormalizedAddressAdminArea4Id) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusNormalizedAddressAdminArea4Id) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusNormalizedAddressAdminArea4Id) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NormalizedAddress().AdminArea4Id().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNormalizedAddressAdminArea4Id) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NormalizedAddress().AdminArea4Id().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNormalizedAddressAdminArea4Id) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().NormalizedAddress().AdminArea4Id().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNormalizedAddressAdminArea4Id) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().NormalizedAddress().AdminArea4Id().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNormalizedAddressAdminArea4Id) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().NormalizedAddress().AdminArea4Id().WithValue(value),
	})
}

type filterCndBuilderStatusNormalizedAddressAddress struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusNormalizedAddressAddress) Eq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusNormalizedAddressAddress) Neq(value string) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusNormalizedAddressAddress) Gt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusNormalizedAddressAddress) Gte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusNormalizedAddressAddress) Lt(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusNormalizedAddressAddress) Lte(value string) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusNormalizedAddressAddress) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NormalizedAddress().Address().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNormalizedAddressAddress) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NormalizedAddress().Address().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNormalizedAddressAddress) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().NormalizedAddress().Address().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNormalizedAddressAddress) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().NormalizedAddress().Address().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNormalizedAddressAddress) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().NormalizedAddress().Address().WithValue(value),
	})
}

type filterCndBuilderStatusNormalizedAddressCoordinates struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusNormalizedAddressCoordinates) Eq(value *latlng.LatLng) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusNormalizedAddressCoordinates) Neq(value *latlng.LatLng) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusNormalizedAddressCoordinates) Gt(value *latlng.LatLng) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusNormalizedAddressCoordinates) Gte(value *latlng.LatLng) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusNormalizedAddressCoordinates) Lt(value *latlng.LatLng) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusNormalizedAddressCoordinates) Lte(value *latlng.LatLng) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusNormalizedAddressCoordinates) In(values []*latlng.LatLng) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NormalizedAddress().Coordinates().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNormalizedAddressCoordinates) NotIn(values []*latlng.LatLng) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NormalizedAddress().Coordinates().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNormalizedAddressCoordinates) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().NormalizedAddress().Coordinates().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNormalizedAddressCoordinates) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().NormalizedAddress().Coordinates().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNormalizedAddressCoordinates) compare(op gotenfilter.CompareOperator, value *latlng.LatLng) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().NormalizedAddress().Coordinates().WithValue(value),
	})
}

type filterCndBuilderStatusNormalizedAddressAccuracy struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusNormalizedAddressAccuracy) Eq(value float64) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusNormalizedAddressAccuracy) Neq(value float64) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusNormalizedAddressAccuracy) Gt(value float64) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusNormalizedAddressAccuracy) Gte(value float64) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusNormalizedAddressAccuracy) Lt(value float64) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusNormalizedAddressAccuracy) Lte(value float64) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusNormalizedAddressAccuracy) In(values []float64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NormalizedAddress().Accuracy().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNormalizedAddressAccuracy) NotIn(values []float64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NormalizedAddress().Accuracy().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNormalizedAddressAccuracy) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().NormalizedAddress().Accuracy().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNormalizedAddressAccuracy) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().NormalizedAddress().Accuracy().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNormalizedAddressAccuracy) compare(op gotenfilter.CompareOperator, value float64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().NormalizedAddress().Accuracy().WithValue(value),
	})
}

type filterCndBuilderStatusConnectionStatus struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusConnectionStatus) Eq(value Device_Status_ConnectionStatus) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusConnectionStatus) Neq(value Device_Status_ConnectionStatus) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusConnectionStatus) Gt(value Device_Status_ConnectionStatus) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusConnectionStatus) Gte(value Device_Status_ConnectionStatus) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusConnectionStatus) Lt(value Device_Status_ConnectionStatus) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusConnectionStatus) Lte(value Device_Status_ConnectionStatus) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusConnectionStatus) In(values []Device_Status_ConnectionStatus) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().ConnectionStatus().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusConnectionStatus) NotIn(values []Device_Status_ConnectionStatus) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().ConnectionStatus().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusConnectionStatus) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().ConnectionStatus().FieldPath(),
	})
}

func (b *filterCndBuilderStatusConnectionStatus) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().ConnectionStatus().FieldPath(),
	})
}

func (b *filterCndBuilderStatusConnectionStatus) compare(op gotenfilter.CompareOperator, value Device_Status_ConnectionStatus) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().ConnectionStatus().WithValue(value),
	})
}

type filterCndBuilderStatusConnectionStatusChangeTime struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusConnectionStatusChangeTime) Eq(value *timestamppb.Timestamp) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusConnectionStatusChangeTime) Neq(value *timestamppb.Timestamp) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusConnectionStatusChangeTime) Gt(value *timestamppb.Timestamp) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusConnectionStatusChangeTime) Gte(value *timestamppb.Timestamp) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusConnectionStatusChangeTime) Lt(value *timestamppb.Timestamp) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusConnectionStatusChangeTime) Lte(value *timestamppb.Timestamp) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusConnectionStatusChangeTime) In(values []*timestamppb.Timestamp) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().ConnectionStatusChangeTime().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusConnectionStatusChangeTime) NotIn(values []*timestamppb.Timestamp) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().ConnectionStatusChangeTime().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusConnectionStatusChangeTime) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().ConnectionStatusChangeTime().FieldPath(),
	})
}

func (b *filterCndBuilderStatusConnectionStatusChangeTime) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().ConnectionStatusChangeTime().FieldPath(),
	})
}

func (b *filterCndBuilderStatusConnectionStatusChangeTime) compare(op gotenfilter.CompareOperator, value *timestamppb.Timestamp) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().ConnectionStatusChangeTime().WithValue(value),
	})
}

type filterCndBuilderPublicListingSpec struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderPublicListingSpec) Eq(value *Device_PublicListingSpec) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderPublicListingSpec) Neq(value *Device_PublicListingSpec) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderPublicListingSpec) Gt(value *Device_PublicListingSpec) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderPublicListingSpec) Gte(value *Device_PublicListingSpec) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderPublicListingSpec) Lt(value *Device_PublicListingSpec) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderPublicListingSpec) Lte(value *Device_PublicListingSpec) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderPublicListingSpec) In(values []*Device_PublicListingSpec) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().PublicListingSpec().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderPublicListingSpec) NotIn(values []*Device_PublicListingSpec) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().PublicListingSpec().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderPublicListingSpec) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().PublicListingSpec().FieldPath(),
	})
}

func (b *filterCndBuilderPublicListingSpec) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().PublicListingSpec().FieldPath(),
	})
}

func (b *filterCndBuilderPublicListingSpec) compare(op gotenfilter.CompareOperator, value *Device_PublicListingSpec) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().PublicListingSpec().WithValue(value),
	})
}

func (b *filterCndBuilderPublicListingSpec) Enabled() *filterCndBuilderPublicListingSpecEnabled {
	return &filterCndBuilderPublicListingSpecEnabled{builder: b.builder}
}

func (b *filterCndBuilderPublicListingSpec) FieldMask() *filterCndBuilderPublicListingSpecFieldMask {
	return &filterCndBuilderPublicListingSpecFieldMask{builder: b.builder}
}

type filterCndBuilderPublicListingSpecEnabled struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderPublicListingSpecEnabled) Eq(value bool) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderPublicListingSpecEnabled) Neq(value bool) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderPublicListingSpecEnabled) Gt(value bool) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderPublicListingSpecEnabled) Gte(value bool) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderPublicListingSpecEnabled) Lt(value bool) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderPublicListingSpecEnabled) Lte(value bool) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderPublicListingSpecEnabled) In(values []bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().PublicListingSpec().Enabled().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderPublicListingSpecEnabled) NotIn(values []bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().PublicListingSpec().Enabled().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderPublicListingSpecEnabled) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().PublicListingSpec().Enabled().FieldPath(),
	})
}

func (b *filterCndBuilderPublicListingSpecEnabled) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().PublicListingSpec().Enabled().FieldPath(),
	})
}

func (b *filterCndBuilderPublicListingSpecEnabled) compare(op gotenfilter.CompareOperator, value bool) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().PublicListingSpec().Enabled().WithValue(value),
	})
}

type filterCndBuilderPublicListingSpecFieldMask struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderPublicListingSpecFieldMask) Eq(value *Device_FieldMask) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderPublicListingSpecFieldMask) Neq(value *Device_FieldMask) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderPublicListingSpecFieldMask) Gt(value *Device_FieldMask) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderPublicListingSpecFieldMask) Gte(value *Device_FieldMask) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderPublicListingSpecFieldMask) Lt(value *Device_FieldMask) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderPublicListingSpecFieldMask) Lte(value *Device_FieldMask) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderPublicListingSpecFieldMask) In(values []*Device_FieldMask) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().PublicListingSpec().FieldMask().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderPublicListingSpecFieldMask) NotIn(values []*Device_FieldMask) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().PublicListingSpec().FieldMask().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderPublicListingSpecFieldMask) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().PublicListingSpec().FieldMask().FieldPath(),
	})
}

func (b *filterCndBuilderPublicListingSpecFieldMask) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().PublicListingSpec().FieldMask().FieldPath(),
	})
}

func (b *filterCndBuilderPublicListingSpecFieldMask) compare(op gotenfilter.CompareOperator, value *Device_FieldMask) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().PublicListingSpec().FieldMask().WithValue(value),
	})
}