resource_change_log.pb.filterbuilder.go

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

package resource_change_log

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

// proto imports
import (
	common "github.com/cloudwan/edgelq-sdk/audit/resources/v1/common"
	iam_iam_common "github.com/cloudwan/edgelq-sdk/iam/resources/v1/common"
	iam_organization "github.com/cloudwan/edgelq-sdk/iam/resources/v1/organization"
	iam_project "github.com/cloudwan/edgelq-sdk/iam/resources/v1/project"
	meta_service "github.com/cloudwan/goten-sdk/meta-service/resources/v1/service"
	meta "github.com/cloudwan/goten-sdk/types/meta"
	multi_region_policy "github.com/cloudwan/goten-sdk/types/multi_region_policy"
	anypb "google.golang.org/protobuf/types/known/anypb"
	fieldmaskpb "google.golang.org/protobuf/types/known/fieldmaskpb"
	timestamppb "google.golang.org/protobuf/types/known/timestamppb"
)

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

// make sure we're using proto imports
var (
	_ = &common.Authentication{}
	_ = &iam_iam_common.PCR{}
	_ = &iam_organization.Organization{}
	_ = &iam_project.Project{}
	_ = &anypb.Any{}
	_ = &fieldmaskpb.FieldMask{}
	_ = &timestamppb.Timestamp{}
	_ = &meta_service.Service{}
	_ = &meta.Meta{}
	_ = &multi_region_policy.MultiRegionPolicy{}
)

type FilterBuilderOrCondition interface {
	_IsResourceChangeLogFilterBuilderOrCondition()
}

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

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

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

type filterCndBuilder struct {
	builder *FilterBuilder
}

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

func (b *filterCndBuilder) Scope() *filterCndBuilderScope {
	return &filterCndBuilderScope{builder: b.builder}
}

func (b *filterCndBuilder) RequestId() *filterCndBuilderRequestId {
	return &filterCndBuilderRequestId{builder: b.builder}
}

func (b *filterCndBuilder) Timestamp() *filterCndBuilderTimestamp {
	return &filterCndBuilderTimestamp{builder: b.builder}
}

func (b *filterCndBuilder) Authentication() *filterCndBuilderAuthentication {
	return &filterCndBuilderAuthentication{builder: b.builder}
}

func (b *filterCndBuilder) Service() *filterCndBuilderService {
	return &filterCndBuilderService{builder: b.builder}
}

func (b *filterCndBuilder) Resource() *filterCndBuilderResource {
	return &filterCndBuilderResource{builder: b.builder}
}

func (b *filterCndBuilder) Transaction() *filterCndBuilderTransaction {
	return &filterCndBuilderTransaction{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{
		ResourceChangeLog_FieldPathArrayOfValues: NewResourceChangeLogFieldPathBuilder().Name().WithArrayOfValues(values),
	})
}

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

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

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

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

type filterCndBuilderScope struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderScope) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		ResourceChangeLog_FieldPathArrayOfValues: NewResourceChangeLogFieldPathBuilder().Scope().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderScope) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		ResourceChangeLog_FieldPathArrayOfValues: NewResourceChangeLogFieldPathBuilder().Scope().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderScope) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewResourceChangeLogFieldPathBuilder().Scope().FieldPath(),
	})
}

func (b *filterCndBuilderScope) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewResourceChangeLogFieldPathBuilder().Scope().FieldPath(),
	})
}

func (b *filterCndBuilderScope) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                         op,
		ResourceChangeLog_FieldPathValue: NewResourceChangeLogFieldPathBuilder().Scope().WithValue(value),
	})
}

type filterCndBuilderRequestId struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderRequestId) Eq(value uint64) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderRequestId) Neq(value uint64) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderRequestId) Gt(value uint64) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderRequestId) Gte(value uint64) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderRequestId) Lt(value uint64) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderRequestId) Lte(value uint64) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderRequestId) In(values []uint64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		ResourceChangeLog_FieldPathArrayOfValues: NewResourceChangeLogFieldPathBuilder().RequestId().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderRequestId) NotIn(values []uint64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		ResourceChangeLog_FieldPathArrayOfValues: NewResourceChangeLogFieldPathBuilder().RequestId().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderRequestId) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewResourceChangeLogFieldPathBuilder().RequestId().FieldPath(),
	})
}

func (b *filterCndBuilderRequestId) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewResourceChangeLogFieldPathBuilder().RequestId().FieldPath(),
	})
}

func (b *filterCndBuilderRequestId) compare(op gotenfilter.CompareOperator, value uint64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                         op,
		ResourceChangeLog_FieldPathValue: NewResourceChangeLogFieldPathBuilder().RequestId().WithValue(value),
	})
}

type filterCndBuilderTimestamp struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderTimestamp) In(values []*timestamppb.Timestamp) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		ResourceChangeLog_FieldPathArrayOfValues: NewResourceChangeLogFieldPathBuilder().Timestamp().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderTimestamp) NotIn(values []*timestamppb.Timestamp) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		ResourceChangeLog_FieldPathArrayOfValues: NewResourceChangeLogFieldPathBuilder().Timestamp().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderTimestamp) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewResourceChangeLogFieldPathBuilder().Timestamp().FieldPath(),
	})
}

func (b *filterCndBuilderTimestamp) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewResourceChangeLogFieldPathBuilder().Timestamp().FieldPath(),
	})
}

func (b *filterCndBuilderTimestamp) compare(op gotenfilter.CompareOperator, value *timestamppb.Timestamp) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                         op,
		ResourceChangeLog_FieldPathValue: NewResourceChangeLogFieldPathBuilder().Timestamp().WithValue(value),
	})
}

type filterCndBuilderAuthentication struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderAuthentication) In(values []*common.Authentication) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		ResourceChangeLog_FieldPathArrayOfValues: NewResourceChangeLogFieldPathBuilder().Authentication().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderAuthentication) NotIn(values []*common.Authentication) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		ResourceChangeLog_FieldPathArrayOfValues: NewResourceChangeLogFieldPathBuilder().Authentication().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderAuthentication) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewResourceChangeLogFieldPathBuilder().Authentication().FieldPath(),
	})
}

func (b *filterCndBuilderAuthentication) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewResourceChangeLogFieldPathBuilder().Authentication().FieldPath(),
	})
}

func (b *filterCndBuilderAuthentication) compare(op gotenfilter.CompareOperator, value *common.Authentication) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                         op,
		ResourceChangeLog_FieldPathValue: NewResourceChangeLogFieldPathBuilder().Authentication().WithValue(value),
	})
}

func (b *filterCndBuilderAuthentication) Principal() *filterCndBuilderAuthenticationPrincipal {
	return &filterCndBuilderAuthenticationPrincipal{builder: b.builder}
}

func (b *filterCndBuilderAuthentication) PrincipalType() *filterCndBuilderAuthenticationPrincipalType {
	return &filterCndBuilderAuthenticationPrincipalType{builder: b.builder}
}

type filterCndBuilderAuthenticationPrincipal struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderAuthenticationPrincipal) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		ResourceChangeLog_FieldPathArrayOfValues: NewResourceChangeLogFieldPathBuilder().Authentication().Principal().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderAuthenticationPrincipal) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		ResourceChangeLog_FieldPathArrayOfValues: NewResourceChangeLogFieldPathBuilder().Authentication().Principal().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderAuthenticationPrincipal) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewResourceChangeLogFieldPathBuilder().Authentication().Principal().FieldPath(),
	})
}

func (b *filterCndBuilderAuthenticationPrincipal) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewResourceChangeLogFieldPathBuilder().Authentication().Principal().FieldPath(),
	})
}

func (b *filterCndBuilderAuthenticationPrincipal) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                         op,
		ResourceChangeLog_FieldPathValue: NewResourceChangeLogFieldPathBuilder().Authentication().Principal().WithValue(value),
	})
}

type filterCndBuilderAuthenticationPrincipalType struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderAuthenticationPrincipalType) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		ResourceChangeLog_FieldPathArrayOfValues: NewResourceChangeLogFieldPathBuilder().Authentication().PrincipalType().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderAuthenticationPrincipalType) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		ResourceChangeLog_FieldPathArrayOfValues: NewResourceChangeLogFieldPathBuilder().Authentication().PrincipalType().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderAuthenticationPrincipalType) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewResourceChangeLogFieldPathBuilder().Authentication().PrincipalType().FieldPath(),
	})
}

func (b *filterCndBuilderAuthenticationPrincipalType) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewResourceChangeLogFieldPathBuilder().Authentication().PrincipalType().FieldPath(),
	})
}

func (b *filterCndBuilderAuthenticationPrincipalType) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                         op,
		ResourceChangeLog_FieldPathValue: NewResourceChangeLogFieldPathBuilder().Authentication().PrincipalType().WithValue(value),
	})
}

type filterCndBuilderService struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderService) In(values []*common.ServiceData) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		ResourceChangeLog_FieldPathArrayOfValues: NewResourceChangeLogFieldPathBuilder().Service().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderService) NotIn(values []*common.ServiceData) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		ResourceChangeLog_FieldPathArrayOfValues: NewResourceChangeLogFieldPathBuilder().Service().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderService) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewResourceChangeLogFieldPathBuilder().Service().FieldPath(),
	})
}

func (b *filterCndBuilderService) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewResourceChangeLogFieldPathBuilder().Service().FieldPath(),
	})
}

func (b *filterCndBuilderService) compare(op gotenfilter.CompareOperator, value *common.ServiceData) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                         op,
		ResourceChangeLog_FieldPathValue: NewResourceChangeLogFieldPathBuilder().Service().WithValue(value),
	})
}

func (b *filterCndBuilderService) Name() *filterCndBuilderServiceName {
	return &filterCndBuilderServiceName{builder: b.builder}
}

func (b *filterCndBuilderService) RegionId() *filterCndBuilderServiceRegionId {
	return &filterCndBuilderServiceRegionId{builder: b.builder}
}

type filterCndBuilderServiceName struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderServiceName) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		ResourceChangeLog_FieldPathArrayOfValues: NewResourceChangeLogFieldPathBuilder().Service().Name().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderServiceName) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		ResourceChangeLog_FieldPathArrayOfValues: NewResourceChangeLogFieldPathBuilder().Service().Name().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderServiceName) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewResourceChangeLogFieldPathBuilder().Service().Name().FieldPath(),
	})
}

func (b *filterCndBuilderServiceName) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewResourceChangeLogFieldPathBuilder().Service().Name().FieldPath(),
	})
}

func (b *filterCndBuilderServiceName) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                         op,
		ResourceChangeLog_FieldPathValue: NewResourceChangeLogFieldPathBuilder().Service().Name().WithValue(value),
	})
}

type filterCndBuilderServiceRegionId struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderServiceRegionId) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		ResourceChangeLog_FieldPathArrayOfValues: NewResourceChangeLogFieldPathBuilder().Service().RegionId().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderServiceRegionId) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		ResourceChangeLog_FieldPathArrayOfValues: NewResourceChangeLogFieldPathBuilder().Service().RegionId().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderServiceRegionId) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewResourceChangeLogFieldPathBuilder().Service().RegionId().FieldPath(),
	})
}

func (b *filterCndBuilderServiceRegionId) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewResourceChangeLogFieldPathBuilder().Service().RegionId().FieldPath(),
	})
}

func (b *filterCndBuilderServiceRegionId) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                         op,
		ResourceChangeLog_FieldPathValue: NewResourceChangeLogFieldPathBuilder().Service().RegionId().WithValue(value),
	})
}

type filterCndBuilderResource struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderResource) Eq(value *ResourceChangeLog_ResourceChange) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderResource) Neq(value *ResourceChangeLog_ResourceChange) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderResource) Gt(value *ResourceChangeLog_ResourceChange) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderResource) Gte(value *ResourceChangeLog_ResourceChange) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderResource) Lt(value *ResourceChangeLog_ResourceChange) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderResource) Lte(value *ResourceChangeLog_ResourceChange) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderResource) In(values []*ResourceChangeLog_ResourceChange) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		ResourceChangeLog_FieldPathArrayOfValues: NewResourceChangeLogFieldPathBuilder().Resource().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderResource) NotIn(values []*ResourceChangeLog_ResourceChange) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		ResourceChangeLog_FieldPathArrayOfValues: NewResourceChangeLogFieldPathBuilder().Resource().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderResource) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewResourceChangeLogFieldPathBuilder().Resource().FieldPath(),
	})
}

func (b *filterCndBuilderResource) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewResourceChangeLogFieldPathBuilder().Resource().FieldPath(),
	})
}

func (b *filterCndBuilderResource) compare(op gotenfilter.CompareOperator, value *ResourceChangeLog_ResourceChange) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                         op,
		ResourceChangeLog_FieldPathValue: NewResourceChangeLogFieldPathBuilder().Resource().WithValue(value),
	})
}

func (b *filterCndBuilderResource) Name() *filterCndBuilderResourceName {
	return &filterCndBuilderResourceName{builder: b.builder}
}

func (b *filterCndBuilderResource) Type() *filterCndBuilderResourceType {
	return &filterCndBuilderResourceType{builder: b.builder}
}

func (b *filterCndBuilderResource) Action() *filterCndBuilderResourceAction {
	return &filterCndBuilderResourceAction{builder: b.builder}
}

func (b *filterCndBuilderResource) UpdatedFields() *filterCndBuilderResourceUpdatedFields {
	return &filterCndBuilderResourceUpdatedFields{builder: b.builder}
}

func (b *filterCndBuilderResource) Previous() *filterCndBuilderResourcePrevious {
	return &filterCndBuilderResourcePrevious{builder: b.builder}
}

func (b *filterCndBuilderResource) Current() *filterCndBuilderResourceCurrent {
	return &filterCndBuilderResourceCurrent{builder: b.builder}
}

func (b *filterCndBuilderResource) Labels() *filterCndBuilderResourceLabels {
	return &filterCndBuilderResourceLabels{builder: b.builder}
}

func (b *filterCndBuilderResource) Pre() *filterCndBuilderResourcePre {
	return &filterCndBuilderResourcePre{builder: b.builder}
}

func (b *filterCndBuilderResource) Post() *filterCndBuilderResourcePost {
	return &filterCndBuilderResourcePost{builder: b.builder}
}

type filterCndBuilderResourceName struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderResourceName) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		ResourceChangeLog_FieldPathArrayOfValues: NewResourceChangeLogFieldPathBuilder().Resource().Name().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderResourceName) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		ResourceChangeLog_FieldPathArrayOfValues: NewResourceChangeLogFieldPathBuilder().Resource().Name().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderResourceName) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewResourceChangeLogFieldPathBuilder().Resource().Name().FieldPath(),
	})
}

func (b *filterCndBuilderResourceName) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewResourceChangeLogFieldPathBuilder().Resource().Name().FieldPath(),
	})
}

func (b *filterCndBuilderResourceName) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                         op,
		ResourceChangeLog_FieldPathValue: NewResourceChangeLogFieldPathBuilder().Resource().Name().WithValue(value),
	})
}

type filterCndBuilderResourceType struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderResourceType) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		ResourceChangeLog_FieldPathArrayOfValues: NewResourceChangeLogFieldPathBuilder().Resource().Type().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderResourceType) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		ResourceChangeLog_FieldPathArrayOfValues: NewResourceChangeLogFieldPathBuilder().Resource().Type().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderResourceType) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewResourceChangeLogFieldPathBuilder().Resource().Type().FieldPath(),
	})
}

func (b *filterCndBuilderResourceType) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewResourceChangeLogFieldPathBuilder().Resource().Type().FieldPath(),
	})
}

func (b *filterCndBuilderResourceType) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                         op,
		ResourceChangeLog_FieldPathValue: NewResourceChangeLogFieldPathBuilder().Resource().Type().WithValue(value),
	})
}

type filterCndBuilderResourceAction struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderResourceAction) Eq(value ResourceChangeLog_ResourceChange_Action) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderResourceAction) Neq(value ResourceChangeLog_ResourceChange_Action) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderResourceAction) Gt(value ResourceChangeLog_ResourceChange_Action) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderResourceAction) Gte(value ResourceChangeLog_ResourceChange_Action) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderResourceAction) Lt(value ResourceChangeLog_ResourceChange_Action) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderResourceAction) Lte(value ResourceChangeLog_ResourceChange_Action) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderResourceAction) In(values []ResourceChangeLog_ResourceChange_Action) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		ResourceChangeLog_FieldPathArrayOfValues: NewResourceChangeLogFieldPathBuilder().Resource().Action().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderResourceAction) NotIn(values []ResourceChangeLog_ResourceChange_Action) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		ResourceChangeLog_FieldPathArrayOfValues: NewResourceChangeLogFieldPathBuilder().Resource().Action().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderResourceAction) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewResourceChangeLogFieldPathBuilder().Resource().Action().FieldPath(),
	})
}

func (b *filterCndBuilderResourceAction) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewResourceChangeLogFieldPathBuilder().Resource().Action().FieldPath(),
	})
}

func (b *filterCndBuilderResourceAction) compare(op gotenfilter.CompareOperator, value ResourceChangeLog_ResourceChange_Action) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                         op,
		ResourceChangeLog_FieldPathValue: NewResourceChangeLogFieldPathBuilder().Resource().Action().WithValue(value),
	})
}

type filterCndBuilderResourceUpdatedFields struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderResourceUpdatedFields) Eq(value *fieldmaskpb.FieldMask) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderResourceUpdatedFields) Neq(value *fieldmaskpb.FieldMask) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderResourceUpdatedFields) Gt(value *fieldmaskpb.FieldMask) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderResourceUpdatedFields) Gte(value *fieldmaskpb.FieldMask) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderResourceUpdatedFields) Lt(value *fieldmaskpb.FieldMask) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderResourceUpdatedFields) Lte(value *fieldmaskpb.FieldMask) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderResourceUpdatedFields) In(values []*fieldmaskpb.FieldMask) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		ResourceChangeLog_FieldPathArrayOfValues: NewResourceChangeLogFieldPathBuilder().Resource().UpdatedFields().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderResourceUpdatedFields) NotIn(values []*fieldmaskpb.FieldMask) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		ResourceChangeLog_FieldPathArrayOfValues: NewResourceChangeLogFieldPathBuilder().Resource().UpdatedFields().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderResourceUpdatedFields) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewResourceChangeLogFieldPathBuilder().Resource().UpdatedFields().FieldPath(),
	})
}

func (b *filterCndBuilderResourceUpdatedFields) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewResourceChangeLogFieldPathBuilder().Resource().UpdatedFields().FieldPath(),
	})
}

func (b *filterCndBuilderResourceUpdatedFields) compare(op gotenfilter.CompareOperator, value *fieldmaskpb.FieldMask) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                         op,
		ResourceChangeLog_FieldPathValue: NewResourceChangeLogFieldPathBuilder().Resource().UpdatedFields().WithValue(value),
	})
}

type filterCndBuilderResourcePrevious struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderResourcePrevious) Eq(value *anypb.Any) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderResourcePrevious) Neq(value *anypb.Any) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderResourcePrevious) Gt(value *anypb.Any) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderResourcePrevious) Gte(value *anypb.Any) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderResourcePrevious) Lt(value *anypb.Any) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderResourcePrevious) Lte(value *anypb.Any) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderResourcePrevious) In(values []*anypb.Any) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		ResourceChangeLog_FieldPathArrayOfValues: NewResourceChangeLogFieldPathBuilder().Resource().Previous().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderResourcePrevious) NotIn(values []*anypb.Any) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		ResourceChangeLog_FieldPathArrayOfValues: NewResourceChangeLogFieldPathBuilder().Resource().Previous().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderResourcePrevious) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewResourceChangeLogFieldPathBuilder().Resource().Previous().FieldPath(),
	})
}

func (b *filterCndBuilderResourcePrevious) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewResourceChangeLogFieldPathBuilder().Resource().Previous().FieldPath(),
	})
}

func (b *filterCndBuilderResourcePrevious) compare(op gotenfilter.CompareOperator, value *anypb.Any) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                         op,
		ResourceChangeLog_FieldPathValue: NewResourceChangeLogFieldPathBuilder().Resource().Previous().WithValue(value),
	})
}

type filterCndBuilderResourceCurrent struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderResourceCurrent) Eq(value *anypb.Any) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderResourceCurrent) Neq(value *anypb.Any) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderResourceCurrent) Gt(value *anypb.Any) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderResourceCurrent) Gte(value *anypb.Any) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderResourceCurrent) Lt(value *anypb.Any) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderResourceCurrent) Lte(value *anypb.Any) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderResourceCurrent) In(values []*anypb.Any) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		ResourceChangeLog_FieldPathArrayOfValues: NewResourceChangeLogFieldPathBuilder().Resource().Current().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderResourceCurrent) NotIn(values []*anypb.Any) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		ResourceChangeLog_FieldPathArrayOfValues: NewResourceChangeLogFieldPathBuilder().Resource().Current().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderResourceCurrent) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewResourceChangeLogFieldPathBuilder().Resource().Current().FieldPath(),
	})
}

func (b *filterCndBuilderResourceCurrent) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewResourceChangeLogFieldPathBuilder().Resource().Current().FieldPath(),
	})
}

func (b *filterCndBuilderResourceCurrent) compare(op gotenfilter.CompareOperator, value *anypb.Any) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                         op,
		ResourceChangeLog_FieldPathValue: NewResourceChangeLogFieldPathBuilder().Resource().Current().WithValue(value),
	})
}

type filterCndBuilderResourceLabels struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderResourceLabels) In(values []map[string]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		ResourceChangeLog_FieldPathArrayOfValues: NewResourceChangeLogFieldPathBuilder().Resource().Labels().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderResourceLabels) NotIn(values []map[string]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		ResourceChangeLog_FieldPathArrayOfValues: NewResourceChangeLogFieldPathBuilder().Resource().Labels().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderResourceLabels) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewResourceChangeLogFieldPathBuilder().Resource().Labels().FieldPath(),
	})
}

func (b *filterCndBuilderResourceLabels) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewResourceChangeLogFieldPathBuilder().Resource().Labels().FieldPath(),
	})
}

func (b *filterCndBuilderResourceLabels) compare(op gotenfilter.CompareOperator, value map[string]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                         op,
		ResourceChangeLog_FieldPathValue: NewResourceChangeLogFieldPathBuilder().Resource().Labels().WithValue(value),
	})
}

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

type mapFilterCndBuilderResourceLabels struct {
	builder *FilterBuilder
	key     string
}

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

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

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

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

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

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

func (b *mapFilterCndBuilderResourceLabels) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		ResourceChangeLog_FieldPathArrayOfValues: NewResourceChangeLogFieldPathBuilder().Resource().Labels().WithKey(b.key).WithArrayOfValues(values),
	})
}

func (b *mapFilterCndBuilderResourceLabels) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		ResourceChangeLog_FieldPathArrayOfValues: NewResourceChangeLogFieldPathBuilder().Resource().Labels().WithKey(b.key).WithArrayOfValues(values),
	})
}

func (b *mapFilterCndBuilderResourceLabels) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewResourceChangeLogFieldPathBuilder().Resource().Labels().WithKey(b.key).FieldPath(),
	})
}

func (b *mapFilterCndBuilderResourceLabels) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewResourceChangeLogFieldPathBuilder().Resource().Labels().WithKey(b.key).FieldPath(),
	})
}

func (b *mapFilterCndBuilderResourceLabels) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                         op,
		ResourceChangeLog_FieldPathValue: NewResourceChangeLogFieldPathBuilder().Resource().Labels().WithKey(b.key).WithValue(value),
	})
}

type filterCndBuilderResourcePre struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderResourcePre) In(values []*common.ObjectState) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		ResourceChangeLog_FieldPathArrayOfValues: NewResourceChangeLogFieldPathBuilder().Resource().Pre().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderResourcePre) NotIn(values []*common.ObjectState) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		ResourceChangeLog_FieldPathArrayOfValues: NewResourceChangeLogFieldPathBuilder().Resource().Pre().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderResourcePre) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewResourceChangeLogFieldPathBuilder().Resource().Pre().FieldPath(),
	})
}

func (b *filterCndBuilderResourcePre) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewResourceChangeLogFieldPathBuilder().Resource().Pre().FieldPath(),
	})
}

func (b *filterCndBuilderResourcePre) compare(op gotenfilter.CompareOperator, value *common.ObjectState) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                         op,
		ResourceChangeLog_FieldPathValue: NewResourceChangeLogFieldPathBuilder().Resource().Pre().WithValue(value),
	})
}

func (b *filterCndBuilderResourcePre) Data() *filterCndBuilderResourcePreData {
	return &filterCndBuilderResourcePreData{builder: b.builder}
}

func (b *filterCndBuilderResourcePre) Labels() *filterCndBuilderResourcePreLabels {
	return &filterCndBuilderResourcePreLabels{builder: b.builder}
}

type filterCndBuilderResourcePreData struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderResourcePreData) Eq(value *anypb.Any) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderResourcePreData) Neq(value *anypb.Any) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderResourcePreData) Gt(value *anypb.Any) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderResourcePreData) Gte(value *anypb.Any) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderResourcePreData) Lt(value *anypb.Any) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderResourcePreData) Lte(value *anypb.Any) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderResourcePreData) In(values []*anypb.Any) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		ResourceChangeLog_FieldPathArrayOfValues: NewResourceChangeLogFieldPathBuilder().Resource().Pre().Data().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderResourcePreData) NotIn(values []*anypb.Any) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		ResourceChangeLog_FieldPathArrayOfValues: NewResourceChangeLogFieldPathBuilder().Resource().Pre().Data().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderResourcePreData) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewResourceChangeLogFieldPathBuilder().Resource().Pre().Data().FieldPath(),
	})
}

func (b *filterCndBuilderResourcePreData) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewResourceChangeLogFieldPathBuilder().Resource().Pre().Data().FieldPath(),
	})
}

func (b *filterCndBuilderResourcePreData) compare(op gotenfilter.CompareOperator, value *anypb.Any) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                         op,
		ResourceChangeLog_FieldPathValue: NewResourceChangeLogFieldPathBuilder().Resource().Pre().Data().WithValue(value),
	})
}

type filterCndBuilderResourcePreLabels struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderResourcePreLabels) In(values []map[string]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		ResourceChangeLog_FieldPathArrayOfValues: NewResourceChangeLogFieldPathBuilder().Resource().Pre().Labels().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderResourcePreLabels) NotIn(values []map[string]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		ResourceChangeLog_FieldPathArrayOfValues: NewResourceChangeLogFieldPathBuilder().Resource().Pre().Labels().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderResourcePreLabels) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewResourceChangeLogFieldPathBuilder().Resource().Pre().Labels().FieldPath(),
	})
}

func (b *filterCndBuilderResourcePreLabels) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewResourceChangeLogFieldPathBuilder().Resource().Pre().Labels().FieldPath(),
	})
}

func (b *filterCndBuilderResourcePreLabels) compare(op gotenfilter.CompareOperator, value map[string]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                         op,
		ResourceChangeLog_FieldPathValue: NewResourceChangeLogFieldPathBuilder().Resource().Pre().Labels().WithValue(value),
	})
}

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

type mapFilterCndBuilderResourcePreLabels struct {
	builder *FilterBuilder
	key     string
}

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

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

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

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

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

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

func (b *mapFilterCndBuilderResourcePreLabels) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		ResourceChangeLog_FieldPathArrayOfValues: NewResourceChangeLogFieldPathBuilder().Resource().Pre().Labels().WithKey(b.key).WithArrayOfValues(values),
	})
}

func (b *mapFilterCndBuilderResourcePreLabels) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		ResourceChangeLog_FieldPathArrayOfValues: NewResourceChangeLogFieldPathBuilder().Resource().Pre().Labels().WithKey(b.key).WithArrayOfValues(values),
	})
}

func (b *mapFilterCndBuilderResourcePreLabels) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewResourceChangeLogFieldPathBuilder().Resource().Pre().Labels().WithKey(b.key).FieldPath(),
	})
}

func (b *mapFilterCndBuilderResourcePreLabels) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewResourceChangeLogFieldPathBuilder().Resource().Pre().Labels().WithKey(b.key).FieldPath(),
	})
}

func (b *mapFilterCndBuilderResourcePreLabels) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                         op,
		ResourceChangeLog_FieldPathValue: NewResourceChangeLogFieldPathBuilder().Resource().Pre().Labels().WithKey(b.key).WithValue(value),
	})
}

type filterCndBuilderResourcePost struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderResourcePost) In(values []*common.ObjectState) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		ResourceChangeLog_FieldPathArrayOfValues: NewResourceChangeLogFieldPathBuilder().Resource().Post().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderResourcePost) NotIn(values []*common.ObjectState) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		ResourceChangeLog_FieldPathArrayOfValues: NewResourceChangeLogFieldPathBuilder().Resource().Post().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderResourcePost) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewResourceChangeLogFieldPathBuilder().Resource().Post().FieldPath(),
	})
}

func (b *filterCndBuilderResourcePost) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewResourceChangeLogFieldPathBuilder().Resource().Post().FieldPath(),
	})
}

func (b *filterCndBuilderResourcePost) compare(op gotenfilter.CompareOperator, value *common.ObjectState) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                         op,
		ResourceChangeLog_FieldPathValue: NewResourceChangeLogFieldPathBuilder().Resource().Post().WithValue(value),
	})
}

func (b *filterCndBuilderResourcePost) Data() *filterCndBuilderResourcePostData {
	return &filterCndBuilderResourcePostData{builder: b.builder}
}

func (b *filterCndBuilderResourcePost) Labels() *filterCndBuilderResourcePostLabels {
	return &filterCndBuilderResourcePostLabels{builder: b.builder}
}

type filterCndBuilderResourcePostData struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderResourcePostData) Eq(value *anypb.Any) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderResourcePostData) Neq(value *anypb.Any) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderResourcePostData) Gt(value *anypb.Any) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderResourcePostData) Gte(value *anypb.Any) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderResourcePostData) Lt(value *anypb.Any) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderResourcePostData) Lte(value *anypb.Any) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderResourcePostData) In(values []*anypb.Any) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		ResourceChangeLog_FieldPathArrayOfValues: NewResourceChangeLogFieldPathBuilder().Resource().Post().Data().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderResourcePostData) NotIn(values []*anypb.Any) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		ResourceChangeLog_FieldPathArrayOfValues: NewResourceChangeLogFieldPathBuilder().Resource().Post().Data().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderResourcePostData) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewResourceChangeLogFieldPathBuilder().Resource().Post().Data().FieldPath(),
	})
}

func (b *filterCndBuilderResourcePostData) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewResourceChangeLogFieldPathBuilder().Resource().Post().Data().FieldPath(),
	})
}

func (b *filterCndBuilderResourcePostData) compare(op gotenfilter.CompareOperator, value *anypb.Any) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                         op,
		ResourceChangeLog_FieldPathValue: NewResourceChangeLogFieldPathBuilder().Resource().Post().Data().WithValue(value),
	})
}

type filterCndBuilderResourcePostLabels struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderResourcePostLabels) In(values []map[string]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		ResourceChangeLog_FieldPathArrayOfValues: NewResourceChangeLogFieldPathBuilder().Resource().Post().Labels().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderResourcePostLabels) NotIn(values []map[string]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		ResourceChangeLog_FieldPathArrayOfValues: NewResourceChangeLogFieldPathBuilder().Resource().Post().Labels().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderResourcePostLabels) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewResourceChangeLogFieldPathBuilder().Resource().Post().Labels().FieldPath(),
	})
}

func (b *filterCndBuilderResourcePostLabels) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewResourceChangeLogFieldPathBuilder().Resource().Post().Labels().FieldPath(),
	})
}

func (b *filterCndBuilderResourcePostLabels) compare(op gotenfilter.CompareOperator, value map[string]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                         op,
		ResourceChangeLog_FieldPathValue: NewResourceChangeLogFieldPathBuilder().Resource().Post().Labels().WithValue(value),
	})
}

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

type mapFilterCndBuilderResourcePostLabels struct {
	builder *FilterBuilder
	key     string
}

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

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

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

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

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

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

func (b *mapFilterCndBuilderResourcePostLabels) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		ResourceChangeLog_FieldPathArrayOfValues: NewResourceChangeLogFieldPathBuilder().Resource().Post().Labels().WithKey(b.key).WithArrayOfValues(values),
	})
}

func (b *mapFilterCndBuilderResourcePostLabels) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		ResourceChangeLog_FieldPathArrayOfValues: NewResourceChangeLogFieldPathBuilder().Resource().Post().Labels().WithKey(b.key).WithArrayOfValues(values),
	})
}

func (b *mapFilterCndBuilderResourcePostLabels) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewResourceChangeLogFieldPathBuilder().Resource().Post().Labels().WithKey(b.key).FieldPath(),
	})
}

func (b *mapFilterCndBuilderResourcePostLabels) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewResourceChangeLogFieldPathBuilder().Resource().Post().Labels().WithKey(b.key).FieldPath(),
	})
}

func (b *mapFilterCndBuilderResourcePostLabels) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                         op,
		ResourceChangeLog_FieldPathValue: NewResourceChangeLogFieldPathBuilder().Resource().Post().Labels().WithKey(b.key).WithValue(value),
	})
}

type filterCndBuilderTransaction struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderTransaction) Eq(value *ResourceChangeLog_TransactionInfo) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderTransaction) Neq(value *ResourceChangeLog_TransactionInfo) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderTransaction) Gt(value *ResourceChangeLog_TransactionInfo) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderTransaction) Gte(value *ResourceChangeLog_TransactionInfo) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderTransaction) Lt(value *ResourceChangeLog_TransactionInfo) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderTransaction) Lte(value *ResourceChangeLog_TransactionInfo) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderTransaction) In(values []*ResourceChangeLog_TransactionInfo) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		ResourceChangeLog_FieldPathArrayOfValues: NewResourceChangeLogFieldPathBuilder().Transaction().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderTransaction) NotIn(values []*ResourceChangeLog_TransactionInfo) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		ResourceChangeLog_FieldPathArrayOfValues: NewResourceChangeLogFieldPathBuilder().Transaction().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderTransaction) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewResourceChangeLogFieldPathBuilder().Transaction().FieldPath(),
	})
}

func (b *filterCndBuilderTransaction) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewResourceChangeLogFieldPathBuilder().Transaction().FieldPath(),
	})
}

func (b *filterCndBuilderTransaction) compare(op gotenfilter.CompareOperator, value *ResourceChangeLog_TransactionInfo) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                         op,
		ResourceChangeLog_FieldPathValue: NewResourceChangeLogFieldPathBuilder().Transaction().WithValue(value),
	})
}

func (b *filterCndBuilderTransaction) Identifier() *filterCndBuilderTransactionIdentifier {
	return &filterCndBuilderTransactionIdentifier{builder: b.builder}
}

func (b *filterCndBuilderTransaction) TryCounter() *filterCndBuilderTransactionTryCounter {
	return &filterCndBuilderTransactionTryCounter{builder: b.builder}
}

func (b *filterCndBuilderTransaction) State() *filterCndBuilderTransactionState {
	return &filterCndBuilderTransactionState{builder: b.builder}
}

type filterCndBuilderTransactionIdentifier struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderTransactionIdentifier) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		ResourceChangeLog_FieldPathArrayOfValues: NewResourceChangeLogFieldPathBuilder().Transaction().Identifier().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderTransactionIdentifier) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		ResourceChangeLog_FieldPathArrayOfValues: NewResourceChangeLogFieldPathBuilder().Transaction().Identifier().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderTransactionIdentifier) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewResourceChangeLogFieldPathBuilder().Transaction().Identifier().FieldPath(),
	})
}

func (b *filterCndBuilderTransactionIdentifier) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewResourceChangeLogFieldPathBuilder().Transaction().Identifier().FieldPath(),
	})
}

func (b *filterCndBuilderTransactionIdentifier) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                         op,
		ResourceChangeLog_FieldPathValue: NewResourceChangeLogFieldPathBuilder().Transaction().Identifier().WithValue(value),
	})
}

type filterCndBuilderTransactionTryCounter struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderTransactionTryCounter) In(values []int32) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		ResourceChangeLog_FieldPathArrayOfValues: NewResourceChangeLogFieldPathBuilder().Transaction().TryCounter().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderTransactionTryCounter) NotIn(values []int32) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		ResourceChangeLog_FieldPathArrayOfValues: NewResourceChangeLogFieldPathBuilder().Transaction().TryCounter().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderTransactionTryCounter) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewResourceChangeLogFieldPathBuilder().Transaction().TryCounter().FieldPath(),
	})
}

func (b *filterCndBuilderTransactionTryCounter) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewResourceChangeLogFieldPathBuilder().Transaction().TryCounter().FieldPath(),
	})
}

func (b *filterCndBuilderTransactionTryCounter) compare(op gotenfilter.CompareOperator, value int32) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                         op,
		ResourceChangeLog_FieldPathValue: NewResourceChangeLogFieldPathBuilder().Transaction().TryCounter().WithValue(value),
	})
}

type filterCndBuilderTransactionState struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderTransactionState) Eq(value ResourceChangeLog_TransactionInfo_State) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderTransactionState) Neq(value ResourceChangeLog_TransactionInfo_State) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderTransactionState) Gt(value ResourceChangeLog_TransactionInfo_State) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderTransactionState) Gte(value ResourceChangeLog_TransactionInfo_State) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderTransactionState) Lt(value ResourceChangeLog_TransactionInfo_State) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderTransactionState) Lte(value ResourceChangeLog_TransactionInfo_State) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderTransactionState) In(values []ResourceChangeLog_TransactionInfo_State) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		ResourceChangeLog_FieldPathArrayOfValues: NewResourceChangeLogFieldPathBuilder().Transaction().State().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderTransactionState) NotIn(values []ResourceChangeLog_TransactionInfo_State) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		ResourceChangeLog_FieldPathArrayOfValues: NewResourceChangeLogFieldPathBuilder().Transaction().State().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderTransactionState) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewResourceChangeLogFieldPathBuilder().Transaction().State().FieldPath(),
	})
}

func (b *filterCndBuilderTransactionState) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewResourceChangeLogFieldPathBuilder().Transaction().State().FieldPath(),
	})
}

func (b *filterCndBuilderTransactionState) compare(op gotenfilter.CompareOperator, value ResourceChangeLog_TransactionInfo_State) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                         op,
		ResourceChangeLog_FieldPathValue: NewResourceChangeLogFieldPathBuilder().Transaction().State().WithValue(value),
	})
}