activity_log.pb.filterbuilder.go

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

package activity_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/v1alpha2/common"
	rpc "github.com/cloudwan/edgelq-sdk/common/rpc"
	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"
	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"
	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{}
	_ = &rpc.Status{}
	_ = &iam_iam_common.PCR{}
	_ = &iam_organization.Organization{}
	_ = &iam_project.Project{}
	_ = &meta_service.Service{}
	_ = &anypb.Any{}
	_ = &fieldmaskpb.FieldMask{}
	_ = &timestamppb.Timestamp{}
	_ = &meta.Meta{}
	_ = &multi_region_policy.MultiRegionPolicy{}
)

type FilterBuilderOrCondition interface {
	_IsActivityLogFilterBuilderOrCondition()
}

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

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

func (b *filterCndBuilderAnyPath) NotIn(values interface{}) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		ActivityLog_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([]ActivityLog_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([]ActivityLog_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,
		ActivityLog_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) Authentication() *filterCndBuilderAuthentication {
	return &filterCndBuilderAuthentication{builder: b.builder}
}

func (b *filterCndBuilder) Authorization() *filterCndBuilderAuthorization {
	return &filterCndBuilderAuthorization{builder: b.builder}
}

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

func (b *filterCndBuilder) Method() *filterCndBuilderMethod {
	return &filterCndBuilderMethod{builder: b.builder}
}

func (b *filterCndBuilder) RequestMetadata() *filterCndBuilderRequestMetadata {
	return &filterCndBuilderRequestMetadata{builder: b.builder}
}

func (b *filterCndBuilder) RequestRouting() *filterCndBuilderRequestRouting {
	return &filterCndBuilderRequestRouting{builder: b.builder}
}

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

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

func (b *filterCndBuilder) Labels() *filterCndBuilderLabels {
	return &filterCndBuilderLabels{builder: b.builder}
}

func (b *filterCndBuilder) Events() *filterCndBuilderEvents {
	return &filterCndBuilderEvents{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{
		ActivityLog_FieldPathArrayOfValues: NewActivityLogFieldPathBuilder().Name().WithArrayOfValues(values),
	})
}

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

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

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

func (b *filterCndBuilderName) compare(op gotenfilter.CompareOperator, value *Name) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                   op,
		ActivityLog_FieldPathValue: NewActivityLogFieldPathBuilder().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{
		ActivityLog_FieldPathArrayOfValues: NewActivityLogFieldPathBuilder().Scope().WithArrayOfValues(values),
	})
}

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

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

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

func (b *filterCndBuilderScope) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                   op,
		ActivityLog_FieldPathValue: NewActivityLogFieldPathBuilder().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{
		ActivityLog_FieldPathArrayOfValues: NewActivityLogFieldPathBuilder().RequestId().WithArrayOfValues(values),
	})
}

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

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

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

func (b *filterCndBuilderRequestId) compare(op gotenfilter.CompareOperator, value uint64) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                   op,
		ActivityLog_FieldPathValue: NewActivityLogFieldPathBuilder().RequestId().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{
		ActivityLog_FieldPathArrayOfValues: NewActivityLogFieldPathBuilder().Authentication().WithArrayOfValues(values),
	})
}

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

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

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

func (b *filterCndBuilderAuthentication) compare(op gotenfilter.CompareOperator, value *common.Authentication) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                   op,
		ActivityLog_FieldPathValue: NewActivityLogFieldPathBuilder().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{
		ActivityLog_FieldPathArrayOfValues: NewActivityLogFieldPathBuilder().Authentication().Principal().WithArrayOfValues(values),
	})
}

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

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

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

func (b *filterCndBuilderAuthenticationPrincipal) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                   op,
		ActivityLog_FieldPathValue: NewActivityLogFieldPathBuilder().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{
		ActivityLog_FieldPathArrayOfValues: NewActivityLogFieldPathBuilder().Authentication().PrincipalType().WithArrayOfValues(values),
	})
}

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

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

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

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

type filterCndBuilderAuthorization struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderAuthorization) In(values []*common.Authorization) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		ActivityLog_FieldPathArrayOfValues: NewActivityLogFieldPathBuilder().Authorization().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderAuthorization) NotIn(values []*common.Authorization) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		ActivityLog_FieldPathArrayOfValues: NewActivityLogFieldPathBuilder().Authorization().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderAuthorization) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewActivityLogFieldPathBuilder().Authorization().FieldPath(),
	})
}

func (b *filterCndBuilderAuthorization) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewActivityLogFieldPathBuilder().Authorization().FieldPath(),
	})
}

func (b *filterCndBuilderAuthorization) compare(op gotenfilter.CompareOperator, value *common.Authorization) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                   op,
		ActivityLog_FieldPathValue: NewActivityLogFieldPathBuilder().Authorization().WithValue(value),
	})
}

func (b *filterCndBuilderAuthorization) GrantedPermissions() *filterCndBuilderAuthorizationGrantedPermissions {
	return &filterCndBuilderAuthorizationGrantedPermissions{builder: b.builder}
}

func (b *filterCndBuilderAuthorization) DeniedPermissions() *filterCndBuilderAuthorizationDeniedPermissions {
	return &filterCndBuilderAuthorizationDeniedPermissions{builder: b.builder}
}

type filterCndBuilderAuthorizationGrantedPermissions struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderAuthorizationGrantedPermissions) In(values [][]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		ActivityLog_FieldPathArrayOfValues: NewActivityLogFieldPathBuilder().Authorization().GrantedPermissions().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderAuthorizationGrantedPermissions) NotIn(values [][]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		ActivityLog_FieldPathArrayOfValues: NewActivityLogFieldPathBuilder().Authorization().GrantedPermissions().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderAuthorizationGrantedPermissions) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewActivityLogFieldPathBuilder().Authorization().GrantedPermissions().FieldPath(),
	})
}

func (b *filterCndBuilderAuthorizationGrantedPermissions) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewActivityLogFieldPathBuilder().Authorization().GrantedPermissions().FieldPath(),
	})
}

func (b *filterCndBuilderAuthorizationGrantedPermissions) Contains(value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewActivityLogFieldPathBuilder().Authorization().GrantedPermissions().FieldPath(),
		Value:     NewActivityLogFieldPathBuilder().Authorization().GrantedPermissions().WithItemValue(value),
	})
}

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

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

func (b *filterCndBuilderAuthorizationGrantedPermissions) compare(op gotenfilter.CompareOperator, value []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                   op,
		ActivityLog_FieldPathValue: NewActivityLogFieldPathBuilder().Authorization().GrantedPermissions().WithValue(value),
	})
}

type filterCndBuilderAuthorizationDeniedPermissions struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderAuthorizationDeniedPermissions) In(values [][]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		ActivityLog_FieldPathArrayOfValues: NewActivityLogFieldPathBuilder().Authorization().DeniedPermissions().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderAuthorizationDeniedPermissions) NotIn(values [][]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		ActivityLog_FieldPathArrayOfValues: NewActivityLogFieldPathBuilder().Authorization().DeniedPermissions().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderAuthorizationDeniedPermissions) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewActivityLogFieldPathBuilder().Authorization().DeniedPermissions().FieldPath(),
	})
}

func (b *filterCndBuilderAuthorizationDeniedPermissions) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewActivityLogFieldPathBuilder().Authorization().DeniedPermissions().FieldPath(),
	})
}

func (b *filterCndBuilderAuthorizationDeniedPermissions) Contains(value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewActivityLogFieldPathBuilder().Authorization().DeniedPermissions().FieldPath(),
		Value:     NewActivityLogFieldPathBuilder().Authorization().DeniedPermissions().WithItemValue(value),
	})
}

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

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

func (b *filterCndBuilderAuthorizationDeniedPermissions) compare(op gotenfilter.CompareOperator, value []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                   op,
		ActivityLog_FieldPathValue: NewActivityLogFieldPathBuilder().Authorization().DeniedPermissions().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{
		ActivityLog_FieldPathArrayOfValues: NewActivityLogFieldPathBuilder().Service().WithArrayOfValues(values),
	})
}

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

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

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

func (b *filterCndBuilderService) compare(op gotenfilter.CompareOperator, value *common.ServiceData) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                   op,
		ActivityLog_FieldPathValue: NewActivityLogFieldPathBuilder().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{
		ActivityLog_FieldPathArrayOfValues: NewActivityLogFieldPathBuilder().Service().Name().WithArrayOfValues(values),
	})
}

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

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

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

func (b *filterCndBuilderServiceName) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                   op,
		ActivityLog_FieldPathValue: NewActivityLogFieldPathBuilder().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{
		ActivityLog_FieldPathArrayOfValues: NewActivityLogFieldPathBuilder().Service().RegionId().WithArrayOfValues(values),
	})
}

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

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

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

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

type filterCndBuilderMethod struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderMethod) Eq(value *ActivityLog_Method) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderMethod) Neq(value *ActivityLog_Method) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderMethod) Gt(value *ActivityLog_Method) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderMethod) Gte(value *ActivityLog_Method) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderMethod) Lt(value *ActivityLog_Method) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderMethod) Lte(value *ActivityLog_Method) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderMethod) In(values []*ActivityLog_Method) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		ActivityLog_FieldPathArrayOfValues: NewActivityLogFieldPathBuilder().Method().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderMethod) NotIn(values []*ActivityLog_Method) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		ActivityLog_FieldPathArrayOfValues: NewActivityLogFieldPathBuilder().Method().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderMethod) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewActivityLogFieldPathBuilder().Method().FieldPath(),
	})
}

func (b *filterCndBuilderMethod) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewActivityLogFieldPathBuilder().Method().FieldPath(),
	})
}

func (b *filterCndBuilderMethod) compare(op gotenfilter.CompareOperator, value *ActivityLog_Method) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                   op,
		ActivityLog_FieldPathValue: NewActivityLogFieldPathBuilder().Method().WithValue(value),
	})
}

func (b *filterCndBuilderMethod) Type() *filterCndBuilderMethodType {
	return &filterCndBuilderMethodType{builder: b.builder}
}

func (b *filterCndBuilderMethod) Version() *filterCndBuilderMethodVersion {
	return &filterCndBuilderMethodVersion{builder: b.builder}
}

type filterCndBuilderMethodType struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderMethodType) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		ActivityLog_FieldPathArrayOfValues: NewActivityLogFieldPathBuilder().Method().Type().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderMethodType) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		ActivityLog_FieldPathArrayOfValues: NewActivityLogFieldPathBuilder().Method().Type().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderMethodType) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewActivityLogFieldPathBuilder().Method().Type().FieldPath(),
	})
}

func (b *filterCndBuilderMethodType) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewActivityLogFieldPathBuilder().Method().Type().FieldPath(),
	})
}

func (b *filterCndBuilderMethodType) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                   op,
		ActivityLog_FieldPathValue: NewActivityLogFieldPathBuilder().Method().Type().WithValue(value),
	})
}

type filterCndBuilderMethodVersion struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderMethodVersion) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		ActivityLog_FieldPathArrayOfValues: NewActivityLogFieldPathBuilder().Method().Version().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderMethodVersion) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		ActivityLog_FieldPathArrayOfValues: NewActivityLogFieldPathBuilder().Method().Version().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderMethodVersion) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewActivityLogFieldPathBuilder().Method().Version().FieldPath(),
	})
}

func (b *filterCndBuilderMethodVersion) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewActivityLogFieldPathBuilder().Method().Version().FieldPath(),
	})
}

func (b *filterCndBuilderMethodVersion) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                   op,
		ActivityLog_FieldPathValue: NewActivityLogFieldPathBuilder().Method().Version().WithValue(value),
	})
}

type filterCndBuilderRequestMetadata struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderRequestMetadata) Eq(value *ActivityLog_RequestMetadata) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderRequestMetadata) Neq(value *ActivityLog_RequestMetadata) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderRequestMetadata) Gt(value *ActivityLog_RequestMetadata) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderRequestMetadata) Gte(value *ActivityLog_RequestMetadata) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderRequestMetadata) Lt(value *ActivityLog_RequestMetadata) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderRequestMetadata) Lte(value *ActivityLog_RequestMetadata) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderRequestMetadata) In(values []*ActivityLog_RequestMetadata) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		ActivityLog_FieldPathArrayOfValues: NewActivityLogFieldPathBuilder().RequestMetadata().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderRequestMetadata) NotIn(values []*ActivityLog_RequestMetadata) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		ActivityLog_FieldPathArrayOfValues: NewActivityLogFieldPathBuilder().RequestMetadata().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderRequestMetadata) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewActivityLogFieldPathBuilder().RequestMetadata().FieldPath(),
	})
}

func (b *filterCndBuilderRequestMetadata) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewActivityLogFieldPathBuilder().RequestMetadata().FieldPath(),
	})
}

func (b *filterCndBuilderRequestMetadata) compare(op gotenfilter.CompareOperator, value *ActivityLog_RequestMetadata) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                   op,
		ActivityLog_FieldPathValue: NewActivityLogFieldPathBuilder().RequestMetadata().WithValue(value),
	})
}

func (b *filterCndBuilderRequestMetadata) IpAddress() *filterCndBuilderRequestMetadataIpAddress {
	return &filterCndBuilderRequestMetadataIpAddress{builder: b.builder}
}

func (b *filterCndBuilderRequestMetadata) UserAgent() *filterCndBuilderRequestMetadataUserAgent {
	return &filterCndBuilderRequestMetadataUserAgent{builder: b.builder}
}

type filterCndBuilderRequestMetadataIpAddress struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderRequestMetadataIpAddress) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		ActivityLog_FieldPathArrayOfValues: NewActivityLogFieldPathBuilder().RequestMetadata().IpAddress().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderRequestMetadataIpAddress) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		ActivityLog_FieldPathArrayOfValues: NewActivityLogFieldPathBuilder().RequestMetadata().IpAddress().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderRequestMetadataIpAddress) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewActivityLogFieldPathBuilder().RequestMetadata().IpAddress().FieldPath(),
	})
}

func (b *filterCndBuilderRequestMetadataIpAddress) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewActivityLogFieldPathBuilder().RequestMetadata().IpAddress().FieldPath(),
	})
}

func (b *filterCndBuilderRequestMetadataIpAddress) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                   op,
		ActivityLog_FieldPathValue: NewActivityLogFieldPathBuilder().RequestMetadata().IpAddress().WithValue(value),
	})
}

type filterCndBuilderRequestMetadataUserAgent struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderRequestMetadataUserAgent) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		ActivityLog_FieldPathArrayOfValues: NewActivityLogFieldPathBuilder().RequestMetadata().UserAgent().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderRequestMetadataUserAgent) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		ActivityLog_FieldPathArrayOfValues: NewActivityLogFieldPathBuilder().RequestMetadata().UserAgent().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderRequestMetadataUserAgent) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewActivityLogFieldPathBuilder().RequestMetadata().UserAgent().FieldPath(),
	})
}

func (b *filterCndBuilderRequestMetadataUserAgent) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewActivityLogFieldPathBuilder().RequestMetadata().UserAgent().FieldPath(),
	})
}

func (b *filterCndBuilderRequestMetadataUserAgent) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                   op,
		ActivityLog_FieldPathValue: NewActivityLogFieldPathBuilder().RequestMetadata().UserAgent().WithValue(value),
	})
}

type filterCndBuilderRequestRouting struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderRequestRouting) Eq(value *ActivityLog_RequestRouting) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderRequestRouting) Neq(value *ActivityLog_RequestRouting) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderRequestRouting) Gt(value *ActivityLog_RequestRouting) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderRequestRouting) Gte(value *ActivityLog_RequestRouting) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderRequestRouting) Lt(value *ActivityLog_RequestRouting) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderRequestRouting) Lte(value *ActivityLog_RequestRouting) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderRequestRouting) In(values []*ActivityLog_RequestRouting) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		ActivityLog_FieldPathArrayOfValues: NewActivityLogFieldPathBuilder().RequestRouting().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderRequestRouting) NotIn(values []*ActivityLog_RequestRouting) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		ActivityLog_FieldPathArrayOfValues: NewActivityLogFieldPathBuilder().RequestRouting().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderRequestRouting) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewActivityLogFieldPathBuilder().RequestRouting().FieldPath(),
	})
}

func (b *filterCndBuilderRequestRouting) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewActivityLogFieldPathBuilder().RequestRouting().FieldPath(),
	})
}

func (b *filterCndBuilderRequestRouting) compare(op gotenfilter.CompareOperator, value *ActivityLog_RequestRouting) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                   op,
		ActivityLog_FieldPathValue: NewActivityLogFieldPathBuilder().RequestRouting().WithValue(value),
	})
}

func (b *filterCndBuilderRequestRouting) ViaRegion() *filterCndBuilderRequestRoutingViaRegion {
	return &filterCndBuilderRequestRoutingViaRegion{builder: b.builder}
}

func (b *filterCndBuilderRequestRouting) DestRegions() *filterCndBuilderRequestRoutingDestRegions {
	return &filterCndBuilderRequestRoutingDestRegions{builder: b.builder}
}

type filterCndBuilderRequestRoutingViaRegion struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderRequestRoutingViaRegion) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		ActivityLog_FieldPathArrayOfValues: NewActivityLogFieldPathBuilder().RequestRouting().ViaRegion().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderRequestRoutingViaRegion) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		ActivityLog_FieldPathArrayOfValues: NewActivityLogFieldPathBuilder().RequestRouting().ViaRegion().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderRequestRoutingViaRegion) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewActivityLogFieldPathBuilder().RequestRouting().ViaRegion().FieldPath(),
	})
}

func (b *filterCndBuilderRequestRoutingViaRegion) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewActivityLogFieldPathBuilder().RequestRouting().ViaRegion().FieldPath(),
	})
}

func (b *filterCndBuilderRequestRoutingViaRegion) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                   op,
		ActivityLog_FieldPathValue: NewActivityLogFieldPathBuilder().RequestRouting().ViaRegion().WithValue(value),
	})
}

type filterCndBuilderRequestRoutingDestRegions struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderRequestRoutingDestRegions) In(values [][]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		ActivityLog_FieldPathArrayOfValues: NewActivityLogFieldPathBuilder().RequestRouting().DestRegions().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderRequestRoutingDestRegions) NotIn(values [][]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		ActivityLog_FieldPathArrayOfValues: NewActivityLogFieldPathBuilder().RequestRouting().DestRegions().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderRequestRoutingDestRegions) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewActivityLogFieldPathBuilder().RequestRouting().DestRegions().FieldPath(),
	})
}

func (b *filterCndBuilderRequestRoutingDestRegions) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewActivityLogFieldPathBuilder().RequestRouting().DestRegions().FieldPath(),
	})
}

func (b *filterCndBuilderRequestRoutingDestRegions) Contains(value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewActivityLogFieldPathBuilder().RequestRouting().DestRegions().FieldPath(),
		Value:     NewActivityLogFieldPathBuilder().RequestRouting().DestRegions().WithItemValue(value),
	})
}

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

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

func (b *filterCndBuilderRequestRoutingDestRegions) compare(op gotenfilter.CompareOperator, value []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                   op,
		ActivityLog_FieldPathValue: NewActivityLogFieldPathBuilder().RequestRouting().DestRegions().WithValue(value),
	})
}

type filterCndBuilderResource struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderResource) In(values []*ActivityLog_Resource) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		ActivityLog_FieldPathArrayOfValues: NewActivityLogFieldPathBuilder().Resource().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderResource) NotIn(values []*ActivityLog_Resource) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		ActivityLog_FieldPathArrayOfValues: NewActivityLogFieldPathBuilder().Resource().WithArrayOfValues(values),
	})
}

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

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

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

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

func (b *filterCndBuilderResource) Difference() *filterCndBuilderResourceDifference {
	return &filterCndBuilderResourceDifference{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{
		ActivityLog_FieldPathArrayOfValues: NewActivityLogFieldPathBuilder().Resource().Name().WithArrayOfValues(values),
	})
}

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

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

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

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

type filterCndBuilderResourceDifference struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderResourceDifference) Eq(value *ActivityLog_Resource_Difference) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderResourceDifference) Neq(value *ActivityLog_Resource_Difference) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderResourceDifference) Gt(value *ActivityLog_Resource_Difference) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderResourceDifference) Gte(value *ActivityLog_Resource_Difference) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderResourceDifference) Lt(value *ActivityLog_Resource_Difference) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderResourceDifference) Lte(value *ActivityLog_Resource_Difference) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderResourceDifference) In(values []*ActivityLog_Resource_Difference) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		ActivityLog_FieldPathArrayOfValues: NewActivityLogFieldPathBuilder().Resource().Difference().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderResourceDifference) NotIn(values []*ActivityLog_Resource_Difference) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		ActivityLog_FieldPathArrayOfValues: NewActivityLogFieldPathBuilder().Resource().Difference().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderResourceDifference) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewActivityLogFieldPathBuilder().Resource().Difference().FieldPath(),
	})
}

func (b *filterCndBuilderResourceDifference) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewActivityLogFieldPathBuilder().Resource().Difference().FieldPath(),
	})
}

func (b *filterCndBuilderResourceDifference) compare(op gotenfilter.CompareOperator, value *ActivityLog_Resource_Difference) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                   op,
		ActivityLog_FieldPathValue: NewActivityLogFieldPathBuilder().Resource().Difference().WithValue(value),
	})
}

func (b *filterCndBuilderResourceDifference) Fields() *filterCndBuilderResourceDifferenceFields {
	return &filterCndBuilderResourceDifferenceFields{builder: b.builder}
}

func (b *filterCndBuilderResourceDifference) Before() *filterCndBuilderResourceDifferenceBefore {
	return &filterCndBuilderResourceDifferenceBefore{builder: b.builder}
}

func (b *filterCndBuilderResourceDifference) After() *filterCndBuilderResourceDifferenceAfter {
	return &filterCndBuilderResourceDifferenceAfter{builder: b.builder}
}

type filterCndBuilderResourceDifferenceFields struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderResourceDifferenceFields) In(values []*fieldmaskpb.FieldMask) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		ActivityLog_FieldPathArrayOfValues: NewActivityLogFieldPathBuilder().Resource().Difference().Fields().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderResourceDifferenceFields) NotIn(values []*fieldmaskpb.FieldMask) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		ActivityLog_FieldPathArrayOfValues: NewActivityLogFieldPathBuilder().Resource().Difference().Fields().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderResourceDifferenceFields) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewActivityLogFieldPathBuilder().Resource().Difference().Fields().FieldPath(),
	})
}

func (b *filterCndBuilderResourceDifferenceFields) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewActivityLogFieldPathBuilder().Resource().Difference().Fields().FieldPath(),
	})
}

func (b *filterCndBuilderResourceDifferenceFields) compare(op gotenfilter.CompareOperator, value *fieldmaskpb.FieldMask) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                   op,
		ActivityLog_FieldPathValue: NewActivityLogFieldPathBuilder().Resource().Difference().Fields().WithValue(value),
	})
}

type filterCndBuilderResourceDifferenceBefore struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderResourceDifferenceBefore) In(values []*anypb.Any) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		ActivityLog_FieldPathArrayOfValues: NewActivityLogFieldPathBuilder().Resource().Difference().Before().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderResourceDifferenceBefore) NotIn(values []*anypb.Any) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		ActivityLog_FieldPathArrayOfValues: NewActivityLogFieldPathBuilder().Resource().Difference().Before().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderResourceDifferenceBefore) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewActivityLogFieldPathBuilder().Resource().Difference().Before().FieldPath(),
	})
}

func (b *filterCndBuilderResourceDifferenceBefore) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewActivityLogFieldPathBuilder().Resource().Difference().Before().FieldPath(),
	})
}

func (b *filterCndBuilderResourceDifferenceBefore) compare(op gotenfilter.CompareOperator, value *anypb.Any) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                   op,
		ActivityLog_FieldPathValue: NewActivityLogFieldPathBuilder().Resource().Difference().Before().WithValue(value),
	})
}

type filterCndBuilderResourceDifferenceAfter struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderResourceDifferenceAfter) In(values []*anypb.Any) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		ActivityLog_FieldPathArrayOfValues: NewActivityLogFieldPathBuilder().Resource().Difference().After().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderResourceDifferenceAfter) NotIn(values []*anypb.Any) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		ActivityLog_FieldPathArrayOfValues: NewActivityLogFieldPathBuilder().Resource().Difference().After().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderResourceDifferenceAfter) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewActivityLogFieldPathBuilder().Resource().Difference().After().FieldPath(),
	})
}

func (b *filterCndBuilderResourceDifferenceAfter) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewActivityLogFieldPathBuilder().Resource().Difference().After().FieldPath(),
	})
}

func (b *filterCndBuilderResourceDifferenceAfter) compare(op gotenfilter.CompareOperator, value *anypb.Any) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                   op,
		ActivityLog_FieldPathValue: NewActivityLogFieldPathBuilder().Resource().Difference().After().WithValue(value),
	})
}

type filterCndBuilderCategory struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderCategory) In(values []ActivityLog_Category) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		ActivityLog_FieldPathArrayOfValues: NewActivityLogFieldPathBuilder().Category().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderCategory) NotIn(values []ActivityLog_Category) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		ActivityLog_FieldPathArrayOfValues: NewActivityLogFieldPathBuilder().Category().WithArrayOfValues(values),
	})
}

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

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

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

type filterCndBuilderLabels struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderLabels) In(values []map[string]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		ActivityLog_FieldPathArrayOfValues: NewActivityLogFieldPathBuilder().Labels().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderLabels) NotIn(values []map[string]string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		ActivityLog_FieldPathArrayOfValues: NewActivityLogFieldPathBuilder().Labels().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderLabels) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewActivityLogFieldPathBuilder().Labels().FieldPath(),
	})
}

func (b *filterCndBuilderLabels) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewActivityLogFieldPathBuilder().Labels().FieldPath(),
	})
}

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

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

type mapFilterCndBuilderLabels struct {
	builder *FilterBuilder
	key     string
}

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

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

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

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

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

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

func (b *mapFilterCndBuilderLabels) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		ActivityLog_FieldPathArrayOfValues: NewActivityLogFieldPathBuilder().Labels().WithKey(b.key).WithArrayOfValues(values),
	})
}

func (b *mapFilterCndBuilderLabels) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		ActivityLog_FieldPathArrayOfValues: NewActivityLogFieldPathBuilder().Labels().WithKey(b.key).WithArrayOfValues(values),
	})
}

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

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

func (b *mapFilterCndBuilderLabels) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                   op,
		ActivityLog_FieldPathValue: NewActivityLogFieldPathBuilder().Labels().WithKey(b.key).WithValue(value),
	})
}

type filterCndBuilderEvents struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderEvents) In(values [][]*ActivityLog_Event) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		ActivityLog_FieldPathArrayOfValues: NewActivityLogFieldPathBuilder().Events().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderEvents) NotIn(values [][]*ActivityLog_Event) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		ActivityLog_FieldPathArrayOfValues: NewActivityLogFieldPathBuilder().Events().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderEvents) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewActivityLogFieldPathBuilder().Events().FieldPath(),
	})
}

func (b *filterCndBuilderEvents) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewActivityLogFieldPathBuilder().Events().FieldPath(),
	})
}

func (b *filterCndBuilderEvents) Contains(value *ActivityLog_Event) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewActivityLogFieldPathBuilder().Events().FieldPath(),
		Value:     NewActivityLogFieldPathBuilder().Events().WithItemValue(value),
	})
}

func (b *filterCndBuilderEvents) ContainsAnyOf(values []*ActivityLog_Event) *FilterBuilder {
	pathSelector := NewActivityLogFieldPathBuilder().Events()
	itemValues := make([]ActivityLog_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewActivityLogFieldPathBuilder().Events().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderEvents) ContainsAll(values []*ActivityLog_Event) *FilterBuilder {
	pathSelector := NewActivityLogFieldPathBuilder().Events()
	itemValues := make([]ActivityLog_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewActivityLogFieldPathBuilder().Events().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderEvents) compare(op gotenfilter.CompareOperator, value []*ActivityLog_Event) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                   op,
		ActivityLog_FieldPathValue: NewActivityLogFieldPathBuilder().Events().WithValue(value),
	})
}

func (b *filterCndBuilderEvents) ClientMessage() *filterCndBuilderEventsClientMessage {
	return &filterCndBuilderEventsClientMessage{builder: b.builder}
}

func (b *filterCndBuilderEvents) ServerMessage() *filterCndBuilderEventsServerMessage {
	return &filterCndBuilderEventsServerMessage{builder: b.builder}
}

func (b *filterCndBuilderEvents) Exit() *filterCndBuilderEventsExit {
	return &filterCndBuilderEventsExit{builder: b.builder}
}

func (b *filterCndBuilderEvents) RegionalServerMessage() *filterCndBuilderEventsRegionalServerMessage {
	return &filterCndBuilderEventsRegionalServerMessage{builder: b.builder}
}

func (b *filterCndBuilderEvents) RegionalExit() *filterCndBuilderEventsRegionalExit {
	return &filterCndBuilderEventsRegionalExit{builder: b.builder}
}

type filterCndBuilderEventsClientMessage struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderEventsClientMessage) Eq(value *ActivityLog_Event_ClientMsgEvent) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderEventsClientMessage) Neq(value *ActivityLog_Event_ClientMsgEvent) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderEventsClientMessage) Gt(value *ActivityLog_Event_ClientMsgEvent) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderEventsClientMessage) Gte(value *ActivityLog_Event_ClientMsgEvent) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderEventsClientMessage) Lt(value *ActivityLog_Event_ClientMsgEvent) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderEventsClientMessage) Lte(value *ActivityLog_Event_ClientMsgEvent) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderEventsClientMessage) In(values []*ActivityLog_Event_ClientMsgEvent) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		ActivityLog_FieldPathArrayOfValues: NewActivityLogFieldPathBuilder().Events().ClientMessage().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderEventsClientMessage) NotIn(values []*ActivityLog_Event_ClientMsgEvent) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		ActivityLog_FieldPathArrayOfValues: NewActivityLogFieldPathBuilder().Events().ClientMessage().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderEventsClientMessage) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewActivityLogFieldPathBuilder().Events().ClientMessage().FieldPath(),
	})
}

func (b *filterCndBuilderEventsClientMessage) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewActivityLogFieldPathBuilder().Events().ClientMessage().FieldPath(),
	})
}

func (b *filterCndBuilderEventsClientMessage) compare(op gotenfilter.CompareOperator, value *ActivityLog_Event_ClientMsgEvent) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                   op,
		ActivityLog_FieldPathValue: NewActivityLogFieldPathBuilder().Events().ClientMessage().WithValue(value),
	})
}

func (b *filterCndBuilderEventsClientMessage) Data() *filterCndBuilderEventsClientMessageData {
	return &filterCndBuilderEventsClientMessageData{builder: b.builder}
}

func (b *filterCndBuilderEventsClientMessage) Time() *filterCndBuilderEventsClientMessageTime {
	return &filterCndBuilderEventsClientMessageTime{builder: b.builder}
}

type filterCndBuilderEventsClientMessageData struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderEventsClientMessageData) In(values []*anypb.Any) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		ActivityLog_FieldPathArrayOfValues: NewActivityLogFieldPathBuilder().Events().ClientMessage().Data().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderEventsClientMessageData) NotIn(values []*anypb.Any) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		ActivityLog_FieldPathArrayOfValues: NewActivityLogFieldPathBuilder().Events().ClientMessage().Data().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderEventsClientMessageData) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewActivityLogFieldPathBuilder().Events().ClientMessage().Data().FieldPath(),
	})
}

func (b *filterCndBuilderEventsClientMessageData) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewActivityLogFieldPathBuilder().Events().ClientMessage().Data().FieldPath(),
	})
}

func (b *filterCndBuilderEventsClientMessageData) compare(op gotenfilter.CompareOperator, value *anypb.Any) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                   op,
		ActivityLog_FieldPathValue: NewActivityLogFieldPathBuilder().Events().ClientMessage().Data().WithValue(value),
	})
}

type filterCndBuilderEventsClientMessageTime struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderEventsClientMessageTime) In(values []*timestamppb.Timestamp) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		ActivityLog_FieldPathArrayOfValues: NewActivityLogFieldPathBuilder().Events().ClientMessage().Time().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderEventsClientMessageTime) NotIn(values []*timestamppb.Timestamp) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		ActivityLog_FieldPathArrayOfValues: NewActivityLogFieldPathBuilder().Events().ClientMessage().Time().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderEventsClientMessageTime) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewActivityLogFieldPathBuilder().Events().ClientMessage().Time().FieldPath(),
	})
}

func (b *filterCndBuilderEventsClientMessageTime) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewActivityLogFieldPathBuilder().Events().ClientMessage().Time().FieldPath(),
	})
}

func (b *filterCndBuilderEventsClientMessageTime) compare(op gotenfilter.CompareOperator, value *timestamppb.Timestamp) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                   op,
		ActivityLog_FieldPathValue: NewActivityLogFieldPathBuilder().Events().ClientMessage().Time().WithValue(value),
	})
}

type filterCndBuilderEventsServerMessage struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderEventsServerMessage) Eq(value *ActivityLog_Event_ServerMsgEvent) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderEventsServerMessage) Neq(value *ActivityLog_Event_ServerMsgEvent) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderEventsServerMessage) Gt(value *ActivityLog_Event_ServerMsgEvent) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderEventsServerMessage) Gte(value *ActivityLog_Event_ServerMsgEvent) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderEventsServerMessage) Lt(value *ActivityLog_Event_ServerMsgEvent) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderEventsServerMessage) Lte(value *ActivityLog_Event_ServerMsgEvent) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderEventsServerMessage) In(values []*ActivityLog_Event_ServerMsgEvent) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		ActivityLog_FieldPathArrayOfValues: NewActivityLogFieldPathBuilder().Events().ServerMessage().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderEventsServerMessage) NotIn(values []*ActivityLog_Event_ServerMsgEvent) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		ActivityLog_FieldPathArrayOfValues: NewActivityLogFieldPathBuilder().Events().ServerMessage().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderEventsServerMessage) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewActivityLogFieldPathBuilder().Events().ServerMessage().FieldPath(),
	})
}

func (b *filterCndBuilderEventsServerMessage) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewActivityLogFieldPathBuilder().Events().ServerMessage().FieldPath(),
	})
}

func (b *filterCndBuilderEventsServerMessage) compare(op gotenfilter.CompareOperator, value *ActivityLog_Event_ServerMsgEvent) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                   op,
		ActivityLog_FieldPathValue: NewActivityLogFieldPathBuilder().Events().ServerMessage().WithValue(value),
	})
}

func (b *filterCndBuilderEventsServerMessage) Data() *filterCndBuilderEventsServerMessageData {
	return &filterCndBuilderEventsServerMessageData{builder: b.builder}
}

func (b *filterCndBuilderEventsServerMessage) Time() *filterCndBuilderEventsServerMessageTime {
	return &filterCndBuilderEventsServerMessageTime{builder: b.builder}
}

type filterCndBuilderEventsServerMessageData struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderEventsServerMessageData) In(values []*anypb.Any) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		ActivityLog_FieldPathArrayOfValues: NewActivityLogFieldPathBuilder().Events().ServerMessage().Data().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderEventsServerMessageData) NotIn(values []*anypb.Any) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		ActivityLog_FieldPathArrayOfValues: NewActivityLogFieldPathBuilder().Events().ServerMessage().Data().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderEventsServerMessageData) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewActivityLogFieldPathBuilder().Events().ServerMessage().Data().FieldPath(),
	})
}

func (b *filterCndBuilderEventsServerMessageData) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewActivityLogFieldPathBuilder().Events().ServerMessage().Data().FieldPath(),
	})
}

func (b *filterCndBuilderEventsServerMessageData) compare(op gotenfilter.CompareOperator, value *anypb.Any) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                   op,
		ActivityLog_FieldPathValue: NewActivityLogFieldPathBuilder().Events().ServerMessage().Data().WithValue(value),
	})
}

type filterCndBuilderEventsServerMessageTime struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderEventsServerMessageTime) In(values []*timestamppb.Timestamp) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		ActivityLog_FieldPathArrayOfValues: NewActivityLogFieldPathBuilder().Events().ServerMessage().Time().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderEventsServerMessageTime) NotIn(values []*timestamppb.Timestamp) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		ActivityLog_FieldPathArrayOfValues: NewActivityLogFieldPathBuilder().Events().ServerMessage().Time().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderEventsServerMessageTime) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewActivityLogFieldPathBuilder().Events().ServerMessage().Time().FieldPath(),
	})
}

func (b *filterCndBuilderEventsServerMessageTime) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewActivityLogFieldPathBuilder().Events().ServerMessage().Time().FieldPath(),
	})
}

func (b *filterCndBuilderEventsServerMessageTime) compare(op gotenfilter.CompareOperator, value *timestamppb.Timestamp) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                   op,
		ActivityLog_FieldPathValue: NewActivityLogFieldPathBuilder().Events().ServerMessage().Time().WithValue(value),
	})
}

type filterCndBuilderEventsExit struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderEventsExit) Eq(value *ActivityLog_Event_ExitEvent) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderEventsExit) Neq(value *ActivityLog_Event_ExitEvent) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderEventsExit) Gt(value *ActivityLog_Event_ExitEvent) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderEventsExit) Gte(value *ActivityLog_Event_ExitEvent) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderEventsExit) Lt(value *ActivityLog_Event_ExitEvent) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderEventsExit) Lte(value *ActivityLog_Event_ExitEvent) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderEventsExit) In(values []*ActivityLog_Event_ExitEvent) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		ActivityLog_FieldPathArrayOfValues: NewActivityLogFieldPathBuilder().Events().Exit().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderEventsExit) NotIn(values []*ActivityLog_Event_ExitEvent) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		ActivityLog_FieldPathArrayOfValues: NewActivityLogFieldPathBuilder().Events().Exit().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderEventsExit) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewActivityLogFieldPathBuilder().Events().Exit().FieldPath(),
	})
}

func (b *filterCndBuilderEventsExit) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewActivityLogFieldPathBuilder().Events().Exit().FieldPath(),
	})
}

func (b *filterCndBuilderEventsExit) compare(op gotenfilter.CompareOperator, value *ActivityLog_Event_ExitEvent) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                   op,
		ActivityLog_FieldPathValue: NewActivityLogFieldPathBuilder().Events().Exit().WithValue(value),
	})
}

func (b *filterCndBuilderEventsExit) Status() *filterCndBuilderEventsExitStatus {
	return &filterCndBuilderEventsExitStatus{builder: b.builder}
}

func (b *filterCndBuilderEventsExit) Time() *filterCndBuilderEventsExitTime {
	return &filterCndBuilderEventsExitTime{builder: b.builder}
}

type filterCndBuilderEventsExitStatus struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderEventsExitStatus) Eq(value *rpc.Status) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderEventsExitStatus) Neq(value *rpc.Status) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderEventsExitStatus) Gt(value *rpc.Status) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderEventsExitStatus) Gte(value *rpc.Status) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderEventsExitStatus) Lt(value *rpc.Status) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderEventsExitStatus) Lte(value *rpc.Status) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderEventsExitStatus) In(values []*rpc.Status) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		ActivityLog_FieldPathArrayOfValues: NewActivityLogFieldPathBuilder().Events().Exit().Status().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderEventsExitStatus) NotIn(values []*rpc.Status) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		ActivityLog_FieldPathArrayOfValues: NewActivityLogFieldPathBuilder().Events().Exit().Status().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderEventsExitStatus) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewActivityLogFieldPathBuilder().Events().Exit().Status().FieldPath(),
	})
}

func (b *filterCndBuilderEventsExitStatus) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewActivityLogFieldPathBuilder().Events().Exit().Status().FieldPath(),
	})
}

func (b *filterCndBuilderEventsExitStatus) compare(op gotenfilter.CompareOperator, value *rpc.Status) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                   op,
		ActivityLog_FieldPathValue: NewActivityLogFieldPathBuilder().Events().Exit().Status().WithValue(value),
	})
}

func (b *filterCndBuilderEventsExitStatus) Code() *filterCndBuilderEventsExitStatusCode {
	return &filterCndBuilderEventsExitStatusCode{builder: b.builder}
}

func (b *filterCndBuilderEventsExitStatus) Message() *filterCndBuilderEventsExitStatusMessage {
	return &filterCndBuilderEventsExitStatusMessage{builder: b.builder}
}

func (b *filterCndBuilderEventsExitStatus) Details() *filterCndBuilderEventsExitStatusDetails {
	return &filterCndBuilderEventsExitStatusDetails{builder: b.builder}
}

type filterCndBuilderEventsExitStatusCode struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderEventsExitStatusCode) In(values []int32) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		ActivityLog_FieldPathArrayOfValues: NewActivityLogFieldPathBuilder().Events().Exit().Status().Code().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderEventsExitStatusCode) NotIn(values []int32) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		ActivityLog_FieldPathArrayOfValues: NewActivityLogFieldPathBuilder().Events().Exit().Status().Code().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderEventsExitStatusCode) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewActivityLogFieldPathBuilder().Events().Exit().Status().Code().FieldPath(),
	})
}

func (b *filterCndBuilderEventsExitStatusCode) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewActivityLogFieldPathBuilder().Events().Exit().Status().Code().FieldPath(),
	})
}

func (b *filterCndBuilderEventsExitStatusCode) compare(op gotenfilter.CompareOperator, value int32) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                   op,
		ActivityLog_FieldPathValue: NewActivityLogFieldPathBuilder().Events().Exit().Status().Code().WithValue(value),
	})
}

type filterCndBuilderEventsExitStatusMessage struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderEventsExitStatusMessage) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		ActivityLog_FieldPathArrayOfValues: NewActivityLogFieldPathBuilder().Events().Exit().Status().Message().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderEventsExitStatusMessage) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		ActivityLog_FieldPathArrayOfValues: NewActivityLogFieldPathBuilder().Events().Exit().Status().Message().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderEventsExitStatusMessage) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewActivityLogFieldPathBuilder().Events().Exit().Status().Message().FieldPath(),
	})
}

func (b *filterCndBuilderEventsExitStatusMessage) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewActivityLogFieldPathBuilder().Events().Exit().Status().Message().FieldPath(),
	})
}

func (b *filterCndBuilderEventsExitStatusMessage) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                   op,
		ActivityLog_FieldPathValue: NewActivityLogFieldPathBuilder().Events().Exit().Status().Message().WithValue(value),
	})
}

type filterCndBuilderEventsExitStatusDetails struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderEventsExitStatusDetails) In(values [][]*anypb.Any) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		ActivityLog_FieldPathArrayOfValues: NewActivityLogFieldPathBuilder().Events().Exit().Status().Details().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderEventsExitStatusDetails) NotIn(values [][]*anypb.Any) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		ActivityLog_FieldPathArrayOfValues: NewActivityLogFieldPathBuilder().Events().Exit().Status().Details().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderEventsExitStatusDetails) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewActivityLogFieldPathBuilder().Events().Exit().Status().Details().FieldPath(),
	})
}

func (b *filterCndBuilderEventsExitStatusDetails) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewActivityLogFieldPathBuilder().Events().Exit().Status().Details().FieldPath(),
	})
}

func (b *filterCndBuilderEventsExitStatusDetails) Contains(value *anypb.Any) *FilterBuilder {
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeValue,
		FieldPath: NewActivityLogFieldPathBuilder().Events().Exit().Status().Details().FieldPath(),
		Value:     NewActivityLogFieldPathBuilder().Events().Exit().Status().Details().WithItemValue(value),
	})
}

func (b *filterCndBuilderEventsExitStatusDetails) ContainsAnyOf(values []*anypb.Any) *FilterBuilder {
	pathSelector := NewActivityLogFieldPathBuilder().Events().Exit().Status().Details()
	itemValues := make([]ActivityLog_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAny,
		FieldPath: NewActivityLogFieldPathBuilder().Events().Exit().Status().Details().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderEventsExitStatusDetails) ContainsAll(values []*anypb.Any) *FilterBuilder {
	pathSelector := NewActivityLogFieldPathBuilder().Events().Exit().Status().Details()
	itemValues := make([]ActivityLog_FieldPathArrayItemValue, 0, len(values))
	for _, value := range values {
		itemValues = append(itemValues, pathSelector.WithItemValue(value))
	}
	return b.builder.addCond(&FilterConditionContains{
		Type:      gotenresource.ConditionContainsTypeAll,
		FieldPath: NewActivityLogFieldPathBuilder().Events().Exit().Status().Details().FieldPath(),
		Values:    itemValues,
	})
}

func (b *filterCndBuilderEventsExitStatusDetails) compare(op gotenfilter.CompareOperator, value []*anypb.Any) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                   op,
		ActivityLog_FieldPathValue: NewActivityLogFieldPathBuilder().Events().Exit().Status().Details().WithValue(value),
	})
}

type filterCndBuilderEventsExitTime struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderEventsExitTime) In(values []*timestamppb.Timestamp) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		ActivityLog_FieldPathArrayOfValues: NewActivityLogFieldPathBuilder().Events().Exit().Time().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderEventsExitTime) NotIn(values []*timestamppb.Timestamp) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		ActivityLog_FieldPathArrayOfValues: NewActivityLogFieldPathBuilder().Events().Exit().Time().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderEventsExitTime) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewActivityLogFieldPathBuilder().Events().Exit().Time().FieldPath(),
	})
}

func (b *filterCndBuilderEventsExitTime) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewActivityLogFieldPathBuilder().Events().Exit().Time().FieldPath(),
	})
}

func (b *filterCndBuilderEventsExitTime) compare(op gotenfilter.CompareOperator, value *timestamppb.Timestamp) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                   op,
		ActivityLog_FieldPathValue: NewActivityLogFieldPathBuilder().Events().Exit().Time().WithValue(value),
	})
}

type filterCndBuilderEventsRegionalServerMessage struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderEventsRegionalServerMessage) Eq(value *ActivityLog_Event_RegionalServerMsgEvent) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderEventsRegionalServerMessage) Neq(value *ActivityLog_Event_RegionalServerMsgEvent) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderEventsRegionalServerMessage) Gt(value *ActivityLog_Event_RegionalServerMsgEvent) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderEventsRegionalServerMessage) Gte(value *ActivityLog_Event_RegionalServerMsgEvent) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderEventsRegionalServerMessage) Lt(value *ActivityLog_Event_RegionalServerMsgEvent) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderEventsRegionalServerMessage) Lte(value *ActivityLog_Event_RegionalServerMsgEvent) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderEventsRegionalServerMessage) In(values []*ActivityLog_Event_RegionalServerMsgEvent) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		ActivityLog_FieldPathArrayOfValues: NewActivityLogFieldPathBuilder().Events().RegionalServerMessage().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderEventsRegionalServerMessage) NotIn(values []*ActivityLog_Event_RegionalServerMsgEvent) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		ActivityLog_FieldPathArrayOfValues: NewActivityLogFieldPathBuilder().Events().RegionalServerMessage().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderEventsRegionalServerMessage) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewActivityLogFieldPathBuilder().Events().RegionalServerMessage().FieldPath(),
	})
}

func (b *filterCndBuilderEventsRegionalServerMessage) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewActivityLogFieldPathBuilder().Events().RegionalServerMessage().FieldPath(),
	})
}

func (b *filterCndBuilderEventsRegionalServerMessage) compare(op gotenfilter.CompareOperator, value *ActivityLog_Event_RegionalServerMsgEvent) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                   op,
		ActivityLog_FieldPathValue: NewActivityLogFieldPathBuilder().Events().RegionalServerMessage().WithValue(value),
	})
}

func (b *filterCndBuilderEventsRegionalServerMessage) Data() *filterCndBuilderEventsRegionalServerMessageData {
	return &filterCndBuilderEventsRegionalServerMessageData{builder: b.builder}
}

func (b *filterCndBuilderEventsRegionalServerMessage) Time() *filterCndBuilderEventsRegionalServerMessageTime {
	return &filterCndBuilderEventsRegionalServerMessageTime{builder: b.builder}
}

func (b *filterCndBuilderEventsRegionalServerMessage) RegionId() *filterCndBuilderEventsRegionalServerMessageRegionId {
	return &filterCndBuilderEventsRegionalServerMessageRegionId{builder: b.builder}
}

type filterCndBuilderEventsRegionalServerMessageData struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderEventsRegionalServerMessageData) In(values []*anypb.Any) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		ActivityLog_FieldPathArrayOfValues: NewActivityLogFieldPathBuilder().Events().RegionalServerMessage().Data().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderEventsRegionalServerMessageData) NotIn(values []*anypb.Any) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		ActivityLog_FieldPathArrayOfValues: NewActivityLogFieldPathBuilder().Events().RegionalServerMessage().Data().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderEventsRegionalServerMessageData) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewActivityLogFieldPathBuilder().Events().RegionalServerMessage().Data().FieldPath(),
	})
}

func (b *filterCndBuilderEventsRegionalServerMessageData) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewActivityLogFieldPathBuilder().Events().RegionalServerMessage().Data().FieldPath(),
	})
}

func (b *filterCndBuilderEventsRegionalServerMessageData) compare(op gotenfilter.CompareOperator, value *anypb.Any) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                   op,
		ActivityLog_FieldPathValue: NewActivityLogFieldPathBuilder().Events().RegionalServerMessage().Data().WithValue(value),
	})
}

type filterCndBuilderEventsRegionalServerMessageTime struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderEventsRegionalServerMessageTime) In(values []*timestamppb.Timestamp) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		ActivityLog_FieldPathArrayOfValues: NewActivityLogFieldPathBuilder().Events().RegionalServerMessage().Time().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderEventsRegionalServerMessageTime) NotIn(values []*timestamppb.Timestamp) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		ActivityLog_FieldPathArrayOfValues: NewActivityLogFieldPathBuilder().Events().RegionalServerMessage().Time().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderEventsRegionalServerMessageTime) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewActivityLogFieldPathBuilder().Events().RegionalServerMessage().Time().FieldPath(),
	})
}

func (b *filterCndBuilderEventsRegionalServerMessageTime) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewActivityLogFieldPathBuilder().Events().RegionalServerMessage().Time().FieldPath(),
	})
}

func (b *filterCndBuilderEventsRegionalServerMessageTime) compare(op gotenfilter.CompareOperator, value *timestamppb.Timestamp) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                   op,
		ActivityLog_FieldPathValue: NewActivityLogFieldPathBuilder().Events().RegionalServerMessage().Time().WithValue(value),
	})
}

type filterCndBuilderEventsRegionalServerMessageRegionId struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderEventsRegionalServerMessageRegionId) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		ActivityLog_FieldPathArrayOfValues: NewActivityLogFieldPathBuilder().Events().RegionalServerMessage().RegionId().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderEventsRegionalServerMessageRegionId) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		ActivityLog_FieldPathArrayOfValues: NewActivityLogFieldPathBuilder().Events().RegionalServerMessage().RegionId().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderEventsRegionalServerMessageRegionId) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewActivityLogFieldPathBuilder().Events().RegionalServerMessage().RegionId().FieldPath(),
	})
}

func (b *filterCndBuilderEventsRegionalServerMessageRegionId) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewActivityLogFieldPathBuilder().Events().RegionalServerMessage().RegionId().FieldPath(),
	})
}

func (b *filterCndBuilderEventsRegionalServerMessageRegionId) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                   op,
		ActivityLog_FieldPathValue: NewActivityLogFieldPathBuilder().Events().RegionalServerMessage().RegionId().WithValue(value),
	})
}

type filterCndBuilderEventsRegionalExit struct {
	builder *FilterBuilder
}

func (b *filterCndBuilderEventsRegionalExit) Eq(value *ActivityLog_Event_RegionalServerMsgEvent) *FilterBuilder {
	return b.compare(gotenfilter.Eq, value)
}

func (b *filterCndBuilderEventsRegionalExit) Neq(value *ActivityLog_Event_RegionalServerMsgEvent) *FilterBuilder {
	return b.compare(gotenfilter.Neq, value)
}

func (b *filterCndBuilderEventsRegionalExit) Gt(value *ActivityLog_Event_RegionalServerMsgEvent) *FilterBuilder {
	return b.compare(gotenfilter.Gt, value)
}

func (b *filterCndBuilderEventsRegionalExit) Gte(value *ActivityLog_Event_RegionalServerMsgEvent) *FilterBuilder {
	return b.compare(gotenfilter.Gte, value)
}

func (b *filterCndBuilderEventsRegionalExit) Lt(value *ActivityLog_Event_RegionalServerMsgEvent) *FilterBuilder {
	return b.compare(gotenfilter.Lt, value)
}

func (b *filterCndBuilderEventsRegionalExit) Lte(value *ActivityLog_Event_RegionalServerMsgEvent) *FilterBuilder {
	return b.compare(gotenfilter.Lte, value)
}

func (b *filterCndBuilderEventsRegionalExit) In(values []*ActivityLog_Event_RegionalServerMsgEvent) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		ActivityLog_FieldPathArrayOfValues: NewActivityLogFieldPathBuilder().Events().RegionalExit().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderEventsRegionalExit) NotIn(values []*ActivityLog_Event_RegionalServerMsgEvent) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		ActivityLog_FieldPathArrayOfValues: NewActivityLogFieldPathBuilder().Events().RegionalExit().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderEventsRegionalExit) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewActivityLogFieldPathBuilder().Events().RegionalExit().FieldPath(),
	})
}

func (b *filterCndBuilderEventsRegionalExit) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewActivityLogFieldPathBuilder().Events().RegionalExit().FieldPath(),
	})
}

func (b *filterCndBuilderEventsRegionalExit) compare(op gotenfilter.CompareOperator, value *ActivityLog_Event_RegionalServerMsgEvent) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                   op,
		ActivityLog_FieldPathValue: NewActivityLogFieldPathBuilder().Events().RegionalExit().WithValue(value),
	})
}

func (b *filterCndBuilderEventsRegionalExit) Data() *filterCndBuilderEventsRegionalExitData {
	return &filterCndBuilderEventsRegionalExitData{builder: b.builder}
}

func (b *filterCndBuilderEventsRegionalExit) Time() *filterCndBuilderEventsRegionalExitTime {
	return &filterCndBuilderEventsRegionalExitTime{builder: b.builder}
}

func (b *filterCndBuilderEventsRegionalExit) RegionId() *filterCndBuilderEventsRegionalExitRegionId {
	return &filterCndBuilderEventsRegionalExitRegionId{builder: b.builder}
}

type filterCndBuilderEventsRegionalExitData struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderEventsRegionalExitData) In(values []*anypb.Any) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		ActivityLog_FieldPathArrayOfValues: NewActivityLogFieldPathBuilder().Events().RegionalExit().Data().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderEventsRegionalExitData) NotIn(values []*anypb.Any) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		ActivityLog_FieldPathArrayOfValues: NewActivityLogFieldPathBuilder().Events().RegionalExit().Data().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderEventsRegionalExitData) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewActivityLogFieldPathBuilder().Events().RegionalExit().Data().FieldPath(),
	})
}

func (b *filterCndBuilderEventsRegionalExitData) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewActivityLogFieldPathBuilder().Events().RegionalExit().Data().FieldPath(),
	})
}

func (b *filterCndBuilderEventsRegionalExitData) compare(op gotenfilter.CompareOperator, value *anypb.Any) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                   op,
		ActivityLog_FieldPathValue: NewActivityLogFieldPathBuilder().Events().RegionalExit().Data().WithValue(value),
	})
}

type filterCndBuilderEventsRegionalExitTime struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderEventsRegionalExitTime) In(values []*timestamppb.Timestamp) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		ActivityLog_FieldPathArrayOfValues: NewActivityLogFieldPathBuilder().Events().RegionalExit().Time().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderEventsRegionalExitTime) NotIn(values []*timestamppb.Timestamp) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		ActivityLog_FieldPathArrayOfValues: NewActivityLogFieldPathBuilder().Events().RegionalExit().Time().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderEventsRegionalExitTime) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewActivityLogFieldPathBuilder().Events().RegionalExit().Time().FieldPath(),
	})
}

func (b *filterCndBuilderEventsRegionalExitTime) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewActivityLogFieldPathBuilder().Events().RegionalExit().Time().FieldPath(),
	})
}

func (b *filterCndBuilderEventsRegionalExitTime) compare(op gotenfilter.CompareOperator, value *timestamppb.Timestamp) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                   op,
		ActivityLog_FieldPathValue: NewActivityLogFieldPathBuilder().Events().RegionalExit().Time().WithValue(value),
	})
}

type filterCndBuilderEventsRegionalExitRegionId struct {
	builder *FilterBuilder
}

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

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

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

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

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

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

func (b *filterCndBuilderEventsRegionalExitRegionId) In(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionIn{
		ActivityLog_FieldPathArrayOfValues: NewActivityLogFieldPathBuilder().Events().RegionalExit().RegionId().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderEventsRegionalExitRegionId) NotIn(values []string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionNotIn{
		ActivityLog_FieldPathArrayOfValues: NewActivityLogFieldPathBuilder().Events().RegionalExit().RegionId().WithArrayOfValues(values),
	})
}

func (b *filterCndBuilderEventsRegionalExitRegionId) IsNull() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNull{
		FieldPath: NewActivityLogFieldPathBuilder().Events().RegionalExit().RegionId().FieldPath(),
	})
}

func (b *filterCndBuilderEventsRegionalExitRegionId) IsNan() *FilterBuilder {
	return b.builder.addCond(&FilterConditionIsNaN{
		FieldPath: NewActivityLogFieldPathBuilder().Events().RegionalExit().RegionId().FieldPath(),
	})
}

func (b *filterCndBuilderEventsRegionalExitRegionId) compare(op gotenfilter.CompareOperator, value string) *FilterBuilder {
	return b.builder.addCond(&FilterConditionCompare{
		Operator:                   op,
		ActivityLog_FieldPathValue: NewActivityLogFieldPathBuilder().Events().RegionalExit().RegionId().WithValue(value),
	})
}