github.com/cloudwan/edgelq-sdk@v1.15.4/devices/resources/v1alpha2/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 (
	project "github.com/cloudwan/edgelq-sdk/devices/resources/v1alpha2/project"
	iam_attestation_domain "github.com/cloudwan/edgelq-sdk/iam/resources/v1alpha2/attestation_domain"
	iam_iam_common "github.com/cloudwan/edgelq-sdk/iam/resources/v1alpha2/common"
	iam_organization "github.com/cloudwan/edgelq-sdk/iam/resources/v1alpha2/organization"
	iam_project "github.com/cloudwan/edgelq-sdk/iam/resources/v1alpha2/project"
	iam_service_account "github.com/cloudwan/edgelq-sdk/iam/resources/v1alpha2/service_account"
	meta_service "github.com/cloudwan/edgelq-sdk/meta/resources/v1alpha2/service"
	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 (
	_ = &project.Project{}
	_ = &iam_attestation_domain.AttestationDomain{}
	_ = &iam_iam_common.PCR{}
	_ = &iam_organization.Organization{}
	_ = &iam_project.Project{}
	_ = &iam_service_account.ServiceAccount{}
	_ = &meta_service.Service{}
	_ = &durationpb.Duration{}
	_ = &fieldmaskpb.FieldMask{}
	_ = &timestamppb.Timestamp{}
	_ = &latlng.LatLng{}
	_ = &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) 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}
}

func (b *filterCndBuilder) DisplayName() *filterCndBuilderDisplayName {
	return &filterCndBuilderDisplayName{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 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) OsVersion() *filterCndBuilderSpecOsVersion {
	return &filterCndBuilderSpecOsVersion{builder: b.builder}
}

func (b *filterCndBuilderSpec) NetplanConfig() *filterCndBuilderSpecNetplanConfig {
	return &filterCndBuilderSpecNetplanConfig{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}
}

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 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 filterCndBuilderSpecNetplanConfig struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderSpecNetplanConfig) Eq(value *Device_Spec_NetplanConfig) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderSpecNetplanConfig) Neq(value *Device_Spec_NetplanConfig) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderSpecNetplanConfig) Gt(value *Device_Spec_NetplanConfig) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderSpecNetplanConfig) Gte(value *Device_Spec_NetplanConfig) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderSpecNetplanConfig) Lt(value *Device_Spec_NetplanConfig) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderSpecNetplanConfig) Lte(value *Device_Spec_NetplanConfig) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

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

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

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

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

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

func (b *filterCndBuilderSpecNetplanConfig) Network() *filterCndBuilderSpecNetplanConfigNetwork {
	return &filterCndBuilderSpecNetplanConfigNetwork{builder: b.builder}
}

type filterCndBuilderSpecNetplanConfigNetwork struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderSpecNetplanConfigNetwork) Eq(value *Device_Spec_NetworkingConfig) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderSpecNetplanConfigNetwork) Neq(value *Device_Spec_NetworkingConfig) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderSpecNetplanConfigNetwork) Gt(value *Device_Spec_NetworkingConfig) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderSpecNetplanConfigNetwork) Gte(value *Device_Spec_NetworkingConfig) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderSpecNetplanConfigNetwork) Lt(value *Device_Spec_NetworkingConfig) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderSpecNetplanConfigNetwork) Lte(value *Device_Spec_NetworkingConfig) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

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

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

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

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

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

func (b *filterCndBuilderSpecNetplanConfigNetwork) Version() *filterCndBuilderSpecNetplanConfigNetworkVersion {
	return &filterCndBuilderSpecNetplanConfigNetworkVersion{builder: b.builder}
}

func (b *filterCndBuilderSpecNetplanConfigNetwork) Renderer() *filterCndBuilderSpecNetplanConfigNetworkRenderer {
	return &filterCndBuilderSpecNetplanConfigNetworkRenderer{builder: b.builder}
}

func (b *filterCndBuilderSpecNetplanConfigNetwork) Ethernets() *filterCndBuilderSpecNetplanConfigNetworkEthernets {
	return &filterCndBuilderSpecNetplanConfigNetworkEthernets{builder: b.builder}
}

func (b *filterCndBuilderSpecNetplanConfigNetwork) Wifis() *filterCndBuilderSpecNetplanConfigNetworkWifis {
	return &filterCndBuilderSpecNetplanConfigNetworkWifis{builder: b.builder}
}

func (b *filterCndBuilderSpecNetplanConfigNetwork) Bridges() *filterCndBuilderSpecNetplanConfigNetworkBridges {
	return &filterCndBuilderSpecNetplanConfigNetworkBridges{builder: b.builder}
}

func (b *filterCndBuilderSpecNetplanConfigNetwork) Bonds() *filterCndBuilderSpecNetplanConfigNetworkBonds {
	return &filterCndBuilderSpecNetplanConfigNetworkBonds{builder: b.builder}
}

func (b *filterCndBuilderSpecNetplanConfigNetwork) Tunnels() *filterCndBuilderSpecNetplanConfigNetworkTunnels {
	return &filterCndBuilderSpecNetplanConfigNetworkTunnels{builder: b.builder}
}

func (b *filterCndBuilderSpecNetplanConfigNetwork) Vlans() *filterCndBuilderSpecNetplanConfigNetworkVlans {
	return &filterCndBuilderSpecNetplanConfigNetworkVlans{builder: b.builder}
}

func (b *filterCndBuilderSpecNetplanConfigNetwork) Modems() *filterCndBuilderSpecNetplanConfigNetworkModems {
	return &filterCndBuilderSpecNetplanConfigNetworkModems{builder: b.builder}
}

type filterCndBuilderSpecNetplanConfigNetworkVersion struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecNetplanConfigNetworkVersion) In(values []int32) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().NetplanConfig().Network().Version().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecNetplanConfigNetworkVersion) NotIn(values []int32) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().NetplanConfig().Network().Version().WithArrayOfValues(values),
	})
}

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

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

func (b *filterCndBuilderSpecNetplanConfigNetworkVersion) compare(op gotenfilter.CompareOperator, value int32) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Spec().NetplanConfig().Network().Version().WithValue(value),
	})
}

type filterCndBuilderSpecNetplanConfigNetworkRenderer struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

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

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

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

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

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

type filterCndBuilderSpecNetplanConfigNetworkEthernets struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecNetplanConfigNetworkEthernets) In(values []map[string]*Device_Spec_NetworkingConfig_EthOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().NetplanConfig().Network().Ethernets().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecNetplanConfigNetworkEthernets) NotIn(values []map[string]*Device_Spec_NetworkingConfig_EthOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().NetplanConfig().Network().Ethernets().WithArrayOfValues(values),
	})
}

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

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

func (b *filterCndBuilderSpecNetplanConfigNetworkEthernets) compare(op gotenfilter.CompareOperator, value map[string]*Device_Spec_NetworkingConfig_EthOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Spec().NetplanConfig().Network().Ethernets().WithValue(value),
	})
}

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

type mapFilterCndBuilderSpecNetplanConfigNetworkEthernets struct {
	builder *FilterBuilder
	key     string
}

func (b *mapFilterCndBuilderSpecNetplanConfigNetworkEthernets) Eq(value *Device_Spec_NetworkingConfig_EthOpts) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *mapFilterCndBuilderSpecNetplanConfigNetworkEthernets) Neq(value *Device_Spec_NetworkingConfig_EthOpts) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *mapFilterCndBuilderSpecNetplanConfigNetworkEthernets) Gt(value *Device_Spec_NetworkingConfig_EthOpts) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *mapFilterCndBuilderSpecNetplanConfigNetworkEthernets) Gte(value *Device_Spec_NetworkingConfig_EthOpts) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *mapFilterCndBuilderSpecNetplanConfigNetworkEthernets) Lt(value *Device_Spec_NetworkingConfig_EthOpts) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *mapFilterCndBuilderSpecNetplanConfigNetworkEthernets) Lte(value *Device_Spec_NetworkingConfig_EthOpts) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *mapFilterCndBuilderSpecNetplanConfigNetworkEthernets) In(values []*Device_Spec_NetworkingConfig_EthOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().NetplanConfig().Network().Ethernets().WithKey(b.key).WithArrayOfValues(values),
	})
}

func (b *mapFilterCndBuilderSpecNetplanConfigNetworkEthernets) NotIn(values []*Device_Spec_NetworkingConfig_EthOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().NetplanConfig().Network().Ethernets().WithKey(b.key).WithArrayOfValues(values),
	})
}

func (b *mapFilterCndBuilderSpecNetplanConfigNetworkEthernets) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Spec().NetplanConfig().Network().Ethernets().WithKey(b.key).FieldPath(),
	})
}

func (b *mapFilterCndBuilderSpecNetplanConfigNetworkEthernets) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Spec().NetplanConfig().Network().Ethernets().WithKey(b.key).FieldPath(),
	})
}

func (b *mapFilterCndBuilderSpecNetplanConfigNetworkEthernets) compare(op gotenfilter.CompareOperator, value *Device_Spec_NetworkingConfig_EthOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Spec().NetplanConfig().Network().Ethernets().WithKey(b.key).WithValue(value),
	})
}

type filterCndBuilderSpecNetplanConfigNetworkWifis struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecNetplanConfigNetworkWifis) In(values []map[string]*Device_Spec_NetworkingConfig_WifiOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().NetplanConfig().Network().Wifis().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecNetplanConfigNetworkWifis) NotIn(values []map[string]*Device_Spec_NetworkingConfig_WifiOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().NetplanConfig().Network().Wifis().WithArrayOfValues(values),
	})
}

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

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

func (b *filterCndBuilderSpecNetplanConfigNetworkWifis) compare(op gotenfilter.CompareOperator, value map[string]*Device_Spec_NetworkingConfig_WifiOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Spec().NetplanConfig().Network().Wifis().WithValue(value),
	})
}

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

type mapFilterCndBuilderSpecNetplanConfigNetworkWifis struct {
	builder *FilterBuilder
	key     string
}

func (b *mapFilterCndBuilderSpecNetplanConfigNetworkWifis) Eq(value *Device_Spec_NetworkingConfig_WifiOpts) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *mapFilterCndBuilderSpecNetplanConfigNetworkWifis) Neq(value *Device_Spec_NetworkingConfig_WifiOpts) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *mapFilterCndBuilderSpecNetplanConfigNetworkWifis) Gt(value *Device_Spec_NetworkingConfig_WifiOpts) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *mapFilterCndBuilderSpecNetplanConfigNetworkWifis) Gte(value *Device_Spec_NetworkingConfig_WifiOpts) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *mapFilterCndBuilderSpecNetplanConfigNetworkWifis) Lt(value *Device_Spec_NetworkingConfig_WifiOpts) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *mapFilterCndBuilderSpecNetplanConfigNetworkWifis) Lte(value *Device_Spec_NetworkingConfig_WifiOpts) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *mapFilterCndBuilderSpecNetplanConfigNetworkWifis) In(values []*Device_Spec_NetworkingConfig_WifiOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().NetplanConfig().Network().Wifis().WithKey(b.key).WithArrayOfValues(values),
	})
}

func (b *mapFilterCndBuilderSpecNetplanConfigNetworkWifis) NotIn(values []*Device_Spec_NetworkingConfig_WifiOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().NetplanConfig().Network().Wifis().WithKey(b.key).WithArrayOfValues(values),
	})
}

func (b *mapFilterCndBuilderSpecNetplanConfigNetworkWifis) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Spec().NetplanConfig().Network().Wifis().WithKey(b.key).FieldPath(),
	})
}

func (b *mapFilterCndBuilderSpecNetplanConfigNetworkWifis) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Spec().NetplanConfig().Network().Wifis().WithKey(b.key).FieldPath(),
	})
}

func (b *mapFilterCndBuilderSpecNetplanConfigNetworkWifis) compare(op gotenfilter.CompareOperator, value *Device_Spec_NetworkingConfig_WifiOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Spec().NetplanConfig().Network().Wifis().WithKey(b.key).WithValue(value),
	})
}

type filterCndBuilderSpecNetplanConfigNetworkBridges struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecNetplanConfigNetworkBridges) In(values []map[string]*Device_Spec_NetworkingConfig_BridgesOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().NetplanConfig().Network().Bridges().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecNetplanConfigNetworkBridges) NotIn(values []map[string]*Device_Spec_NetworkingConfig_BridgesOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().NetplanConfig().Network().Bridges().WithArrayOfValues(values),
	})
}

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

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

func (b *filterCndBuilderSpecNetplanConfigNetworkBridges) compare(op gotenfilter.CompareOperator, value map[string]*Device_Spec_NetworkingConfig_BridgesOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Spec().NetplanConfig().Network().Bridges().WithValue(value),
	})
}

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

type mapFilterCndBuilderSpecNetplanConfigNetworkBridges struct {
	builder *FilterBuilder
	key     string
}

func (b *mapFilterCndBuilderSpecNetplanConfigNetworkBridges) Eq(value *Device_Spec_NetworkingConfig_BridgesOpts) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *mapFilterCndBuilderSpecNetplanConfigNetworkBridges) Neq(value *Device_Spec_NetworkingConfig_BridgesOpts) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *mapFilterCndBuilderSpecNetplanConfigNetworkBridges) Gt(value *Device_Spec_NetworkingConfig_BridgesOpts) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *mapFilterCndBuilderSpecNetplanConfigNetworkBridges) Gte(value *Device_Spec_NetworkingConfig_BridgesOpts) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *mapFilterCndBuilderSpecNetplanConfigNetworkBridges) Lt(value *Device_Spec_NetworkingConfig_BridgesOpts) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *mapFilterCndBuilderSpecNetplanConfigNetworkBridges) Lte(value *Device_Spec_NetworkingConfig_BridgesOpts) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *mapFilterCndBuilderSpecNetplanConfigNetworkBridges) In(values []*Device_Spec_NetworkingConfig_BridgesOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().NetplanConfig().Network().Bridges().WithKey(b.key).WithArrayOfValues(values),
	})
}

func (b *mapFilterCndBuilderSpecNetplanConfigNetworkBridges) NotIn(values []*Device_Spec_NetworkingConfig_BridgesOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().NetplanConfig().Network().Bridges().WithKey(b.key).WithArrayOfValues(values),
	})
}

func (b *mapFilterCndBuilderSpecNetplanConfigNetworkBridges) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Spec().NetplanConfig().Network().Bridges().WithKey(b.key).FieldPath(),
	})
}

func (b *mapFilterCndBuilderSpecNetplanConfigNetworkBridges) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Spec().NetplanConfig().Network().Bridges().WithKey(b.key).FieldPath(),
	})
}

func (b *mapFilterCndBuilderSpecNetplanConfigNetworkBridges) compare(op gotenfilter.CompareOperator, value *Device_Spec_NetworkingConfig_BridgesOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Spec().NetplanConfig().Network().Bridges().WithKey(b.key).WithValue(value),
	})
}

type filterCndBuilderSpecNetplanConfigNetworkBonds struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecNetplanConfigNetworkBonds) In(values []map[string]*Device_Spec_NetworkingConfig_BondsOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().NetplanConfig().Network().Bonds().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecNetplanConfigNetworkBonds) NotIn(values []map[string]*Device_Spec_NetworkingConfig_BondsOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().NetplanConfig().Network().Bonds().WithArrayOfValues(values),
	})
}

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

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

func (b *filterCndBuilderSpecNetplanConfigNetworkBonds) compare(op gotenfilter.CompareOperator, value map[string]*Device_Spec_NetworkingConfig_BondsOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Spec().NetplanConfig().Network().Bonds().WithValue(value),
	})
}

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

type mapFilterCndBuilderSpecNetplanConfigNetworkBonds struct {
	builder *FilterBuilder
	key     string
}

func (b *mapFilterCndBuilderSpecNetplanConfigNetworkBonds) Eq(value *Device_Spec_NetworkingConfig_BondsOpts) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *mapFilterCndBuilderSpecNetplanConfigNetworkBonds) Neq(value *Device_Spec_NetworkingConfig_BondsOpts) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *mapFilterCndBuilderSpecNetplanConfigNetworkBonds) Gt(value *Device_Spec_NetworkingConfig_BondsOpts) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *mapFilterCndBuilderSpecNetplanConfigNetworkBonds) Gte(value *Device_Spec_NetworkingConfig_BondsOpts) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *mapFilterCndBuilderSpecNetplanConfigNetworkBonds) Lt(value *Device_Spec_NetworkingConfig_BondsOpts) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *mapFilterCndBuilderSpecNetplanConfigNetworkBonds) Lte(value *Device_Spec_NetworkingConfig_BondsOpts) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *mapFilterCndBuilderSpecNetplanConfigNetworkBonds) In(values []*Device_Spec_NetworkingConfig_BondsOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().NetplanConfig().Network().Bonds().WithKey(b.key).WithArrayOfValues(values),
	})
}

func (b *mapFilterCndBuilderSpecNetplanConfigNetworkBonds) NotIn(values []*Device_Spec_NetworkingConfig_BondsOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().NetplanConfig().Network().Bonds().WithKey(b.key).WithArrayOfValues(values),
	})
}

func (b *mapFilterCndBuilderSpecNetplanConfigNetworkBonds) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Spec().NetplanConfig().Network().Bonds().WithKey(b.key).FieldPath(),
	})
}

func (b *mapFilterCndBuilderSpecNetplanConfigNetworkBonds) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Spec().NetplanConfig().Network().Bonds().WithKey(b.key).FieldPath(),
	})
}

func (b *mapFilterCndBuilderSpecNetplanConfigNetworkBonds) compare(op gotenfilter.CompareOperator, value *Device_Spec_NetworkingConfig_BondsOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Spec().NetplanConfig().Network().Bonds().WithKey(b.key).WithValue(value),
	})
}

type filterCndBuilderSpecNetplanConfigNetworkTunnels struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecNetplanConfigNetworkTunnels) In(values []map[string]*Device_Spec_NetworkingConfig_TunnelsOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().NetplanConfig().Network().Tunnels().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecNetplanConfigNetworkTunnels) NotIn(values []map[string]*Device_Spec_NetworkingConfig_TunnelsOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().NetplanConfig().Network().Tunnels().WithArrayOfValues(values),
	})
}

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

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

func (b *filterCndBuilderSpecNetplanConfigNetworkTunnels) compare(op gotenfilter.CompareOperator, value map[string]*Device_Spec_NetworkingConfig_TunnelsOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Spec().NetplanConfig().Network().Tunnels().WithValue(value),
	})
}

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

type mapFilterCndBuilderSpecNetplanConfigNetworkTunnels struct {
	builder *FilterBuilder
	key     string
}

func (b *mapFilterCndBuilderSpecNetplanConfigNetworkTunnels) Eq(value *Device_Spec_NetworkingConfig_TunnelsOpts) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *mapFilterCndBuilderSpecNetplanConfigNetworkTunnels) Neq(value *Device_Spec_NetworkingConfig_TunnelsOpts) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *mapFilterCndBuilderSpecNetplanConfigNetworkTunnels) Gt(value *Device_Spec_NetworkingConfig_TunnelsOpts) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *mapFilterCndBuilderSpecNetplanConfigNetworkTunnels) Gte(value *Device_Spec_NetworkingConfig_TunnelsOpts) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *mapFilterCndBuilderSpecNetplanConfigNetworkTunnels) Lt(value *Device_Spec_NetworkingConfig_TunnelsOpts) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *mapFilterCndBuilderSpecNetplanConfigNetworkTunnels) Lte(value *Device_Spec_NetworkingConfig_TunnelsOpts) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *mapFilterCndBuilderSpecNetplanConfigNetworkTunnels) In(values []*Device_Spec_NetworkingConfig_TunnelsOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().NetplanConfig().Network().Tunnels().WithKey(b.key).WithArrayOfValues(values),
	})
}

func (b *mapFilterCndBuilderSpecNetplanConfigNetworkTunnels) NotIn(values []*Device_Spec_NetworkingConfig_TunnelsOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().NetplanConfig().Network().Tunnels().WithKey(b.key).WithArrayOfValues(values),
	})
}

func (b *mapFilterCndBuilderSpecNetplanConfigNetworkTunnels) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Spec().NetplanConfig().Network().Tunnels().WithKey(b.key).FieldPath(),
	})
}

func (b *mapFilterCndBuilderSpecNetplanConfigNetworkTunnels) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Spec().NetplanConfig().Network().Tunnels().WithKey(b.key).FieldPath(),
	})
}

func (b *mapFilterCndBuilderSpecNetplanConfigNetworkTunnels) compare(op gotenfilter.CompareOperator, value *Device_Spec_NetworkingConfig_TunnelsOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Spec().NetplanConfig().Network().Tunnels().WithKey(b.key).WithValue(value),
	})
}

type filterCndBuilderSpecNetplanConfigNetworkVlans struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecNetplanConfigNetworkVlans) In(values []map[string]*Device_Spec_NetworkingConfig_VlansOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().NetplanConfig().Network().Vlans().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecNetplanConfigNetworkVlans) NotIn(values []map[string]*Device_Spec_NetworkingConfig_VlansOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().NetplanConfig().Network().Vlans().WithArrayOfValues(values),
	})
}

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

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

func (b *filterCndBuilderSpecNetplanConfigNetworkVlans) compare(op gotenfilter.CompareOperator, value map[string]*Device_Spec_NetworkingConfig_VlansOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Spec().NetplanConfig().Network().Vlans().WithValue(value),
	})
}

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

type mapFilterCndBuilderSpecNetplanConfigNetworkVlans struct {
	builder *FilterBuilder
	key     string
}

func (b *mapFilterCndBuilderSpecNetplanConfigNetworkVlans) Eq(value *Device_Spec_NetworkingConfig_VlansOpts) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *mapFilterCndBuilderSpecNetplanConfigNetworkVlans) Neq(value *Device_Spec_NetworkingConfig_VlansOpts) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *mapFilterCndBuilderSpecNetplanConfigNetworkVlans) Gt(value *Device_Spec_NetworkingConfig_VlansOpts) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *mapFilterCndBuilderSpecNetplanConfigNetworkVlans) Gte(value *Device_Spec_NetworkingConfig_VlansOpts) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *mapFilterCndBuilderSpecNetplanConfigNetworkVlans) Lt(value *Device_Spec_NetworkingConfig_VlansOpts) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *mapFilterCndBuilderSpecNetplanConfigNetworkVlans) Lte(value *Device_Spec_NetworkingConfig_VlansOpts) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *mapFilterCndBuilderSpecNetplanConfigNetworkVlans) In(values []*Device_Spec_NetworkingConfig_VlansOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().NetplanConfig().Network().Vlans().WithKey(b.key).WithArrayOfValues(values),
	})
}

func (b *mapFilterCndBuilderSpecNetplanConfigNetworkVlans) NotIn(values []*Device_Spec_NetworkingConfig_VlansOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().NetplanConfig().Network().Vlans().WithKey(b.key).WithArrayOfValues(values),
	})
}

func (b *mapFilterCndBuilderSpecNetplanConfigNetworkVlans) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Spec().NetplanConfig().Network().Vlans().WithKey(b.key).FieldPath(),
	})
}

func (b *mapFilterCndBuilderSpecNetplanConfigNetworkVlans) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Spec().NetplanConfig().Network().Vlans().WithKey(b.key).FieldPath(),
	})
}

func (b *mapFilterCndBuilderSpecNetplanConfigNetworkVlans) compare(op gotenfilter.CompareOperator, value *Device_Spec_NetworkingConfig_VlansOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Spec().NetplanConfig().Network().Vlans().WithKey(b.key).WithValue(value),
	})
}

type filterCndBuilderSpecNetplanConfigNetworkModems struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderSpecNetplanConfigNetworkModems) In(values []map[string]*Device_Spec_NetworkingConfig_ModemOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().NetplanConfig().Network().Modems().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderSpecNetplanConfigNetworkModems) NotIn(values []map[string]*Device_Spec_NetworkingConfig_ModemOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().NetplanConfig().Network().Modems().WithArrayOfValues(values),
	})
}

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

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

func (b *filterCndBuilderSpecNetplanConfigNetworkModems) compare(op gotenfilter.CompareOperator, value map[string]*Device_Spec_NetworkingConfig_ModemOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Spec().NetplanConfig().Network().Modems().WithValue(value),
	})
}

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

type mapFilterCndBuilderSpecNetplanConfigNetworkModems struct {
	builder *FilterBuilder
	key     string
}

func (b *mapFilterCndBuilderSpecNetplanConfigNetworkModems) Eq(value *Device_Spec_NetworkingConfig_ModemOpts) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *mapFilterCndBuilderSpecNetplanConfigNetworkModems) Neq(value *Device_Spec_NetworkingConfig_ModemOpts) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *mapFilterCndBuilderSpecNetplanConfigNetworkModems) Gt(value *Device_Spec_NetworkingConfig_ModemOpts) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *mapFilterCndBuilderSpecNetplanConfigNetworkModems) Gte(value *Device_Spec_NetworkingConfig_ModemOpts) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *mapFilterCndBuilderSpecNetplanConfigNetworkModems) Lt(value *Device_Spec_NetworkingConfig_ModemOpts) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *mapFilterCndBuilderSpecNetplanConfigNetworkModems) Lte(value *Device_Spec_NetworkingConfig_ModemOpts) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *mapFilterCndBuilderSpecNetplanConfigNetworkModems) In(values []*Device_Spec_NetworkingConfig_ModemOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().NetplanConfig().Network().Modems().WithKey(b.key).WithArrayOfValues(values),
	})
}

func (b *mapFilterCndBuilderSpecNetplanConfigNetworkModems) NotIn(values []*Device_Spec_NetworkingConfig_ModemOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Spec().NetplanConfig().Network().Modems().WithKey(b.key).WithArrayOfValues(values),
	})
}

func (b *mapFilterCndBuilderSpecNetplanConfigNetworkModems) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Spec().NetplanConfig().Network().Modems().WithKey(b.key).FieldPath(),
	})
}

func (b *mapFilterCndBuilderSpecNetplanConfigNetworkModems) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Spec().NetplanConfig().Network().Modems().WithKey(b.key).FieldPath(),
	})
}

func (b *mapFilterCndBuilderSpecNetplanConfigNetworkModems) compare(op gotenfilter.CompareOperator, value *Device_Spec_NetworkingConfig_ModemOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Spec().NetplanConfig().Network().Modems().WithKey(b.key).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}
}

func (b *filterCndBuilderSpecAttestationConfig) InsecureUseTpmSimulatorSeed() *filterCndBuilderSpecAttestationConfigInsecureUseTpmSimulatorSeed {
	return &filterCndBuilderSpecAttestationConfigInsecureUseTpmSimulatorSeed{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 filterCndBuilderSpecAttestationConfigInsecureUseTpmSimulatorSeed struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

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

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

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

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

func (b *filterCndBuilderSpecAttestationConfigInsecureUseTpmSimulatorSeed) compare(op gotenfilter.CompareOperator, value int32) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Spec().AttestationConfig().InsecureUseTpmSimulatorSeed().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}
}

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 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 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}
}

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) DefaultConfig() *filterCndBuilderStatusNetworkConfigStateDefaultConfig {
	return &filterCndBuilderStatusNetworkConfigStateDefaultConfig{builder: b.builder}
}

func (b *filterCndBuilderStatusNetworkConfigState) ActiveConfig() *filterCndBuilderStatusNetworkConfigStateActiveConfig {
	return &filterCndBuilderStatusNetworkConfigStateActiveConfig{builder: b.builder}
}

func (b *filterCndBuilderStatusNetworkConfigState) DesiredConfig() *filterCndBuilderStatusNetworkConfigStateDesiredConfig {
	return &filterCndBuilderStatusNetworkConfigStateDesiredConfig{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 filterCndBuilderStatusNetworkConfigStateDefaultConfig struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusNetworkConfigStateDefaultConfig) Eq(value *Device_Spec_NetplanConfig) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusNetworkConfigStateDefaultConfig) Neq(value *Device_Spec_NetplanConfig) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusNetworkConfigStateDefaultConfig) Gt(value *Device_Spec_NetplanConfig) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusNetworkConfigStateDefaultConfig) Gte(value *Device_Spec_NetplanConfig) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusNetworkConfigStateDefaultConfig) Lt(value *Device_Spec_NetplanConfig) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusNetworkConfigStateDefaultConfig) Lte(value *Device_Spec_NetplanConfig) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusNetworkConfigStateDefaultConfig) In(values []*Device_Spec_NetplanConfig) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DefaultConfig().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDefaultConfig) NotIn(values []*Device_Spec_NetplanConfig) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DefaultConfig().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDefaultConfig) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DefaultConfig().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDefaultConfig) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DefaultConfig().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDefaultConfig) compare(op gotenfilter.CompareOperator, value *Device_Spec_NetplanConfig) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DefaultConfig().WithValue(value),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDefaultConfig) Network() *filterCndBuilderStatusNetworkConfigStateDefaultConfigNetwork {
	return &filterCndBuilderStatusNetworkConfigStateDefaultConfigNetwork{builder: b.builder}
}

type filterCndBuilderStatusNetworkConfigStateDefaultConfigNetwork struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusNetworkConfigStateDefaultConfigNetwork) Eq(value *Device_Spec_NetworkingConfig) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusNetworkConfigStateDefaultConfigNetwork) Neq(value *Device_Spec_NetworkingConfig) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusNetworkConfigStateDefaultConfigNetwork) Gt(value *Device_Spec_NetworkingConfig) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusNetworkConfigStateDefaultConfigNetwork) Gte(value *Device_Spec_NetworkingConfig) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusNetworkConfigStateDefaultConfigNetwork) Lt(value *Device_Spec_NetworkingConfig) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusNetworkConfigStateDefaultConfigNetwork) Lte(value *Device_Spec_NetworkingConfig) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusNetworkConfigStateDefaultConfigNetwork) In(values []*Device_Spec_NetworkingConfig) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DefaultConfig().Network().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDefaultConfigNetwork) NotIn(values []*Device_Spec_NetworkingConfig) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DefaultConfig().Network().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDefaultConfigNetwork) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DefaultConfig().Network().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDefaultConfigNetwork) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DefaultConfig().Network().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDefaultConfigNetwork) compare(op gotenfilter.CompareOperator, value *Device_Spec_NetworkingConfig) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DefaultConfig().Network().WithValue(value),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDefaultConfigNetwork) Version() *filterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkVersion {
	return &filterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkVersion{builder: b.builder}
}

func (b *filterCndBuilderStatusNetworkConfigStateDefaultConfigNetwork) Renderer() *filterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkRenderer {
	return &filterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkRenderer{builder: b.builder}
}

func (b *filterCndBuilderStatusNetworkConfigStateDefaultConfigNetwork) Ethernets() *filterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkEthernets {
	return &filterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkEthernets{builder: b.builder}
}

func (b *filterCndBuilderStatusNetworkConfigStateDefaultConfigNetwork) Wifis() *filterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkWifis {
	return &filterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkWifis{builder: b.builder}
}

func (b *filterCndBuilderStatusNetworkConfigStateDefaultConfigNetwork) Bridges() *filterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkBridges {
	return &filterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkBridges{builder: b.builder}
}

func (b *filterCndBuilderStatusNetworkConfigStateDefaultConfigNetwork) Bonds() *filterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkBonds {
	return &filterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkBonds{builder: b.builder}
}

func (b *filterCndBuilderStatusNetworkConfigStateDefaultConfigNetwork) Tunnels() *filterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkTunnels {
	return &filterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkTunnels{builder: b.builder}
}

func (b *filterCndBuilderStatusNetworkConfigStateDefaultConfigNetwork) Vlans() *filterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkVlans {
	return &filterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkVlans{builder: b.builder}
}

func (b *filterCndBuilderStatusNetworkConfigStateDefaultConfigNetwork) Modems() *filterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkModems {
	return &filterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkModems{builder: b.builder}
}

type filterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkVersion struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkVersion) In(values []int32) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DefaultConfig().Network().Version().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkVersion) NotIn(values []int32) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DefaultConfig().Network().Version().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkVersion) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DefaultConfig().Network().Version().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkVersion) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DefaultConfig().Network().Version().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkVersion) compare(op gotenfilter.CompareOperator, value int32) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DefaultConfig().Network().Version().WithValue(value),
	})
}

type filterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkRenderer struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkRenderer) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DefaultConfig().Network().Renderer().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkRenderer) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DefaultConfig().Network().Renderer().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkRenderer) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DefaultConfig().Network().Renderer().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkRenderer) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DefaultConfig().Network().Renderer().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkRenderer) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DefaultConfig().Network().Renderer().WithValue(value),
	})
}

type filterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkEthernets struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkEthernets) In(values []map[string]*Device_Spec_NetworkingConfig_EthOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DefaultConfig().Network().Ethernets().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkEthernets) NotIn(values []map[string]*Device_Spec_NetworkingConfig_EthOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DefaultConfig().Network().Ethernets().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkEthernets) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DefaultConfig().Network().Ethernets().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkEthernets) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DefaultConfig().Network().Ethernets().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkEthernets) compare(op gotenfilter.CompareOperator, value map[string]*Device_Spec_NetworkingConfig_EthOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DefaultConfig().Network().Ethernets().WithValue(value),
	})
}

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

type mapFilterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkEthernets struct {
	builder *FilterBuilder
	key     string
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkEthernets) Eq(value *Device_Spec_NetworkingConfig_EthOpts) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkEthernets) Neq(value *Device_Spec_NetworkingConfig_EthOpts) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkEthernets) Gt(value *Device_Spec_NetworkingConfig_EthOpts) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkEthernets) Gte(value *Device_Spec_NetworkingConfig_EthOpts) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkEthernets) Lt(value *Device_Spec_NetworkingConfig_EthOpts) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkEthernets) Lte(value *Device_Spec_NetworkingConfig_EthOpts) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkEthernets) In(values []*Device_Spec_NetworkingConfig_EthOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DefaultConfig().Network().Ethernets().WithKey(b.key).WithArrayOfValues(values),
	})
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkEthernets) NotIn(values []*Device_Spec_NetworkingConfig_EthOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DefaultConfig().Network().Ethernets().WithKey(b.key).WithArrayOfValues(values),
	})
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkEthernets) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DefaultConfig().Network().Ethernets().WithKey(b.key).FieldPath(),
	})
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkEthernets) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DefaultConfig().Network().Ethernets().WithKey(b.key).FieldPath(),
	})
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkEthernets) compare(op gotenfilter.CompareOperator, value *Device_Spec_NetworkingConfig_EthOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DefaultConfig().Network().Ethernets().WithKey(b.key).WithValue(value),
	})
}

type filterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkWifis struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkWifis) In(values []map[string]*Device_Spec_NetworkingConfig_WifiOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DefaultConfig().Network().Wifis().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkWifis) NotIn(values []map[string]*Device_Spec_NetworkingConfig_WifiOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DefaultConfig().Network().Wifis().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkWifis) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DefaultConfig().Network().Wifis().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkWifis) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DefaultConfig().Network().Wifis().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkWifis) compare(op gotenfilter.CompareOperator, value map[string]*Device_Spec_NetworkingConfig_WifiOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DefaultConfig().Network().Wifis().WithValue(value),
	})
}

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

type mapFilterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkWifis struct {
	builder *FilterBuilder
	key     string
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkWifis) Eq(value *Device_Spec_NetworkingConfig_WifiOpts) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkWifis) Neq(value *Device_Spec_NetworkingConfig_WifiOpts) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkWifis) Gt(value *Device_Spec_NetworkingConfig_WifiOpts) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkWifis) Gte(value *Device_Spec_NetworkingConfig_WifiOpts) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkWifis) Lt(value *Device_Spec_NetworkingConfig_WifiOpts) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkWifis) Lte(value *Device_Spec_NetworkingConfig_WifiOpts) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkWifis) In(values []*Device_Spec_NetworkingConfig_WifiOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DefaultConfig().Network().Wifis().WithKey(b.key).WithArrayOfValues(values),
	})
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkWifis) NotIn(values []*Device_Spec_NetworkingConfig_WifiOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DefaultConfig().Network().Wifis().WithKey(b.key).WithArrayOfValues(values),
	})
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkWifis) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DefaultConfig().Network().Wifis().WithKey(b.key).FieldPath(),
	})
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkWifis) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DefaultConfig().Network().Wifis().WithKey(b.key).FieldPath(),
	})
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkWifis) compare(op gotenfilter.CompareOperator, value *Device_Spec_NetworkingConfig_WifiOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DefaultConfig().Network().Wifis().WithKey(b.key).WithValue(value),
	})
}

type filterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkBridges struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkBridges) In(values []map[string]*Device_Spec_NetworkingConfig_BridgesOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DefaultConfig().Network().Bridges().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkBridges) NotIn(values []map[string]*Device_Spec_NetworkingConfig_BridgesOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DefaultConfig().Network().Bridges().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkBridges) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DefaultConfig().Network().Bridges().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkBridges) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DefaultConfig().Network().Bridges().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkBridges) compare(op gotenfilter.CompareOperator, value map[string]*Device_Spec_NetworkingConfig_BridgesOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DefaultConfig().Network().Bridges().WithValue(value),
	})
}

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

type mapFilterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkBridges struct {
	builder *FilterBuilder
	key     string
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkBridges) Eq(value *Device_Spec_NetworkingConfig_BridgesOpts) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkBridges) Neq(value *Device_Spec_NetworkingConfig_BridgesOpts) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkBridges) Gt(value *Device_Spec_NetworkingConfig_BridgesOpts) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkBridges) Gte(value *Device_Spec_NetworkingConfig_BridgesOpts) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkBridges) Lt(value *Device_Spec_NetworkingConfig_BridgesOpts) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkBridges) Lte(value *Device_Spec_NetworkingConfig_BridgesOpts) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkBridges) In(values []*Device_Spec_NetworkingConfig_BridgesOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DefaultConfig().Network().Bridges().WithKey(b.key).WithArrayOfValues(values),
	})
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkBridges) NotIn(values []*Device_Spec_NetworkingConfig_BridgesOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DefaultConfig().Network().Bridges().WithKey(b.key).WithArrayOfValues(values),
	})
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkBridges) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DefaultConfig().Network().Bridges().WithKey(b.key).FieldPath(),
	})
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkBridges) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DefaultConfig().Network().Bridges().WithKey(b.key).FieldPath(),
	})
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkBridges) compare(op gotenfilter.CompareOperator, value *Device_Spec_NetworkingConfig_BridgesOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DefaultConfig().Network().Bridges().WithKey(b.key).WithValue(value),
	})
}

type filterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkBonds struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkBonds) In(values []map[string]*Device_Spec_NetworkingConfig_BondsOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DefaultConfig().Network().Bonds().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkBonds) NotIn(values []map[string]*Device_Spec_NetworkingConfig_BondsOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DefaultConfig().Network().Bonds().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkBonds) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DefaultConfig().Network().Bonds().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkBonds) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DefaultConfig().Network().Bonds().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkBonds) compare(op gotenfilter.CompareOperator, value map[string]*Device_Spec_NetworkingConfig_BondsOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DefaultConfig().Network().Bonds().WithValue(value),
	})
}

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

type mapFilterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkBonds struct {
	builder *FilterBuilder
	key     string
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkBonds) Eq(value *Device_Spec_NetworkingConfig_BondsOpts) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkBonds) Neq(value *Device_Spec_NetworkingConfig_BondsOpts) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkBonds) Gt(value *Device_Spec_NetworkingConfig_BondsOpts) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkBonds) Gte(value *Device_Spec_NetworkingConfig_BondsOpts) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkBonds) Lt(value *Device_Spec_NetworkingConfig_BondsOpts) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkBonds) Lte(value *Device_Spec_NetworkingConfig_BondsOpts) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkBonds) In(values []*Device_Spec_NetworkingConfig_BondsOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DefaultConfig().Network().Bonds().WithKey(b.key).WithArrayOfValues(values),
	})
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkBonds) NotIn(values []*Device_Spec_NetworkingConfig_BondsOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DefaultConfig().Network().Bonds().WithKey(b.key).WithArrayOfValues(values),
	})
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkBonds) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DefaultConfig().Network().Bonds().WithKey(b.key).FieldPath(),
	})
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkBonds) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DefaultConfig().Network().Bonds().WithKey(b.key).FieldPath(),
	})
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkBonds) compare(op gotenfilter.CompareOperator, value *Device_Spec_NetworkingConfig_BondsOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DefaultConfig().Network().Bonds().WithKey(b.key).WithValue(value),
	})
}

type filterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkTunnels struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkTunnels) In(values []map[string]*Device_Spec_NetworkingConfig_TunnelsOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DefaultConfig().Network().Tunnels().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkTunnels) NotIn(values []map[string]*Device_Spec_NetworkingConfig_TunnelsOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DefaultConfig().Network().Tunnels().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkTunnels) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DefaultConfig().Network().Tunnels().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkTunnels) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DefaultConfig().Network().Tunnels().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkTunnels) compare(op gotenfilter.CompareOperator, value map[string]*Device_Spec_NetworkingConfig_TunnelsOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DefaultConfig().Network().Tunnels().WithValue(value),
	})
}

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

type mapFilterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkTunnels struct {
	builder *FilterBuilder
	key     string
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkTunnels) Eq(value *Device_Spec_NetworkingConfig_TunnelsOpts) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkTunnels) Neq(value *Device_Spec_NetworkingConfig_TunnelsOpts) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkTunnels) Gt(value *Device_Spec_NetworkingConfig_TunnelsOpts) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkTunnels) Gte(value *Device_Spec_NetworkingConfig_TunnelsOpts) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkTunnels) Lt(value *Device_Spec_NetworkingConfig_TunnelsOpts) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkTunnels) Lte(value *Device_Spec_NetworkingConfig_TunnelsOpts) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkTunnels) In(values []*Device_Spec_NetworkingConfig_TunnelsOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DefaultConfig().Network().Tunnels().WithKey(b.key).WithArrayOfValues(values),
	})
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkTunnels) NotIn(values []*Device_Spec_NetworkingConfig_TunnelsOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DefaultConfig().Network().Tunnels().WithKey(b.key).WithArrayOfValues(values),
	})
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkTunnels) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DefaultConfig().Network().Tunnels().WithKey(b.key).FieldPath(),
	})
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkTunnels) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DefaultConfig().Network().Tunnels().WithKey(b.key).FieldPath(),
	})
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkTunnels) compare(op gotenfilter.CompareOperator, value *Device_Spec_NetworkingConfig_TunnelsOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DefaultConfig().Network().Tunnels().WithKey(b.key).WithValue(value),
	})
}

type filterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkVlans struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkVlans) In(values []map[string]*Device_Spec_NetworkingConfig_VlansOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DefaultConfig().Network().Vlans().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkVlans) NotIn(values []map[string]*Device_Spec_NetworkingConfig_VlansOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DefaultConfig().Network().Vlans().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkVlans) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DefaultConfig().Network().Vlans().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkVlans) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DefaultConfig().Network().Vlans().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkVlans) compare(op gotenfilter.CompareOperator, value map[string]*Device_Spec_NetworkingConfig_VlansOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DefaultConfig().Network().Vlans().WithValue(value),
	})
}

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

type mapFilterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkVlans struct {
	builder *FilterBuilder
	key     string
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkVlans) Eq(value *Device_Spec_NetworkingConfig_VlansOpts) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkVlans) Neq(value *Device_Spec_NetworkingConfig_VlansOpts) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkVlans) Gt(value *Device_Spec_NetworkingConfig_VlansOpts) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkVlans) Gte(value *Device_Spec_NetworkingConfig_VlansOpts) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkVlans) Lt(value *Device_Spec_NetworkingConfig_VlansOpts) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkVlans) Lte(value *Device_Spec_NetworkingConfig_VlansOpts) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkVlans) In(values []*Device_Spec_NetworkingConfig_VlansOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DefaultConfig().Network().Vlans().WithKey(b.key).WithArrayOfValues(values),
	})
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkVlans) NotIn(values []*Device_Spec_NetworkingConfig_VlansOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DefaultConfig().Network().Vlans().WithKey(b.key).WithArrayOfValues(values),
	})
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkVlans) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DefaultConfig().Network().Vlans().WithKey(b.key).FieldPath(),
	})
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkVlans) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DefaultConfig().Network().Vlans().WithKey(b.key).FieldPath(),
	})
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkVlans) compare(op gotenfilter.CompareOperator, value *Device_Spec_NetworkingConfig_VlansOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DefaultConfig().Network().Vlans().WithKey(b.key).WithValue(value),
	})
}

type filterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkModems struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkModems) In(values []map[string]*Device_Spec_NetworkingConfig_ModemOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DefaultConfig().Network().Modems().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkModems) NotIn(values []map[string]*Device_Spec_NetworkingConfig_ModemOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DefaultConfig().Network().Modems().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkModems) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DefaultConfig().Network().Modems().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkModems) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DefaultConfig().Network().Modems().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkModems) compare(op gotenfilter.CompareOperator, value map[string]*Device_Spec_NetworkingConfig_ModemOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DefaultConfig().Network().Modems().WithValue(value),
	})
}

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

type mapFilterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkModems struct {
	builder *FilterBuilder
	key     string
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkModems) Eq(value *Device_Spec_NetworkingConfig_ModemOpts) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkModems) Neq(value *Device_Spec_NetworkingConfig_ModemOpts) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkModems) Gt(value *Device_Spec_NetworkingConfig_ModemOpts) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkModems) Gte(value *Device_Spec_NetworkingConfig_ModemOpts) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkModems) Lt(value *Device_Spec_NetworkingConfig_ModemOpts) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkModems) Lte(value *Device_Spec_NetworkingConfig_ModemOpts) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkModems) In(values []*Device_Spec_NetworkingConfig_ModemOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DefaultConfig().Network().Modems().WithKey(b.key).WithArrayOfValues(values),
	})
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkModems) NotIn(values []*Device_Spec_NetworkingConfig_ModemOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DefaultConfig().Network().Modems().WithKey(b.key).WithArrayOfValues(values),
	})
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkModems) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DefaultConfig().Network().Modems().WithKey(b.key).FieldPath(),
	})
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkModems) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DefaultConfig().Network().Modems().WithKey(b.key).FieldPath(),
	})
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDefaultConfigNetworkModems) compare(op gotenfilter.CompareOperator, value *Device_Spec_NetworkingConfig_ModemOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DefaultConfig().Network().Modems().WithKey(b.key).WithValue(value),
	})
}

type filterCndBuilderStatusNetworkConfigStateActiveConfig struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusNetworkConfigStateActiveConfig) Eq(value *Device_Spec_NetplanConfig) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusNetworkConfigStateActiveConfig) Neq(value *Device_Spec_NetplanConfig) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusNetworkConfigStateActiveConfig) Gt(value *Device_Spec_NetplanConfig) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusNetworkConfigStateActiveConfig) Gte(value *Device_Spec_NetplanConfig) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusNetworkConfigStateActiveConfig) Lt(value *Device_Spec_NetplanConfig) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusNetworkConfigStateActiveConfig) Lte(value *Device_Spec_NetplanConfig) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusNetworkConfigStateActiveConfig) In(values []*Device_Spec_NetplanConfig) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveConfig().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateActiveConfig) NotIn(values []*Device_Spec_NetplanConfig) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveConfig().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateActiveConfig) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveConfig().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateActiveConfig) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveConfig().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateActiveConfig) compare(op gotenfilter.CompareOperator, value *Device_Spec_NetplanConfig) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveConfig().WithValue(value),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateActiveConfig) Network() *filterCndBuilderStatusNetworkConfigStateActiveConfigNetwork {
	return &filterCndBuilderStatusNetworkConfigStateActiveConfigNetwork{builder: b.builder}
}

type filterCndBuilderStatusNetworkConfigStateActiveConfigNetwork struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusNetworkConfigStateActiveConfigNetwork) Eq(value *Device_Spec_NetworkingConfig) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusNetworkConfigStateActiveConfigNetwork) Neq(value *Device_Spec_NetworkingConfig) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusNetworkConfigStateActiveConfigNetwork) Gt(value *Device_Spec_NetworkingConfig) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusNetworkConfigStateActiveConfigNetwork) Gte(value *Device_Spec_NetworkingConfig) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusNetworkConfigStateActiveConfigNetwork) Lt(value *Device_Spec_NetworkingConfig) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusNetworkConfigStateActiveConfigNetwork) Lte(value *Device_Spec_NetworkingConfig) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusNetworkConfigStateActiveConfigNetwork) In(values []*Device_Spec_NetworkingConfig) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveConfig().Network().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateActiveConfigNetwork) NotIn(values []*Device_Spec_NetworkingConfig) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveConfig().Network().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateActiveConfigNetwork) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveConfig().Network().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateActiveConfigNetwork) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveConfig().Network().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateActiveConfigNetwork) compare(op gotenfilter.CompareOperator, value *Device_Spec_NetworkingConfig) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveConfig().Network().WithValue(value),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateActiveConfigNetwork) Version() *filterCndBuilderStatusNetworkConfigStateActiveConfigNetworkVersion {
	return &filterCndBuilderStatusNetworkConfigStateActiveConfigNetworkVersion{builder: b.builder}
}

func (b *filterCndBuilderStatusNetworkConfigStateActiveConfigNetwork) Renderer() *filterCndBuilderStatusNetworkConfigStateActiveConfigNetworkRenderer {
	return &filterCndBuilderStatusNetworkConfigStateActiveConfigNetworkRenderer{builder: b.builder}
}

func (b *filterCndBuilderStatusNetworkConfigStateActiveConfigNetwork) Ethernets() *filterCndBuilderStatusNetworkConfigStateActiveConfigNetworkEthernets {
	return &filterCndBuilderStatusNetworkConfigStateActiveConfigNetworkEthernets{builder: b.builder}
}

func (b *filterCndBuilderStatusNetworkConfigStateActiveConfigNetwork) Wifis() *filterCndBuilderStatusNetworkConfigStateActiveConfigNetworkWifis {
	return &filterCndBuilderStatusNetworkConfigStateActiveConfigNetworkWifis{builder: b.builder}
}

func (b *filterCndBuilderStatusNetworkConfigStateActiveConfigNetwork) Bridges() *filterCndBuilderStatusNetworkConfigStateActiveConfigNetworkBridges {
	return &filterCndBuilderStatusNetworkConfigStateActiveConfigNetworkBridges{builder: b.builder}
}

func (b *filterCndBuilderStatusNetworkConfigStateActiveConfigNetwork) Bonds() *filterCndBuilderStatusNetworkConfigStateActiveConfigNetworkBonds {
	return &filterCndBuilderStatusNetworkConfigStateActiveConfigNetworkBonds{builder: b.builder}
}

func (b *filterCndBuilderStatusNetworkConfigStateActiveConfigNetwork) Tunnels() *filterCndBuilderStatusNetworkConfigStateActiveConfigNetworkTunnels {
	return &filterCndBuilderStatusNetworkConfigStateActiveConfigNetworkTunnels{builder: b.builder}
}

func (b *filterCndBuilderStatusNetworkConfigStateActiveConfigNetwork) Vlans() *filterCndBuilderStatusNetworkConfigStateActiveConfigNetworkVlans {
	return &filterCndBuilderStatusNetworkConfigStateActiveConfigNetworkVlans{builder: b.builder}
}

func (b *filterCndBuilderStatusNetworkConfigStateActiveConfigNetwork) Modems() *filterCndBuilderStatusNetworkConfigStateActiveConfigNetworkModems {
	return &filterCndBuilderStatusNetworkConfigStateActiveConfigNetworkModems{builder: b.builder}
}

type filterCndBuilderStatusNetworkConfigStateActiveConfigNetworkVersion struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusNetworkConfigStateActiveConfigNetworkVersion) In(values []int32) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveConfig().Network().Version().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateActiveConfigNetworkVersion) NotIn(values []int32) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveConfig().Network().Version().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateActiveConfigNetworkVersion) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveConfig().Network().Version().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateActiveConfigNetworkVersion) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveConfig().Network().Version().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateActiveConfigNetworkVersion) compare(op gotenfilter.CompareOperator, value int32) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveConfig().Network().Version().WithValue(value),
	})
}

type filterCndBuilderStatusNetworkConfigStateActiveConfigNetworkRenderer struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusNetworkConfigStateActiveConfigNetworkRenderer) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveConfig().Network().Renderer().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateActiveConfigNetworkRenderer) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveConfig().Network().Renderer().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateActiveConfigNetworkRenderer) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveConfig().Network().Renderer().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateActiveConfigNetworkRenderer) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveConfig().Network().Renderer().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateActiveConfigNetworkRenderer) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveConfig().Network().Renderer().WithValue(value),
	})
}

type filterCndBuilderStatusNetworkConfigStateActiveConfigNetworkEthernets struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusNetworkConfigStateActiveConfigNetworkEthernets) In(values []map[string]*Device_Spec_NetworkingConfig_EthOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveConfig().Network().Ethernets().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateActiveConfigNetworkEthernets) NotIn(values []map[string]*Device_Spec_NetworkingConfig_EthOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveConfig().Network().Ethernets().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateActiveConfigNetworkEthernets) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveConfig().Network().Ethernets().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateActiveConfigNetworkEthernets) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveConfig().Network().Ethernets().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateActiveConfigNetworkEthernets) compare(op gotenfilter.CompareOperator, value map[string]*Device_Spec_NetworkingConfig_EthOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveConfig().Network().Ethernets().WithValue(value),
	})
}

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

type mapFilterCndBuilderStatusNetworkConfigStateActiveConfigNetworkEthernets struct {
	builder *FilterBuilder
	key     string
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateActiveConfigNetworkEthernets) Eq(value *Device_Spec_NetworkingConfig_EthOpts) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateActiveConfigNetworkEthernets) Neq(value *Device_Spec_NetworkingConfig_EthOpts) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateActiveConfigNetworkEthernets) Gt(value *Device_Spec_NetworkingConfig_EthOpts) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateActiveConfigNetworkEthernets) Gte(value *Device_Spec_NetworkingConfig_EthOpts) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateActiveConfigNetworkEthernets) Lt(value *Device_Spec_NetworkingConfig_EthOpts) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateActiveConfigNetworkEthernets) Lte(value *Device_Spec_NetworkingConfig_EthOpts) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateActiveConfigNetworkEthernets) In(values []*Device_Spec_NetworkingConfig_EthOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveConfig().Network().Ethernets().WithKey(b.key).WithArrayOfValues(values),
	})
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateActiveConfigNetworkEthernets) NotIn(values []*Device_Spec_NetworkingConfig_EthOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveConfig().Network().Ethernets().WithKey(b.key).WithArrayOfValues(values),
	})
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateActiveConfigNetworkEthernets) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveConfig().Network().Ethernets().WithKey(b.key).FieldPath(),
	})
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateActiveConfigNetworkEthernets) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveConfig().Network().Ethernets().WithKey(b.key).FieldPath(),
	})
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateActiveConfigNetworkEthernets) compare(op gotenfilter.CompareOperator, value *Device_Spec_NetworkingConfig_EthOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveConfig().Network().Ethernets().WithKey(b.key).WithValue(value),
	})
}

type filterCndBuilderStatusNetworkConfigStateActiveConfigNetworkWifis struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusNetworkConfigStateActiveConfigNetworkWifis) In(values []map[string]*Device_Spec_NetworkingConfig_WifiOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveConfig().Network().Wifis().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateActiveConfigNetworkWifis) NotIn(values []map[string]*Device_Spec_NetworkingConfig_WifiOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveConfig().Network().Wifis().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateActiveConfigNetworkWifis) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveConfig().Network().Wifis().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateActiveConfigNetworkWifis) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveConfig().Network().Wifis().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateActiveConfigNetworkWifis) compare(op gotenfilter.CompareOperator, value map[string]*Device_Spec_NetworkingConfig_WifiOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveConfig().Network().Wifis().WithValue(value),
	})
}

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

type mapFilterCndBuilderStatusNetworkConfigStateActiveConfigNetworkWifis struct {
	builder *FilterBuilder
	key     string
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateActiveConfigNetworkWifis) Eq(value *Device_Spec_NetworkingConfig_WifiOpts) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateActiveConfigNetworkWifis) Neq(value *Device_Spec_NetworkingConfig_WifiOpts) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateActiveConfigNetworkWifis) Gt(value *Device_Spec_NetworkingConfig_WifiOpts) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateActiveConfigNetworkWifis) Gte(value *Device_Spec_NetworkingConfig_WifiOpts) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateActiveConfigNetworkWifis) Lt(value *Device_Spec_NetworkingConfig_WifiOpts) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateActiveConfigNetworkWifis) Lte(value *Device_Spec_NetworkingConfig_WifiOpts) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateActiveConfigNetworkWifis) In(values []*Device_Spec_NetworkingConfig_WifiOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveConfig().Network().Wifis().WithKey(b.key).WithArrayOfValues(values),
	})
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateActiveConfigNetworkWifis) NotIn(values []*Device_Spec_NetworkingConfig_WifiOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveConfig().Network().Wifis().WithKey(b.key).WithArrayOfValues(values),
	})
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateActiveConfigNetworkWifis) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveConfig().Network().Wifis().WithKey(b.key).FieldPath(),
	})
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateActiveConfigNetworkWifis) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveConfig().Network().Wifis().WithKey(b.key).FieldPath(),
	})
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateActiveConfigNetworkWifis) compare(op gotenfilter.CompareOperator, value *Device_Spec_NetworkingConfig_WifiOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveConfig().Network().Wifis().WithKey(b.key).WithValue(value),
	})
}

type filterCndBuilderStatusNetworkConfigStateActiveConfigNetworkBridges struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusNetworkConfigStateActiveConfigNetworkBridges) In(values []map[string]*Device_Spec_NetworkingConfig_BridgesOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveConfig().Network().Bridges().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateActiveConfigNetworkBridges) NotIn(values []map[string]*Device_Spec_NetworkingConfig_BridgesOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveConfig().Network().Bridges().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateActiveConfigNetworkBridges) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveConfig().Network().Bridges().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateActiveConfigNetworkBridges) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveConfig().Network().Bridges().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateActiveConfigNetworkBridges) compare(op gotenfilter.CompareOperator, value map[string]*Device_Spec_NetworkingConfig_BridgesOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveConfig().Network().Bridges().WithValue(value),
	})
}

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

type mapFilterCndBuilderStatusNetworkConfigStateActiveConfigNetworkBridges struct {
	builder *FilterBuilder
	key     string
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateActiveConfigNetworkBridges) Eq(value *Device_Spec_NetworkingConfig_BridgesOpts) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateActiveConfigNetworkBridges) Neq(value *Device_Spec_NetworkingConfig_BridgesOpts) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateActiveConfigNetworkBridges) Gt(value *Device_Spec_NetworkingConfig_BridgesOpts) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateActiveConfigNetworkBridges) Gte(value *Device_Spec_NetworkingConfig_BridgesOpts) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateActiveConfigNetworkBridges) Lt(value *Device_Spec_NetworkingConfig_BridgesOpts) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateActiveConfigNetworkBridges) Lte(value *Device_Spec_NetworkingConfig_BridgesOpts) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateActiveConfigNetworkBridges) In(values []*Device_Spec_NetworkingConfig_BridgesOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveConfig().Network().Bridges().WithKey(b.key).WithArrayOfValues(values),
	})
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateActiveConfigNetworkBridges) NotIn(values []*Device_Spec_NetworkingConfig_BridgesOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveConfig().Network().Bridges().WithKey(b.key).WithArrayOfValues(values),
	})
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateActiveConfigNetworkBridges) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveConfig().Network().Bridges().WithKey(b.key).FieldPath(),
	})
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateActiveConfigNetworkBridges) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveConfig().Network().Bridges().WithKey(b.key).FieldPath(),
	})
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateActiveConfigNetworkBridges) compare(op gotenfilter.CompareOperator, value *Device_Spec_NetworkingConfig_BridgesOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveConfig().Network().Bridges().WithKey(b.key).WithValue(value),
	})
}

type filterCndBuilderStatusNetworkConfigStateActiveConfigNetworkBonds struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusNetworkConfigStateActiveConfigNetworkBonds) In(values []map[string]*Device_Spec_NetworkingConfig_BondsOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveConfig().Network().Bonds().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateActiveConfigNetworkBonds) NotIn(values []map[string]*Device_Spec_NetworkingConfig_BondsOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveConfig().Network().Bonds().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateActiveConfigNetworkBonds) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveConfig().Network().Bonds().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateActiveConfigNetworkBonds) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveConfig().Network().Bonds().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateActiveConfigNetworkBonds) compare(op gotenfilter.CompareOperator, value map[string]*Device_Spec_NetworkingConfig_BondsOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveConfig().Network().Bonds().WithValue(value),
	})
}

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

type mapFilterCndBuilderStatusNetworkConfigStateActiveConfigNetworkBonds struct {
	builder *FilterBuilder
	key     string
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateActiveConfigNetworkBonds) Eq(value *Device_Spec_NetworkingConfig_BondsOpts) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateActiveConfigNetworkBonds) Neq(value *Device_Spec_NetworkingConfig_BondsOpts) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateActiveConfigNetworkBonds) Gt(value *Device_Spec_NetworkingConfig_BondsOpts) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateActiveConfigNetworkBonds) Gte(value *Device_Spec_NetworkingConfig_BondsOpts) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateActiveConfigNetworkBonds) Lt(value *Device_Spec_NetworkingConfig_BondsOpts) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateActiveConfigNetworkBonds) Lte(value *Device_Spec_NetworkingConfig_BondsOpts) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateActiveConfigNetworkBonds) In(values []*Device_Spec_NetworkingConfig_BondsOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveConfig().Network().Bonds().WithKey(b.key).WithArrayOfValues(values),
	})
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateActiveConfigNetworkBonds) NotIn(values []*Device_Spec_NetworkingConfig_BondsOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveConfig().Network().Bonds().WithKey(b.key).WithArrayOfValues(values),
	})
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateActiveConfigNetworkBonds) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveConfig().Network().Bonds().WithKey(b.key).FieldPath(),
	})
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateActiveConfigNetworkBonds) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveConfig().Network().Bonds().WithKey(b.key).FieldPath(),
	})
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateActiveConfigNetworkBonds) compare(op gotenfilter.CompareOperator, value *Device_Spec_NetworkingConfig_BondsOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveConfig().Network().Bonds().WithKey(b.key).WithValue(value),
	})
}

type filterCndBuilderStatusNetworkConfigStateActiveConfigNetworkTunnels struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusNetworkConfigStateActiveConfigNetworkTunnels) In(values []map[string]*Device_Spec_NetworkingConfig_TunnelsOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveConfig().Network().Tunnels().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateActiveConfigNetworkTunnels) NotIn(values []map[string]*Device_Spec_NetworkingConfig_TunnelsOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveConfig().Network().Tunnels().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateActiveConfigNetworkTunnels) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveConfig().Network().Tunnels().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateActiveConfigNetworkTunnels) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveConfig().Network().Tunnels().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateActiveConfigNetworkTunnels) compare(op gotenfilter.CompareOperator, value map[string]*Device_Spec_NetworkingConfig_TunnelsOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveConfig().Network().Tunnels().WithValue(value),
	})
}

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

type mapFilterCndBuilderStatusNetworkConfigStateActiveConfigNetworkTunnels struct {
	builder *FilterBuilder
	key     string
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateActiveConfigNetworkTunnels) Eq(value *Device_Spec_NetworkingConfig_TunnelsOpts) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateActiveConfigNetworkTunnels) Neq(value *Device_Spec_NetworkingConfig_TunnelsOpts) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateActiveConfigNetworkTunnels) Gt(value *Device_Spec_NetworkingConfig_TunnelsOpts) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateActiveConfigNetworkTunnels) Gte(value *Device_Spec_NetworkingConfig_TunnelsOpts) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateActiveConfigNetworkTunnels) Lt(value *Device_Spec_NetworkingConfig_TunnelsOpts) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateActiveConfigNetworkTunnels) Lte(value *Device_Spec_NetworkingConfig_TunnelsOpts) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateActiveConfigNetworkTunnels) In(values []*Device_Spec_NetworkingConfig_TunnelsOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveConfig().Network().Tunnels().WithKey(b.key).WithArrayOfValues(values),
	})
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateActiveConfigNetworkTunnels) NotIn(values []*Device_Spec_NetworkingConfig_TunnelsOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveConfig().Network().Tunnels().WithKey(b.key).WithArrayOfValues(values),
	})
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateActiveConfigNetworkTunnels) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveConfig().Network().Tunnels().WithKey(b.key).FieldPath(),
	})
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateActiveConfigNetworkTunnels) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveConfig().Network().Tunnels().WithKey(b.key).FieldPath(),
	})
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateActiveConfigNetworkTunnels) compare(op gotenfilter.CompareOperator, value *Device_Spec_NetworkingConfig_TunnelsOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveConfig().Network().Tunnels().WithKey(b.key).WithValue(value),
	})
}

type filterCndBuilderStatusNetworkConfigStateActiveConfigNetworkVlans struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusNetworkConfigStateActiveConfigNetworkVlans) In(values []map[string]*Device_Spec_NetworkingConfig_VlansOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveConfig().Network().Vlans().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateActiveConfigNetworkVlans) NotIn(values []map[string]*Device_Spec_NetworkingConfig_VlansOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveConfig().Network().Vlans().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateActiveConfigNetworkVlans) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveConfig().Network().Vlans().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateActiveConfigNetworkVlans) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveConfig().Network().Vlans().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateActiveConfigNetworkVlans) compare(op gotenfilter.CompareOperator, value map[string]*Device_Spec_NetworkingConfig_VlansOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveConfig().Network().Vlans().WithValue(value),
	})
}

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

type mapFilterCndBuilderStatusNetworkConfigStateActiveConfigNetworkVlans struct {
	builder *FilterBuilder
	key     string
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateActiveConfigNetworkVlans) Eq(value *Device_Spec_NetworkingConfig_VlansOpts) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateActiveConfigNetworkVlans) Neq(value *Device_Spec_NetworkingConfig_VlansOpts) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateActiveConfigNetworkVlans) Gt(value *Device_Spec_NetworkingConfig_VlansOpts) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateActiveConfigNetworkVlans) Gte(value *Device_Spec_NetworkingConfig_VlansOpts) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateActiveConfigNetworkVlans) Lt(value *Device_Spec_NetworkingConfig_VlansOpts) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateActiveConfigNetworkVlans) Lte(value *Device_Spec_NetworkingConfig_VlansOpts) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateActiveConfigNetworkVlans) In(values []*Device_Spec_NetworkingConfig_VlansOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveConfig().Network().Vlans().WithKey(b.key).WithArrayOfValues(values),
	})
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateActiveConfigNetworkVlans) NotIn(values []*Device_Spec_NetworkingConfig_VlansOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveConfig().Network().Vlans().WithKey(b.key).WithArrayOfValues(values),
	})
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateActiveConfigNetworkVlans) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveConfig().Network().Vlans().WithKey(b.key).FieldPath(),
	})
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateActiveConfigNetworkVlans) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveConfig().Network().Vlans().WithKey(b.key).FieldPath(),
	})
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateActiveConfigNetworkVlans) compare(op gotenfilter.CompareOperator, value *Device_Spec_NetworkingConfig_VlansOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveConfig().Network().Vlans().WithKey(b.key).WithValue(value),
	})
}

type filterCndBuilderStatusNetworkConfigStateActiveConfigNetworkModems struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusNetworkConfigStateActiveConfigNetworkModems) In(values []map[string]*Device_Spec_NetworkingConfig_ModemOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveConfig().Network().Modems().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateActiveConfigNetworkModems) NotIn(values []map[string]*Device_Spec_NetworkingConfig_ModemOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveConfig().Network().Modems().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateActiveConfigNetworkModems) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveConfig().Network().Modems().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateActiveConfigNetworkModems) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveConfig().Network().Modems().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateActiveConfigNetworkModems) compare(op gotenfilter.CompareOperator, value map[string]*Device_Spec_NetworkingConfig_ModemOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveConfig().Network().Modems().WithValue(value),
	})
}

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

type mapFilterCndBuilderStatusNetworkConfigStateActiveConfigNetworkModems struct {
	builder *FilterBuilder
	key     string
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateActiveConfigNetworkModems) Eq(value *Device_Spec_NetworkingConfig_ModemOpts) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateActiveConfigNetworkModems) Neq(value *Device_Spec_NetworkingConfig_ModemOpts) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateActiveConfigNetworkModems) Gt(value *Device_Spec_NetworkingConfig_ModemOpts) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateActiveConfigNetworkModems) Gte(value *Device_Spec_NetworkingConfig_ModemOpts) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateActiveConfigNetworkModems) Lt(value *Device_Spec_NetworkingConfig_ModemOpts) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateActiveConfigNetworkModems) Lte(value *Device_Spec_NetworkingConfig_ModemOpts) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateActiveConfigNetworkModems) In(values []*Device_Spec_NetworkingConfig_ModemOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveConfig().Network().Modems().WithKey(b.key).WithArrayOfValues(values),
	})
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateActiveConfigNetworkModems) NotIn(values []*Device_Spec_NetworkingConfig_ModemOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveConfig().Network().Modems().WithKey(b.key).WithArrayOfValues(values),
	})
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateActiveConfigNetworkModems) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveConfig().Network().Modems().WithKey(b.key).FieldPath(),
	})
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateActiveConfigNetworkModems) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveConfig().Network().Modems().WithKey(b.key).FieldPath(),
	})
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateActiveConfigNetworkModems) compare(op gotenfilter.CompareOperator, value *Device_Spec_NetworkingConfig_ModemOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().NetworkConfigState().ActiveConfig().Network().Modems().WithKey(b.key).WithValue(value),
	})
}

type filterCndBuilderStatusNetworkConfigStateDesiredConfig struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusNetworkConfigStateDesiredConfig) Eq(value *Device_Spec_NetplanConfig) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusNetworkConfigStateDesiredConfig) Neq(value *Device_Spec_NetplanConfig) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusNetworkConfigStateDesiredConfig) Gt(value *Device_Spec_NetplanConfig) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusNetworkConfigStateDesiredConfig) Gte(value *Device_Spec_NetplanConfig) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusNetworkConfigStateDesiredConfig) Lt(value *Device_Spec_NetplanConfig) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusNetworkConfigStateDesiredConfig) Lte(value *Device_Spec_NetplanConfig) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusNetworkConfigStateDesiredConfig) In(values []*Device_Spec_NetplanConfig) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredConfig().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDesiredConfig) NotIn(values []*Device_Spec_NetplanConfig) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredConfig().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDesiredConfig) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredConfig().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDesiredConfig) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredConfig().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDesiredConfig) compare(op gotenfilter.CompareOperator, value *Device_Spec_NetplanConfig) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredConfig().WithValue(value),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDesiredConfig) Network() *filterCndBuilderStatusNetworkConfigStateDesiredConfigNetwork {
	return &filterCndBuilderStatusNetworkConfigStateDesiredConfigNetwork{builder: b.builder}
}

type filterCndBuilderStatusNetworkConfigStateDesiredConfigNetwork struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusNetworkConfigStateDesiredConfigNetwork) Eq(value *Device_Spec_NetworkingConfig) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusNetworkConfigStateDesiredConfigNetwork) Neq(value *Device_Spec_NetworkingConfig) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusNetworkConfigStateDesiredConfigNetwork) Gt(value *Device_Spec_NetworkingConfig) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusNetworkConfigStateDesiredConfigNetwork) Gte(value *Device_Spec_NetworkingConfig) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusNetworkConfigStateDesiredConfigNetwork) Lt(value *Device_Spec_NetworkingConfig) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusNetworkConfigStateDesiredConfigNetwork) Lte(value *Device_Spec_NetworkingConfig) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusNetworkConfigStateDesiredConfigNetwork) In(values []*Device_Spec_NetworkingConfig) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredConfig().Network().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDesiredConfigNetwork) NotIn(values []*Device_Spec_NetworkingConfig) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredConfig().Network().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDesiredConfigNetwork) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredConfig().Network().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDesiredConfigNetwork) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredConfig().Network().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDesiredConfigNetwork) compare(op gotenfilter.CompareOperator, value *Device_Spec_NetworkingConfig) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredConfig().Network().WithValue(value),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDesiredConfigNetwork) Version() *filterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkVersion {
	return &filterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkVersion{builder: b.builder}
}

func (b *filterCndBuilderStatusNetworkConfigStateDesiredConfigNetwork) Renderer() *filterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkRenderer {
	return &filterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkRenderer{builder: b.builder}
}

func (b *filterCndBuilderStatusNetworkConfigStateDesiredConfigNetwork) Ethernets() *filterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkEthernets {
	return &filterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkEthernets{builder: b.builder}
}

func (b *filterCndBuilderStatusNetworkConfigStateDesiredConfigNetwork) Wifis() *filterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkWifis {
	return &filterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkWifis{builder: b.builder}
}

func (b *filterCndBuilderStatusNetworkConfigStateDesiredConfigNetwork) Bridges() *filterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkBridges {
	return &filterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkBridges{builder: b.builder}
}

func (b *filterCndBuilderStatusNetworkConfigStateDesiredConfigNetwork) Bonds() *filterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkBonds {
	return &filterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkBonds{builder: b.builder}
}

func (b *filterCndBuilderStatusNetworkConfigStateDesiredConfigNetwork) Tunnels() *filterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkTunnels {
	return &filterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkTunnels{builder: b.builder}
}

func (b *filterCndBuilderStatusNetworkConfigStateDesiredConfigNetwork) Vlans() *filterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkVlans {
	return &filterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkVlans{builder: b.builder}
}

func (b *filterCndBuilderStatusNetworkConfigStateDesiredConfigNetwork) Modems() *filterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkModems {
	return &filterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkModems{builder: b.builder}
}

type filterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkVersion struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkVersion) In(values []int32) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredConfig().Network().Version().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkVersion) NotIn(values []int32) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredConfig().Network().Version().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkVersion) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredConfig().Network().Version().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkVersion) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredConfig().Network().Version().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkVersion) compare(op gotenfilter.CompareOperator, value int32) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredConfig().Network().Version().WithValue(value),
	})
}

type filterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkRenderer struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkRenderer) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredConfig().Network().Renderer().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkRenderer) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredConfig().Network().Renderer().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkRenderer) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredConfig().Network().Renderer().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkRenderer) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredConfig().Network().Renderer().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkRenderer) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredConfig().Network().Renderer().WithValue(value),
	})
}

type filterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkEthernets struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkEthernets) In(values []map[string]*Device_Spec_NetworkingConfig_EthOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredConfig().Network().Ethernets().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkEthernets) NotIn(values []map[string]*Device_Spec_NetworkingConfig_EthOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredConfig().Network().Ethernets().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkEthernets) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredConfig().Network().Ethernets().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkEthernets) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredConfig().Network().Ethernets().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkEthernets) compare(op gotenfilter.CompareOperator, value map[string]*Device_Spec_NetworkingConfig_EthOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredConfig().Network().Ethernets().WithValue(value),
	})
}

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

type mapFilterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkEthernets struct {
	builder *FilterBuilder
	key     string
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkEthernets) Eq(value *Device_Spec_NetworkingConfig_EthOpts) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkEthernets) Neq(value *Device_Spec_NetworkingConfig_EthOpts) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkEthernets) Gt(value *Device_Spec_NetworkingConfig_EthOpts) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkEthernets) Gte(value *Device_Spec_NetworkingConfig_EthOpts) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkEthernets) Lt(value *Device_Spec_NetworkingConfig_EthOpts) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkEthernets) Lte(value *Device_Spec_NetworkingConfig_EthOpts) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkEthernets) In(values []*Device_Spec_NetworkingConfig_EthOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredConfig().Network().Ethernets().WithKey(b.key).WithArrayOfValues(values),
	})
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkEthernets) NotIn(values []*Device_Spec_NetworkingConfig_EthOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredConfig().Network().Ethernets().WithKey(b.key).WithArrayOfValues(values),
	})
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkEthernets) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredConfig().Network().Ethernets().WithKey(b.key).FieldPath(),
	})
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkEthernets) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredConfig().Network().Ethernets().WithKey(b.key).FieldPath(),
	})
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkEthernets) compare(op gotenfilter.CompareOperator, value *Device_Spec_NetworkingConfig_EthOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredConfig().Network().Ethernets().WithKey(b.key).WithValue(value),
	})
}

type filterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkWifis struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkWifis) In(values []map[string]*Device_Spec_NetworkingConfig_WifiOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredConfig().Network().Wifis().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkWifis) NotIn(values []map[string]*Device_Spec_NetworkingConfig_WifiOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredConfig().Network().Wifis().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkWifis) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredConfig().Network().Wifis().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkWifis) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredConfig().Network().Wifis().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkWifis) compare(op gotenfilter.CompareOperator, value map[string]*Device_Spec_NetworkingConfig_WifiOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredConfig().Network().Wifis().WithValue(value),
	})
}

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

type mapFilterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkWifis struct {
	builder *FilterBuilder
	key     string
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkWifis) Eq(value *Device_Spec_NetworkingConfig_WifiOpts) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkWifis) Neq(value *Device_Spec_NetworkingConfig_WifiOpts) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkWifis) Gt(value *Device_Spec_NetworkingConfig_WifiOpts) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkWifis) Gte(value *Device_Spec_NetworkingConfig_WifiOpts) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkWifis) Lt(value *Device_Spec_NetworkingConfig_WifiOpts) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkWifis) Lte(value *Device_Spec_NetworkingConfig_WifiOpts) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkWifis) In(values []*Device_Spec_NetworkingConfig_WifiOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredConfig().Network().Wifis().WithKey(b.key).WithArrayOfValues(values),
	})
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkWifis) NotIn(values []*Device_Spec_NetworkingConfig_WifiOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredConfig().Network().Wifis().WithKey(b.key).WithArrayOfValues(values),
	})
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkWifis) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredConfig().Network().Wifis().WithKey(b.key).FieldPath(),
	})
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkWifis) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredConfig().Network().Wifis().WithKey(b.key).FieldPath(),
	})
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkWifis) compare(op gotenfilter.CompareOperator, value *Device_Spec_NetworkingConfig_WifiOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredConfig().Network().Wifis().WithKey(b.key).WithValue(value),
	})
}

type filterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkBridges struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkBridges) In(values []map[string]*Device_Spec_NetworkingConfig_BridgesOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredConfig().Network().Bridges().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkBridges) NotIn(values []map[string]*Device_Spec_NetworkingConfig_BridgesOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredConfig().Network().Bridges().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkBridges) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredConfig().Network().Bridges().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkBridges) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredConfig().Network().Bridges().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkBridges) compare(op gotenfilter.CompareOperator, value map[string]*Device_Spec_NetworkingConfig_BridgesOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredConfig().Network().Bridges().WithValue(value),
	})
}

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

type mapFilterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkBridges struct {
	builder *FilterBuilder
	key     string
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkBridges) Eq(value *Device_Spec_NetworkingConfig_BridgesOpts) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkBridges) Neq(value *Device_Spec_NetworkingConfig_BridgesOpts) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkBridges) Gt(value *Device_Spec_NetworkingConfig_BridgesOpts) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkBridges) Gte(value *Device_Spec_NetworkingConfig_BridgesOpts) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkBridges) Lt(value *Device_Spec_NetworkingConfig_BridgesOpts) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkBridges) Lte(value *Device_Spec_NetworkingConfig_BridgesOpts) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkBridges) In(values []*Device_Spec_NetworkingConfig_BridgesOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredConfig().Network().Bridges().WithKey(b.key).WithArrayOfValues(values),
	})
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkBridges) NotIn(values []*Device_Spec_NetworkingConfig_BridgesOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredConfig().Network().Bridges().WithKey(b.key).WithArrayOfValues(values),
	})
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkBridges) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredConfig().Network().Bridges().WithKey(b.key).FieldPath(),
	})
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkBridges) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredConfig().Network().Bridges().WithKey(b.key).FieldPath(),
	})
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkBridges) compare(op gotenfilter.CompareOperator, value *Device_Spec_NetworkingConfig_BridgesOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredConfig().Network().Bridges().WithKey(b.key).WithValue(value),
	})
}

type filterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkBonds struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkBonds) In(values []map[string]*Device_Spec_NetworkingConfig_BondsOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredConfig().Network().Bonds().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkBonds) NotIn(values []map[string]*Device_Spec_NetworkingConfig_BondsOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredConfig().Network().Bonds().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkBonds) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredConfig().Network().Bonds().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkBonds) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredConfig().Network().Bonds().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkBonds) compare(op gotenfilter.CompareOperator, value map[string]*Device_Spec_NetworkingConfig_BondsOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredConfig().Network().Bonds().WithValue(value),
	})
}

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

type mapFilterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkBonds struct {
	builder *FilterBuilder
	key     string
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkBonds) Eq(value *Device_Spec_NetworkingConfig_BondsOpts) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkBonds) Neq(value *Device_Spec_NetworkingConfig_BondsOpts) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkBonds) Gt(value *Device_Spec_NetworkingConfig_BondsOpts) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkBonds) Gte(value *Device_Spec_NetworkingConfig_BondsOpts) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkBonds) Lt(value *Device_Spec_NetworkingConfig_BondsOpts) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkBonds) Lte(value *Device_Spec_NetworkingConfig_BondsOpts) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkBonds) In(values []*Device_Spec_NetworkingConfig_BondsOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredConfig().Network().Bonds().WithKey(b.key).WithArrayOfValues(values),
	})
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkBonds) NotIn(values []*Device_Spec_NetworkingConfig_BondsOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredConfig().Network().Bonds().WithKey(b.key).WithArrayOfValues(values),
	})
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkBonds) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredConfig().Network().Bonds().WithKey(b.key).FieldPath(),
	})
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkBonds) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredConfig().Network().Bonds().WithKey(b.key).FieldPath(),
	})
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkBonds) compare(op gotenfilter.CompareOperator, value *Device_Spec_NetworkingConfig_BondsOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredConfig().Network().Bonds().WithKey(b.key).WithValue(value),
	})
}

type filterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkTunnels struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkTunnels) In(values []map[string]*Device_Spec_NetworkingConfig_TunnelsOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredConfig().Network().Tunnels().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkTunnels) NotIn(values []map[string]*Device_Spec_NetworkingConfig_TunnelsOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredConfig().Network().Tunnels().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkTunnels) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredConfig().Network().Tunnels().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkTunnels) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredConfig().Network().Tunnels().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkTunnels) compare(op gotenfilter.CompareOperator, value map[string]*Device_Spec_NetworkingConfig_TunnelsOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredConfig().Network().Tunnels().WithValue(value),
	})
}

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

type mapFilterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkTunnels struct {
	builder *FilterBuilder
	key     string
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkTunnels) Eq(value *Device_Spec_NetworkingConfig_TunnelsOpts) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkTunnels) Neq(value *Device_Spec_NetworkingConfig_TunnelsOpts) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkTunnels) Gt(value *Device_Spec_NetworkingConfig_TunnelsOpts) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkTunnels) Gte(value *Device_Spec_NetworkingConfig_TunnelsOpts) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkTunnels) Lt(value *Device_Spec_NetworkingConfig_TunnelsOpts) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkTunnels) Lte(value *Device_Spec_NetworkingConfig_TunnelsOpts) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkTunnels) In(values []*Device_Spec_NetworkingConfig_TunnelsOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredConfig().Network().Tunnels().WithKey(b.key).WithArrayOfValues(values),
	})
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkTunnels) NotIn(values []*Device_Spec_NetworkingConfig_TunnelsOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredConfig().Network().Tunnels().WithKey(b.key).WithArrayOfValues(values),
	})
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkTunnels) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredConfig().Network().Tunnels().WithKey(b.key).FieldPath(),
	})
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkTunnels) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredConfig().Network().Tunnels().WithKey(b.key).FieldPath(),
	})
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkTunnels) compare(op gotenfilter.CompareOperator, value *Device_Spec_NetworkingConfig_TunnelsOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredConfig().Network().Tunnels().WithKey(b.key).WithValue(value),
	})
}

type filterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkVlans struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkVlans) In(values []map[string]*Device_Spec_NetworkingConfig_VlansOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredConfig().Network().Vlans().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkVlans) NotIn(values []map[string]*Device_Spec_NetworkingConfig_VlansOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredConfig().Network().Vlans().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkVlans) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredConfig().Network().Vlans().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkVlans) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredConfig().Network().Vlans().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkVlans) compare(op gotenfilter.CompareOperator, value map[string]*Device_Spec_NetworkingConfig_VlansOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredConfig().Network().Vlans().WithValue(value),
	})
}

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

type mapFilterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkVlans struct {
	builder *FilterBuilder
	key     string
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkVlans) Eq(value *Device_Spec_NetworkingConfig_VlansOpts) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkVlans) Neq(value *Device_Spec_NetworkingConfig_VlansOpts) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkVlans) Gt(value *Device_Spec_NetworkingConfig_VlansOpts) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkVlans) Gte(value *Device_Spec_NetworkingConfig_VlansOpts) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkVlans) Lt(value *Device_Spec_NetworkingConfig_VlansOpts) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkVlans) Lte(value *Device_Spec_NetworkingConfig_VlansOpts) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkVlans) In(values []*Device_Spec_NetworkingConfig_VlansOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredConfig().Network().Vlans().WithKey(b.key).WithArrayOfValues(values),
	})
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkVlans) NotIn(values []*Device_Spec_NetworkingConfig_VlansOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredConfig().Network().Vlans().WithKey(b.key).WithArrayOfValues(values),
	})
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkVlans) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredConfig().Network().Vlans().WithKey(b.key).FieldPath(),
	})
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkVlans) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredConfig().Network().Vlans().WithKey(b.key).FieldPath(),
	})
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkVlans) compare(op gotenfilter.CompareOperator, value *Device_Spec_NetworkingConfig_VlansOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredConfig().Network().Vlans().WithKey(b.key).WithValue(value),
	})
}

type filterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkModems struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkModems) In(values []map[string]*Device_Spec_NetworkingConfig_ModemOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredConfig().Network().Modems().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkModems) NotIn(values []map[string]*Device_Spec_NetworkingConfig_ModemOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredConfig().Network().Modems().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkModems) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredConfig().Network().Modems().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkModems) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredConfig().Network().Modems().FieldPath(),
	})
}

func (b *filterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkModems) compare(op gotenfilter.CompareOperator, value map[string]*Device_Spec_NetworkingConfig_ModemOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredConfig().Network().Modems().WithValue(value),
	})
}

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

type mapFilterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkModems struct {
	builder *FilterBuilder
	key     string
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkModems) Eq(value *Device_Spec_NetworkingConfig_ModemOpts) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkModems) Neq(value *Device_Spec_NetworkingConfig_ModemOpts) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkModems) Gt(value *Device_Spec_NetworkingConfig_ModemOpts) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkModems) Gte(value *Device_Spec_NetworkingConfig_ModemOpts) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkModems) Lt(value *Device_Spec_NetworkingConfig_ModemOpts) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkModems) Lte(value *Device_Spec_NetworkingConfig_ModemOpts) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkModems) In(values []*Device_Spec_NetworkingConfig_ModemOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredConfig().Network().Modems().WithKey(b.key).WithArrayOfValues(values),
	})
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkModems) NotIn(values []*Device_Spec_NetworkingConfig_ModemOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredConfig().Network().Modems().WithKey(b.key).WithArrayOfValues(values),
	})
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkModems) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredConfig().Network().Modems().WithKey(b.key).FieldPath(),
	})
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkModems) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredConfig().Network().Modems().WithKey(b.key).FieldPath(),
	})
}

func (b *mapFilterCndBuilderStatusNetworkConfigStateDesiredConfigNetworkModems) compare(op gotenfilter.CompareOperator, value *Device_Spec_NetworkingConfig_ModemOpts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().NetworkConfigState().DesiredConfig().Network().Modems().WithKey(b.key).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) 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 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) Memory() *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemory {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemory{builder: b.builder}
}

type filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemory struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemory) In(values [][]*Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_Memory) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().Memory().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemory) NotIn(values [][]*Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_Memory) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().Memory().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemory) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().Memory().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemory) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().Memory().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemory) Contains(value *Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_Memory) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().Memory().FieldPath(),
		Value:     NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().Memory().WithItemValue(value),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemory) ContainsAnyOf(values []*Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_Memory) *FilterBuilder {
	pathSelector := NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().Memory()
	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().Memory().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemory) ContainsAll(values []*Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_Memory) *FilterBuilder {
	pathSelector := NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().Memory()
	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().Memory().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemory) compare(op gotenfilter.CompareOperator, value []*Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_Memory) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().Memory().WithValue(value),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemory) Description() *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryDescription {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryDescription{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemory) SizeBytes() *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemorySizeBytes {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemorySizeBytes{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemory) MemoryBanks() *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryMemoryBanks {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryMemoryBanks{builder: b.builder}
}

type filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryDescription struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryDescription) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().Memory().Description().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryDescription) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().Memory().Description().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryDescription) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().Memory().Description().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryDescription) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().Memory().Description().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryDescription) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().Memory().Description().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemorySizeBytes struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemorySizeBytes) In(values []int64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().Memory().SizeBytes().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemorySizeBytes) NotIn(values []int64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().Memory().SizeBytes().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemorySizeBytes) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().Memory().SizeBytes().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemorySizeBytes) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().Memory().SizeBytes().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemorySizeBytes) compare(op gotenfilter.CompareOperator, value int64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().Memory().SizeBytes().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryMemoryBanks struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryMemoryBanks) In(values [][]*Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_Memory_MemoryBank) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().Memory().MemoryBanks().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryMemoryBanks) NotIn(values [][]*Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_Memory_MemoryBank) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().Memory().MemoryBanks().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryMemoryBanks) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().Memory().MemoryBanks().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryMemoryBanks) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().Memory().MemoryBanks().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryMemoryBanks) Contains(value *Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_Memory_MemoryBank) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().Memory().MemoryBanks().FieldPath(),
		Value:     NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().Memory().MemoryBanks().WithItemValue(value),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryMemoryBanks) ContainsAnyOf(values []*Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_Memory_MemoryBank) *FilterBuilder {
	pathSelector := NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().Memory().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().Memory().MemoryBanks().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryMemoryBanks) ContainsAll(values []*Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_Memory_MemoryBank) *FilterBuilder {
	pathSelector := NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().Memory().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().Memory().MemoryBanks().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryMemoryBanks) compare(op gotenfilter.CompareOperator, value []*Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_Memory_MemoryBank) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().Memory().MemoryBanks().WithValue(value),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryMemoryBanks) Description() *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryMemoryBanksDescription {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryMemoryBanksDescription{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryMemoryBanks) Product() *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryMemoryBanksProduct {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryMemoryBanksProduct{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryMemoryBanks) Vendor() *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryMemoryBanksVendor {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryMemoryBanksVendor{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryMemoryBanks) Serial() *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryMemoryBanksSerial {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryMemoryBanksSerial{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryMemoryBanks) Slot() *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryMemoryBanksSlot {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryMemoryBanksSlot{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryMemoryBanks) SizeBytes() *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryMemoryBanksSizeBytes {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryMemoryBanksSizeBytes{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryMemoryBanks) FrequencyHz() *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryMemoryBanksFrequencyHz {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryMemoryBanksFrequencyHz{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryMemoryBanks) WidthBits() *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryMemoryBanksWidthBits {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryMemoryBanksWidthBits{builder: b.builder}
}

type filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryMemoryBanksDescription struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryMemoryBanksDescription) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().Memory().MemoryBanks().Description().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryMemoryBanksDescription) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().Memory().MemoryBanks().Description().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryMemoryBanksDescription) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().Memory().MemoryBanks().Description().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryMemoryBanksDescription) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().Memory().MemoryBanks().Description().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryMemoryBanksDescription) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().Memory().MemoryBanks().Description().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryMemoryBanksProduct struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryMemoryBanksProduct) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().Memory().MemoryBanks().Product().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryMemoryBanksProduct) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().Memory().MemoryBanks().Product().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryMemoryBanksProduct) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().Memory().MemoryBanks().Product().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryMemoryBanksProduct) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().Memory().MemoryBanks().Product().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryMemoryBanksProduct) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().Memory().MemoryBanks().Product().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryMemoryBanksVendor struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryMemoryBanksVendor) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().Memory().MemoryBanks().Vendor().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryMemoryBanksVendor) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().Memory().MemoryBanks().Vendor().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryMemoryBanksVendor) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().Memory().MemoryBanks().Vendor().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryMemoryBanksVendor) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().Memory().MemoryBanks().Vendor().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryMemoryBanksVendor) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().Memory().MemoryBanks().Vendor().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryMemoryBanksSerial struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryMemoryBanksSerial) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().Memory().MemoryBanks().Serial().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryMemoryBanksSerial) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().Memory().MemoryBanks().Serial().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryMemoryBanksSerial) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().Memory().MemoryBanks().Serial().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryMemoryBanksSerial) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().Memory().MemoryBanks().Serial().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryMemoryBanksSerial) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().Memory().MemoryBanks().Serial().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryMemoryBanksSlot struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryMemoryBanksSlot) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().Memory().MemoryBanks().Slot().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryMemoryBanksSlot) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().Memory().MemoryBanks().Slot().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryMemoryBanksSlot) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().Memory().MemoryBanks().Slot().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryMemoryBanksSlot) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().Memory().MemoryBanks().Slot().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryMemoryBanksSlot) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().Memory().MemoryBanks().Slot().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryMemoryBanksSizeBytes struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryMemoryBanksSizeBytes) In(values []int64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().Memory().MemoryBanks().SizeBytes().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryMemoryBanksSizeBytes) NotIn(values []int64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().Memory().MemoryBanks().SizeBytes().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryMemoryBanksSizeBytes) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().Memory().MemoryBanks().SizeBytes().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryMemoryBanksSizeBytes) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().Memory().MemoryBanks().SizeBytes().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryMemoryBanksSizeBytes) compare(op gotenfilter.CompareOperator, value int64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().Memory().MemoryBanks().SizeBytes().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryMemoryBanksFrequencyHz struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryMemoryBanksFrequencyHz) In(values []int64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().Memory().MemoryBanks().FrequencyHz().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryMemoryBanksFrequencyHz) NotIn(values []int64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().Memory().MemoryBanks().FrequencyHz().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryMemoryBanksFrequencyHz) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().Memory().MemoryBanks().FrequencyHz().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryMemoryBanksFrequencyHz) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().Memory().MemoryBanks().FrequencyHz().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryMemoryBanksFrequencyHz) compare(op gotenfilter.CompareOperator, value int64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().Memory().MemoryBanks().FrequencyHz().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryMemoryBanksWidthBits struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryMemoryBanksWidthBits) In(values []int32) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().Memory().MemoryBanks().WidthBits().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryMemoryBanksWidthBits) NotIn(values []int32) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().Memory().MemoryBanks().WidthBits().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryMemoryBanksWidthBits) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().Memory().MemoryBanks().WidthBits().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryMemoryBanksWidthBits) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().Memory().MemoryBanks().WidthBits().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationMemoryInfoMemoryMemoryBanksWidthBits) compare(op gotenfilter.CompareOperator, value int32) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().MemoryInfo().Memory().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) Signal() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignal {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignal{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 filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignal struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignal) Eq(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Signal) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignal) Neq(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Signal) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignal) Gt(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Signal) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignal) Gte(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Signal) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignal) Lt(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Signal) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignal) Lte(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Signal) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignal) In(values []*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Signal) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignal) NotIn(values []*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Signal) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignal) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignal) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignal) compare(op gotenfilter.CompareOperator, value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Signal) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().WithValue(value),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignal) FiveG() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalFiveG {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalFiveG{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignal) Cdma1X() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalCdma1X {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalCdma1X{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignal) Evdo() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalEvdo {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalEvdo{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignal) Gsm() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalGsm {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalGsm{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignal) LteSignal() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalLteSignal {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalLteSignal{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignal) Refresh() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalRefresh {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalRefresh{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignal) Threshold() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalThreshold {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalThreshold{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignal) Umts() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalUmts {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalUmts{builder: b.builder}
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalFiveG struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalFiveG) Eq(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Signal5G) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalFiveG) Neq(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Signal5G) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalFiveG) Gt(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Signal5G) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalFiveG) Gte(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Signal5G) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalFiveG) Lt(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Signal5G) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalFiveG) Lte(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Signal5G) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalFiveG) In(values []*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Signal5G) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().FiveG().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalFiveG) NotIn(values []*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Signal5G) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().FiveG().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalFiveG) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().FiveG().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalFiveG) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().FiveG().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalFiveG) compare(op gotenfilter.CompareOperator, value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Signal5G) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().FiveG().WithValue(value),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalFiveG) ErrorRate() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalFiveGErrorRate {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalFiveGErrorRate{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalFiveG) Rsrp() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalFiveGRsrp {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalFiveGRsrp{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalFiveG) Rsrq() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalFiveGRsrq {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalFiveGRsrq{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalFiveG) Snr() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalFiveGSnr {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalFiveGSnr{builder: b.builder}
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalFiveGErrorRate struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalFiveGErrorRate) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().FiveG().ErrorRate().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalFiveGErrorRate) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().FiveG().ErrorRate().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalFiveGErrorRate) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().FiveG().ErrorRate().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalFiveGErrorRate) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().FiveG().ErrorRate().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalFiveGErrorRate) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().FiveG().ErrorRate().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalFiveGRsrp struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalFiveGRsrp) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().FiveG().Rsrp().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalFiveGRsrp) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().FiveG().Rsrp().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalFiveGRsrp) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().FiveG().Rsrp().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalFiveGRsrp) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().FiveG().Rsrp().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalFiveGRsrp) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().FiveG().Rsrp().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalFiveGRsrq struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalFiveGRsrq) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().FiveG().Rsrq().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalFiveGRsrq) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().FiveG().Rsrq().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalFiveGRsrq) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().FiveG().Rsrq().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalFiveGRsrq) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().FiveG().Rsrq().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalFiveGRsrq) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().FiveG().Rsrq().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalFiveGSnr struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalFiveGSnr) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().FiveG().Snr().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalFiveGSnr) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().FiveG().Snr().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalFiveGSnr) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().FiveG().Snr().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalFiveGSnr) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().FiveG().Snr().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalFiveGSnr) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().FiveG().Snr().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalCdma1X struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalCdma1X) Eq(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalCdma1X) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalCdma1X) Neq(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalCdma1X) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalCdma1X) Gt(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalCdma1X) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalCdma1X) Gte(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalCdma1X) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalCdma1X) Lt(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalCdma1X) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalCdma1X) Lte(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalCdma1X) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalCdma1X) In(values []*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalCdma1X) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Cdma1X().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalCdma1X) NotIn(values []*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalCdma1X) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Cdma1X().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalCdma1X) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Cdma1X().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalCdma1X) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Cdma1X().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalCdma1X) compare(op gotenfilter.CompareOperator, value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalCdma1X) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Cdma1X().WithValue(value),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalCdma1X) Ecio() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalCdma1XEcio {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalCdma1XEcio{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalCdma1X) ErrorRate() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalCdma1XErrorRate {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalCdma1XErrorRate{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalCdma1X) Rssi() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalCdma1XRssi {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalCdma1XRssi{builder: b.builder}
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalCdma1XEcio struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalCdma1XEcio) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Cdma1X().Ecio().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalCdma1XEcio) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Cdma1X().Ecio().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalCdma1XEcio) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Cdma1X().Ecio().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalCdma1XEcio) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Cdma1X().Ecio().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalCdma1XEcio) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Cdma1X().Ecio().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalCdma1XErrorRate struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalCdma1XErrorRate) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Cdma1X().ErrorRate().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalCdma1XErrorRate) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Cdma1X().ErrorRate().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalCdma1XErrorRate) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Cdma1X().ErrorRate().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalCdma1XErrorRate) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Cdma1X().ErrorRate().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalCdma1XErrorRate) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Cdma1X().ErrorRate().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalCdma1XRssi struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalCdma1XRssi) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Cdma1X().Rssi().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalCdma1XRssi) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Cdma1X().Rssi().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalCdma1XRssi) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Cdma1X().Rssi().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalCdma1XRssi) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Cdma1X().Rssi().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalCdma1XRssi) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Cdma1X().Rssi().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalEvdo struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalEvdo) Eq(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalEvdo) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalEvdo) Neq(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalEvdo) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalEvdo) Gt(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalEvdo) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalEvdo) Gte(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalEvdo) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalEvdo) Lt(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalEvdo) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalEvdo) Lte(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalEvdo) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalEvdo) In(values []*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalEvdo) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Evdo().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalEvdo) NotIn(values []*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalEvdo) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Evdo().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalEvdo) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Evdo().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalEvdo) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Evdo().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalEvdo) compare(op gotenfilter.CompareOperator, value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalEvdo) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Evdo().WithValue(value),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalEvdo) Ecio() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalEvdoEcio {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalEvdoEcio{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalEvdo) ErrorRate() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalEvdoErrorRate {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalEvdoErrorRate{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalEvdo) Io() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalEvdoIo {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalEvdoIo{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalEvdo) Rssi() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalEvdoRssi {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalEvdoRssi{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalEvdo) Sinr() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalEvdoSinr {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalEvdoSinr{builder: b.builder}
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalEvdoEcio struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalEvdoEcio) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Evdo().Ecio().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalEvdoEcio) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Evdo().Ecio().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalEvdoEcio) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Evdo().Ecio().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalEvdoEcio) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Evdo().Ecio().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalEvdoEcio) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Evdo().Ecio().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalEvdoErrorRate struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalEvdoErrorRate) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Evdo().ErrorRate().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalEvdoErrorRate) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Evdo().ErrorRate().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalEvdoErrorRate) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Evdo().ErrorRate().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalEvdoErrorRate) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Evdo().ErrorRate().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalEvdoErrorRate) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Evdo().ErrorRate().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalEvdoIo struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalEvdoIo) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Evdo().Io().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalEvdoIo) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Evdo().Io().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalEvdoIo) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Evdo().Io().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalEvdoIo) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Evdo().Io().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalEvdoIo) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Evdo().Io().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalEvdoRssi struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalEvdoRssi) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Evdo().Rssi().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalEvdoRssi) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Evdo().Rssi().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalEvdoRssi) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Evdo().Rssi().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalEvdoRssi) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Evdo().Rssi().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalEvdoRssi) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Evdo().Rssi().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalEvdoSinr struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalEvdoSinr) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Evdo().Sinr().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalEvdoSinr) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Evdo().Sinr().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalEvdoSinr) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Evdo().Sinr().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalEvdoSinr) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Evdo().Sinr().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalEvdoSinr) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Evdo().Sinr().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalGsm struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalGsm) Eq(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalGsm) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalGsm) Neq(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalGsm) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalGsm) Gt(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalGsm) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalGsm) Gte(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalGsm) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalGsm) Lt(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalGsm) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalGsm) Lte(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalGsm) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalGsm) In(values []*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalGsm) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Gsm().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalGsm) NotIn(values []*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalGsm) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Gsm().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalGsm) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Gsm().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalGsm) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Gsm().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalGsm) compare(op gotenfilter.CompareOperator, value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalGsm) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Gsm().WithValue(value),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalGsm) ErrorRate() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalGsmErrorRate {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalGsmErrorRate{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalGsm) Rssi() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalGsmRssi {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalGsmRssi{builder: b.builder}
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalGsmErrorRate struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalGsmErrorRate) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Gsm().ErrorRate().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalGsmErrorRate) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Gsm().ErrorRate().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalGsmErrorRate) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Gsm().ErrorRate().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalGsmErrorRate) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Gsm().ErrorRate().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalGsmErrorRate) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Gsm().ErrorRate().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalGsmRssi struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalGsmRssi) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Gsm().Rssi().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalGsmRssi) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Gsm().Rssi().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalGsmRssi) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Gsm().Rssi().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalGsmRssi) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Gsm().Rssi().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalGsmRssi) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Gsm().Rssi().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalLteSignal struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalLteSignal) Eq(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalLte) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalLteSignal) Neq(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalLte) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalLteSignal) Gt(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalLte) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalLteSignal) Gte(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalLte) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalLteSignal) Lt(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalLte) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalLteSignal) Lte(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalLte) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalLteSignal) In(values []*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalLte) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().LteSignal().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalLteSignal) NotIn(values []*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalLte) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().LteSignal().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalLteSignal) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().LteSignal().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalLteSignal) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().LteSignal().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalLteSignal) compare(op gotenfilter.CompareOperator, value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalLte) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().LteSignal().WithValue(value),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalLteSignal) ErrorRate() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalLteSignalErrorRate {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalLteSignalErrorRate{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalLteSignal) Rsrp() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalLteSignalRsrp {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalLteSignalRsrp{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalLteSignal) Rsrq() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalLteSignalRsrq {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalLteSignalRsrq{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalLteSignal) Rssi() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalLteSignalRssi {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalLteSignalRssi{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalLteSignal) Snr() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalLteSignalSnr {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalLteSignalSnr{builder: b.builder}
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalLteSignalErrorRate struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalLteSignalErrorRate) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().LteSignal().ErrorRate().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalLteSignalErrorRate) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().LteSignal().ErrorRate().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalLteSignalErrorRate) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().LteSignal().ErrorRate().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalLteSignalErrorRate) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().LteSignal().ErrorRate().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalLteSignalErrorRate) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().LteSignal().ErrorRate().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalLteSignalRsrp struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalLteSignalRsrp) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().LteSignal().Rsrp().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalLteSignalRsrp) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().LteSignal().Rsrp().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalLteSignalRsrp) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().LteSignal().Rsrp().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalLteSignalRsrp) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().LteSignal().Rsrp().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalLteSignalRsrp) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().LteSignal().Rsrp().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalLteSignalRsrq struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalLteSignalRsrq) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().LteSignal().Rsrq().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalLteSignalRsrq) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().LteSignal().Rsrq().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalLteSignalRsrq) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().LteSignal().Rsrq().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalLteSignalRsrq) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().LteSignal().Rsrq().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalLteSignalRsrq) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().LteSignal().Rsrq().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalLteSignalRssi struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalLteSignalRssi) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().LteSignal().Rssi().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalLteSignalRssi) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().LteSignal().Rssi().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalLteSignalRssi) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().LteSignal().Rssi().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalLteSignalRssi) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().LteSignal().Rssi().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalLteSignalRssi) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().LteSignal().Rssi().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalLteSignalSnr struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalLteSignalSnr) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().LteSignal().Snr().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalLteSignalSnr) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().LteSignal().Snr().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalLteSignalSnr) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().LteSignal().Snr().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalLteSignalSnr) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().LteSignal().Snr().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalLteSignalSnr) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().LteSignal().Snr().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalRefresh struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalRefresh) Eq(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalRefresh) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalRefresh) Neq(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalRefresh) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalRefresh) Gt(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalRefresh) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalRefresh) Gte(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalRefresh) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalRefresh) Lt(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalRefresh) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalRefresh) Lte(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalRefresh) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalRefresh) In(values []*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalRefresh) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Refresh().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalRefresh) NotIn(values []*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalRefresh) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Refresh().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalRefresh) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Refresh().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalRefresh) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Refresh().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalRefresh) compare(op gotenfilter.CompareOperator, value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalRefresh) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Refresh().WithValue(value),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalRefresh) Rate() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalRefreshRate {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalRefreshRate{builder: b.builder}
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalRefreshRate struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalRefreshRate) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Refresh().Rate().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalRefreshRate) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Refresh().Rate().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalRefreshRate) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Refresh().Rate().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalRefreshRate) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Refresh().Rate().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalRefreshRate) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Refresh().Rate().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalThreshold struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalThreshold) Eq(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalThreshold) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalThreshold) Neq(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalThreshold) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalThreshold) Gt(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalThreshold) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalThreshold) Gte(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalThreshold) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalThreshold) Lt(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalThreshold) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalThreshold) Lte(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalThreshold) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalThreshold) In(values []*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalThreshold) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Threshold().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalThreshold) NotIn(values []*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalThreshold) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Threshold().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalThreshold) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Threshold().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalThreshold) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Threshold().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalThreshold) compare(op gotenfilter.CompareOperator, value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalThreshold) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Threshold().WithValue(value),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalThreshold) ErrorRate() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalThresholdErrorRate {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalThresholdErrorRate{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalThreshold) Rssi() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalThresholdRssi {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalThresholdRssi{builder: b.builder}
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalThresholdErrorRate struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalThresholdErrorRate) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Threshold().ErrorRate().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalThresholdErrorRate) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Threshold().ErrorRate().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalThresholdErrorRate) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Threshold().ErrorRate().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalThresholdErrorRate) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Threshold().ErrorRate().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalThresholdErrorRate) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Threshold().ErrorRate().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalThresholdRssi struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalThresholdRssi) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Threshold().Rssi().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalThresholdRssi) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Threshold().Rssi().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalThresholdRssi) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Threshold().Rssi().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalThresholdRssi) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Threshold().Rssi().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalThresholdRssi) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Threshold().Rssi().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalUmts struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalUmts) Eq(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalUmts) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalUmts) Neq(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalUmts) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalUmts) Gt(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalUmts) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalUmts) Gte(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalUmts) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalUmts) Lt(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalUmts) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalUmts) Lte(value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalUmts) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalUmts) In(values []*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalUmts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Umts().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalUmts) NotIn(values []*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalUmts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Umts().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalUmts) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Umts().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalUmts) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Umts().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalUmts) compare(op gotenfilter.CompareOperator, value *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalUmts) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Umts().WithValue(value),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalUmts) Ecio() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalUmtsEcio {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalUmtsEcio{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalUmts) ErrorRate() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalUmtsErrorRate {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalUmtsErrorRate{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalUmts) Rscp() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalUmtsRscp {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalUmtsRscp{builder: b.builder}
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalUmts) Rssi() *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalUmtsRssi {
	return &filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalUmtsRssi{builder: b.builder}
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalUmtsEcio struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalUmtsEcio) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Umts().Ecio().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalUmtsEcio) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Umts().Ecio().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalUmtsEcio) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Umts().Ecio().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalUmtsEcio) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Umts().Ecio().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalUmtsEcio) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Umts().Ecio().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalUmtsErrorRate struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalUmtsErrorRate) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Umts().ErrorRate().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalUmtsErrorRate) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Umts().ErrorRate().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalUmtsErrorRate) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Umts().ErrorRate().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalUmtsErrorRate) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Umts().ErrorRate().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalUmtsErrorRate) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Umts().ErrorRate().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalUmtsRscp struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalUmtsRscp) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Umts().Rscp().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalUmtsRscp) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Umts().Rscp().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalUmtsRscp) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Umts().Rscp().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalUmtsRscp) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Umts().Rscp().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalUmtsRscp) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Umts().Rscp().WithValue(value),
	})
}

type filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalUmtsRssi struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalUmtsRssi) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Umts().Rssi().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalUmtsRssi) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		Device_FieldPathArrayOfValues: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Umts().Rssi().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalUmtsRssi) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Umts().Rssi().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalUmtsRssi) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Umts().Rssi().FieldPath(),
	})
}

func (b *filterCndBuilderStatusDeviceInfoHardwareInformationModemStatusModemSignalUmtsRssi) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:              op,
		Device_FieldPathValue: NewDeviceFieldPathBuilder().Status().DeviceInfo().HardwareInformation().ModemStatus().Modem().Signal().Umts().Rssi().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 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),
	})
}

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),
	})
}