activity_log.pb.fieldpath.go

// Code generated by protoc-gen-goten-object
// File: edgelq/audit/proto/v1alpha2/activity_log.proto
// DO NOT EDIT!!!

package activity_log

import (
	"encoding/json"
	"fmt"
	"reflect"
	"strings"
	"time"

	"github.com/iancoleman/strcase"
	"google.golang.org/grpc/codes"
	"google.golang.org/grpc/status"
	"google.golang.org/protobuf/encoding/protojson"
	"google.golang.org/protobuf/proto"
	"google.golang.org/protobuf/reflect/protoregistry"

	gotenobject "github.com/cloudwan/goten-sdk/runtime/object"
)

// proto imports
import (
	common "github.com/cloudwan/edgelq-sdk/audit/resources/v1alpha2/common"
	rpc "github.com/cloudwan/edgelq-sdk/common/rpc"
	iam_organization "github.com/cloudwan/edgelq-sdk/iam/resources/v1alpha2/organization"
	iam_project "github.com/cloudwan/edgelq-sdk/iam/resources/v1alpha2/project"
	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 (
	_ = new(json.Marshaler)
	_ = new(fmt.Stringer)
	_ = reflect.DeepEqual
	_ = strings.Builder{}
	_ = time.Second

	_ = strcase.ToLowerCamel
	_ = codes.NotFound
	_ = status.Status{}
	_ = protojson.UnmarshalOptions{}
	_ = new(proto.Message)
	_ = protoregistry.GlobalTypes

	_ = new(gotenobject.FieldPath)
)

// make sure we're using proto imports
var (
	_ = &common.Authentication{}
	_ = &rpc.Status{}
	_ = &iam_organization.Organization{}
	_ = &iam_project.Project{}
	_ = &anypb.Any{}
	_ = &fieldmaskpb.FieldMask{}
	_ = &timestamppb.Timestamp{}
)

// FieldPath provides implementation to handle
// https://github.com/protocolbuffers/protobuf/blob/master/src/google/protobuf/field_mask.proto
type ActivityLog_FieldPath interface {
	gotenobject.FieldPath
	Selector() ActivityLog_FieldPathSelector
	Get(source *ActivityLog) []interface{}
	GetSingle(source *ActivityLog) (interface{}, bool)
	ClearValue(item *ActivityLog)

	// Those methods build corresponding ActivityLog_FieldPathValue
	// (or array of values) and holds passed value. Panics if injected type is incorrect.
	WithIValue(value interface{}) ActivityLog_FieldPathValue
	WithIArrayOfValues(values interface{}) ActivityLog_FieldPathArrayOfValues
	WithIArrayItemValue(value interface{}) ActivityLog_FieldPathArrayItemValue
}

type ActivityLog_FieldPathSelector int32

const (
	ActivityLog_FieldPathSelectorName            ActivityLog_FieldPathSelector = 0
	ActivityLog_FieldPathSelectorScope           ActivityLog_FieldPathSelector = 1
	ActivityLog_FieldPathSelectorRequestId       ActivityLog_FieldPathSelector = 2
	ActivityLog_FieldPathSelectorAuthentication  ActivityLog_FieldPathSelector = 3
	ActivityLog_FieldPathSelectorAuthorization   ActivityLog_FieldPathSelector = 4
	ActivityLog_FieldPathSelectorService         ActivityLog_FieldPathSelector = 5
	ActivityLog_FieldPathSelectorMethod          ActivityLog_FieldPathSelector = 6
	ActivityLog_FieldPathSelectorRequestMetadata ActivityLog_FieldPathSelector = 7
	ActivityLog_FieldPathSelectorRequestRouting  ActivityLog_FieldPathSelector = 8
	ActivityLog_FieldPathSelectorResource        ActivityLog_FieldPathSelector = 9
	ActivityLog_FieldPathSelectorCategory        ActivityLog_FieldPathSelector = 10
	ActivityLog_FieldPathSelectorLabels          ActivityLog_FieldPathSelector = 11
	ActivityLog_FieldPathSelectorEvents          ActivityLog_FieldPathSelector = 12
)

func (s ActivityLog_FieldPathSelector) String() string {
	switch s {
	case ActivityLog_FieldPathSelectorName:
		return "name"
	case ActivityLog_FieldPathSelectorScope:
		return "scope"
	case ActivityLog_FieldPathSelectorRequestId:
		return "request_id"
	case ActivityLog_FieldPathSelectorAuthentication:
		return "authentication"
	case ActivityLog_FieldPathSelectorAuthorization:
		return "authorization"
	case ActivityLog_FieldPathSelectorService:
		return "service"
	case ActivityLog_FieldPathSelectorMethod:
		return "method"
	case ActivityLog_FieldPathSelectorRequestMetadata:
		return "request_metadata"
	case ActivityLog_FieldPathSelectorRequestRouting:
		return "request_routing"
	case ActivityLog_FieldPathSelectorResource:
		return "resource"
	case ActivityLog_FieldPathSelectorCategory:
		return "category"
	case ActivityLog_FieldPathSelectorLabels:
		return "labels"
	case ActivityLog_FieldPathSelectorEvents:
		return "events"
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog: %d", s))
	}
}

func BuildActivityLog_FieldPath(fp gotenobject.RawFieldPath) (ActivityLog_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object ActivityLog")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "name":
			return &ActivityLog_FieldTerminalPath{selector: ActivityLog_FieldPathSelectorName}, nil
		case "scope":
			return &ActivityLog_FieldTerminalPath{selector: ActivityLog_FieldPathSelectorScope}, nil
		case "request_id", "requestId", "request-id":
			return &ActivityLog_FieldTerminalPath{selector: ActivityLog_FieldPathSelectorRequestId}, nil
		case "authentication":
			return &ActivityLog_FieldTerminalPath{selector: ActivityLog_FieldPathSelectorAuthentication}, nil
		case "authorization":
			return &ActivityLog_FieldTerminalPath{selector: ActivityLog_FieldPathSelectorAuthorization}, nil
		case "service":
			return &ActivityLog_FieldTerminalPath{selector: ActivityLog_FieldPathSelectorService}, nil
		case "method":
			return &ActivityLog_FieldTerminalPath{selector: ActivityLog_FieldPathSelectorMethod}, nil
		case "request_metadata", "requestMetadata", "request-metadata":
			return &ActivityLog_FieldTerminalPath{selector: ActivityLog_FieldPathSelectorRequestMetadata}, nil
		case "request_routing", "requestRouting", "request-routing":
			return &ActivityLog_FieldTerminalPath{selector: ActivityLog_FieldPathSelectorRequestRouting}, nil
		case "resource":
			return &ActivityLog_FieldTerminalPath{selector: ActivityLog_FieldPathSelectorResource}, nil
		case "category":
			return &ActivityLog_FieldTerminalPath{selector: ActivityLog_FieldPathSelectorCategory}, nil
		case "labels":
			return &ActivityLog_FieldTerminalPath{selector: ActivityLog_FieldPathSelectorLabels}, nil
		case "events":
			return &ActivityLog_FieldTerminalPath{selector: ActivityLog_FieldPathSelectorEvents}, nil
		}
	} else {
		switch fp[0] {
		case "authentication":
			if subpath, err := common.BuildAuthentication_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &ActivityLog_FieldSubPath{selector: ActivityLog_FieldPathSelectorAuthentication, subPath: subpath}, nil
			}
		case "authorization":
			if subpath, err := common.BuildAuthorization_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &ActivityLog_FieldSubPath{selector: ActivityLog_FieldPathSelectorAuthorization, subPath: subpath}, nil
			}
		case "service":
			if subpath, err := common.BuildServiceData_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &ActivityLog_FieldSubPath{selector: ActivityLog_FieldPathSelectorService, subPath: subpath}, nil
			}
		case "method":
			if subpath, err := BuildActivityLogMethod_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &ActivityLog_FieldSubPath{selector: ActivityLog_FieldPathSelectorMethod, subPath: subpath}, nil
			}
		case "request_metadata", "requestMetadata", "request-metadata":
			if subpath, err := BuildActivityLogRequestMetadata_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &ActivityLog_FieldSubPath{selector: ActivityLog_FieldPathSelectorRequestMetadata, subPath: subpath}, nil
			}
		case "request_routing", "requestRouting", "request-routing":
			if subpath, err := BuildActivityLogRequestRouting_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &ActivityLog_FieldSubPath{selector: ActivityLog_FieldPathSelectorRequestRouting, subPath: subpath}, nil
			}
		case "resource":
			if subpath, err := BuildActivityLogResource_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &ActivityLog_FieldSubPath{selector: ActivityLog_FieldPathSelectorResource, subPath: subpath}, nil
			}
		case "events":
			if subpath, err := BuildActivityLogEvent_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &ActivityLog_FieldSubPath{selector: ActivityLog_FieldPathSelectorEvents, subPath: subpath}, nil
			}
		case "labels":
			if len(fp) > 2 {
				return nil, status.Errorf(codes.InvalidArgument, "sub path for maps ('%s') are not supported (object ActivityLog)", fp)
			}
			return &ActivityLog_FieldPathMap{selector: ActivityLog_FieldPathSelectorLabels, key: fp[1]}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object ActivityLog", fp)
}

func ParseActivityLog_FieldPath(rawField string) (ActivityLog_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildActivityLog_FieldPath(fp)
}

func MustParseActivityLog_FieldPath(rawField string) ActivityLog_FieldPath {
	fp, err := ParseActivityLog_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type ActivityLog_FieldTerminalPath struct {
	selector ActivityLog_FieldPathSelector
}

var _ ActivityLog_FieldPath = (*ActivityLog_FieldTerminalPath)(nil)

func (fp *ActivityLog_FieldTerminalPath) Selector() ActivityLog_FieldPathSelector {
	return fp.selector
}

// String returns path representation in proto convention
func (fp *ActivityLog_FieldTerminalPath) String() string {
	return fp.selector.String()
}

// JSONString returns path representation is JSON convention
func (fp *ActivityLog_FieldTerminalPath) JSONString() string {
	return strcase.ToLowerCamel(fp.String())
}

// Get returns all values pointed by specific field from source ActivityLog
func (fp *ActivityLog_FieldTerminalPath) Get(source *ActivityLog) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case ActivityLog_FieldPathSelectorName:
			if source.Name != nil {
				values = append(values, source.Name)
			}
		case ActivityLog_FieldPathSelectorScope:
			values = append(values, source.Scope)
		case ActivityLog_FieldPathSelectorRequestId:
			values = append(values, source.RequestId)
		case ActivityLog_FieldPathSelectorAuthentication:
			if source.Authentication != nil {
				values = append(values, source.Authentication)
			}
		case ActivityLog_FieldPathSelectorAuthorization:
			if source.Authorization != nil {
				values = append(values, source.Authorization)
			}
		case ActivityLog_FieldPathSelectorService:
			if source.Service != nil {
				values = append(values, source.Service)
			}
		case ActivityLog_FieldPathSelectorMethod:
			if source.Method != nil {
				values = append(values, source.Method)
			}
		case ActivityLog_FieldPathSelectorRequestMetadata:
			if source.RequestMetadata != nil {
				values = append(values, source.RequestMetadata)
			}
		case ActivityLog_FieldPathSelectorRequestRouting:
			if source.RequestRouting != nil {
				values = append(values, source.RequestRouting)
			}
		case ActivityLog_FieldPathSelectorResource:
			if source.Resource != nil {
				values = append(values, source.Resource)
			}
		case ActivityLog_FieldPathSelectorCategory:
			values = append(values, source.Category)
		case ActivityLog_FieldPathSelectorLabels:
			values = append(values, source.Labels)
		case ActivityLog_FieldPathSelectorEvents:
			for _, value := range source.GetEvents() {
				values = append(values, value)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for ActivityLog: %d", fp.selector))
		}
	}
	return
}

func (fp *ActivityLog_FieldTerminalPath) GetRaw(source proto.Message) []interface{} {
	return fp.Get(source.(*ActivityLog))
}

// GetSingle returns value pointed by specific field of from source ActivityLog
func (fp *ActivityLog_FieldTerminalPath) GetSingle(source *ActivityLog) (interface{}, bool) {
	switch fp.selector {
	case ActivityLog_FieldPathSelectorName:
		res := source.GetName()
		return res, res != nil
	case ActivityLog_FieldPathSelectorScope:
		return source.GetScope(), source != nil
	case ActivityLog_FieldPathSelectorRequestId:
		return source.GetRequestId(), source != nil
	case ActivityLog_FieldPathSelectorAuthentication:
		res := source.GetAuthentication()
		return res, res != nil
	case ActivityLog_FieldPathSelectorAuthorization:
		res := source.GetAuthorization()
		return res, res != nil
	case ActivityLog_FieldPathSelectorService:
		res := source.GetService()
		return res, res != nil
	case ActivityLog_FieldPathSelectorMethod:
		res := source.GetMethod()
		return res, res != nil
	case ActivityLog_FieldPathSelectorRequestMetadata:
		res := source.GetRequestMetadata()
		return res, res != nil
	case ActivityLog_FieldPathSelectorRequestRouting:
		res := source.GetRequestRouting()
		return res, res != nil
	case ActivityLog_FieldPathSelectorResource:
		res := source.GetResource()
		return res, res != nil
	case ActivityLog_FieldPathSelectorCategory:
		return source.GetCategory(), source != nil
	case ActivityLog_FieldPathSelectorLabels:
		res := source.GetLabels()
		return res, res != nil
	case ActivityLog_FieldPathSelectorEvents:
		res := source.GetEvents()
		return res, res != nil
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog: %d", fp.selector))
	}
}

func (fp *ActivityLog_FieldTerminalPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fp.GetSingle(source.(*ActivityLog))
}

// GetDefault returns a default value of the field type
func (fp *ActivityLog_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case ActivityLog_FieldPathSelectorName:
		return (*Name)(nil)
	case ActivityLog_FieldPathSelectorScope:
		return ""
	case ActivityLog_FieldPathSelectorRequestId:
		return uint64(0)
	case ActivityLog_FieldPathSelectorAuthentication:
		return (*common.Authentication)(nil)
	case ActivityLog_FieldPathSelectorAuthorization:
		return (*common.Authorization)(nil)
	case ActivityLog_FieldPathSelectorService:
		return (*common.ServiceData)(nil)
	case ActivityLog_FieldPathSelectorMethod:
		return (*ActivityLog_Method)(nil)
	case ActivityLog_FieldPathSelectorRequestMetadata:
		return (*ActivityLog_RequestMetadata)(nil)
	case ActivityLog_FieldPathSelectorRequestRouting:
		return (*ActivityLog_RequestRouting)(nil)
	case ActivityLog_FieldPathSelectorResource:
		return (*ActivityLog_Resource)(nil)
	case ActivityLog_FieldPathSelectorCategory:
		return ActivityLog_Undefined
	case ActivityLog_FieldPathSelectorLabels:
		return (map[string]string)(nil)
	case ActivityLog_FieldPathSelectorEvents:
		return ([]*ActivityLog_Event)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog: %d", fp.selector))
	}
}

func (fp *ActivityLog_FieldTerminalPath) ClearValue(item *ActivityLog) {
	if item != nil {
		switch fp.selector {
		case ActivityLog_FieldPathSelectorName:
			item.Name = nil
		case ActivityLog_FieldPathSelectorScope:
			item.Scope = ""
		case ActivityLog_FieldPathSelectorRequestId:
			item.RequestId = uint64(0)
		case ActivityLog_FieldPathSelectorAuthentication:
			item.Authentication = nil
		case ActivityLog_FieldPathSelectorAuthorization:
			item.Authorization = nil
		case ActivityLog_FieldPathSelectorService:
			item.Service = nil
		case ActivityLog_FieldPathSelectorMethod:
			item.Method = nil
		case ActivityLog_FieldPathSelectorRequestMetadata:
			item.RequestMetadata = nil
		case ActivityLog_FieldPathSelectorRequestRouting:
			item.RequestRouting = nil
		case ActivityLog_FieldPathSelectorResource:
			item.Resource = nil
		case ActivityLog_FieldPathSelectorCategory:
			item.Category = ActivityLog_Undefined
		case ActivityLog_FieldPathSelectorLabels:
			item.Labels = nil
		case ActivityLog_FieldPathSelectorEvents:
			item.Events = nil
		default:
			panic(fmt.Sprintf("Invalid selector for ActivityLog: %d", fp.selector))
		}
	}
}

func (fp *ActivityLog_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*ActivityLog))
}

// IsLeaf - whether field path is holds simple value
func (fp *ActivityLog_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == ActivityLog_FieldPathSelectorName ||
		fp.selector == ActivityLog_FieldPathSelectorScope ||
		fp.selector == ActivityLog_FieldPathSelectorRequestId ||
		fp.selector == ActivityLog_FieldPathSelectorCategory ||
		fp.selector == ActivityLog_FieldPathSelectorLabels
}

func (fp *ActivityLog_FieldTerminalPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
	return []gotenobject.FieldPath{fp}
}

func (fp *ActivityLog_FieldTerminalPath) WithIValue(value interface{}) ActivityLog_FieldPathValue {
	switch fp.selector {
	case ActivityLog_FieldPathSelectorName:
		return &ActivityLog_FieldTerminalPathValue{ActivityLog_FieldTerminalPath: *fp, value: value.(*Name)}
	case ActivityLog_FieldPathSelectorScope:
		return &ActivityLog_FieldTerminalPathValue{ActivityLog_FieldTerminalPath: *fp, value: value.(string)}
	case ActivityLog_FieldPathSelectorRequestId:
		return &ActivityLog_FieldTerminalPathValue{ActivityLog_FieldTerminalPath: *fp, value: value.(uint64)}
	case ActivityLog_FieldPathSelectorAuthentication:
		return &ActivityLog_FieldTerminalPathValue{ActivityLog_FieldTerminalPath: *fp, value: value.(*common.Authentication)}
	case ActivityLog_FieldPathSelectorAuthorization:
		return &ActivityLog_FieldTerminalPathValue{ActivityLog_FieldTerminalPath: *fp, value: value.(*common.Authorization)}
	case ActivityLog_FieldPathSelectorService:
		return &ActivityLog_FieldTerminalPathValue{ActivityLog_FieldTerminalPath: *fp, value: value.(*common.ServiceData)}
	case ActivityLog_FieldPathSelectorMethod:
		return &ActivityLog_FieldTerminalPathValue{ActivityLog_FieldTerminalPath: *fp, value: value.(*ActivityLog_Method)}
	case ActivityLog_FieldPathSelectorRequestMetadata:
		return &ActivityLog_FieldTerminalPathValue{ActivityLog_FieldTerminalPath: *fp, value: value.(*ActivityLog_RequestMetadata)}
	case ActivityLog_FieldPathSelectorRequestRouting:
		return &ActivityLog_FieldTerminalPathValue{ActivityLog_FieldTerminalPath: *fp, value: value.(*ActivityLog_RequestRouting)}
	case ActivityLog_FieldPathSelectorResource:
		return &ActivityLog_FieldTerminalPathValue{ActivityLog_FieldTerminalPath: *fp, value: value.(*ActivityLog_Resource)}
	case ActivityLog_FieldPathSelectorCategory:
		return &ActivityLog_FieldTerminalPathValue{ActivityLog_FieldTerminalPath: *fp, value: value.(ActivityLog_Category)}
	case ActivityLog_FieldPathSelectorLabels:
		return &ActivityLog_FieldTerminalPathValue{ActivityLog_FieldTerminalPath: *fp, value: value.(map[string]string)}
	case ActivityLog_FieldPathSelectorEvents:
		return &ActivityLog_FieldTerminalPathValue{ActivityLog_FieldTerminalPath: *fp, value: value.([]*ActivityLog_Event)}
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog: %d", fp.selector))
	}
}

func (fp *ActivityLog_FieldTerminalPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
	return fp.WithIValue(value)
}

func (fp *ActivityLog_FieldTerminalPath) WithIArrayOfValues(values interface{}) ActivityLog_FieldPathArrayOfValues {
	fpaov := &ActivityLog_FieldTerminalPathArrayOfValues{ActivityLog_FieldTerminalPath: *fp}
	switch fp.selector {
	case ActivityLog_FieldPathSelectorName:
		return &ActivityLog_FieldTerminalPathArrayOfValues{ActivityLog_FieldTerminalPath: *fp, values: values.([]*Name)}
	case ActivityLog_FieldPathSelectorScope:
		return &ActivityLog_FieldTerminalPathArrayOfValues{ActivityLog_FieldTerminalPath: *fp, values: values.([]string)}
	case ActivityLog_FieldPathSelectorRequestId:
		return &ActivityLog_FieldTerminalPathArrayOfValues{ActivityLog_FieldTerminalPath: *fp, values: values.([]uint64)}
	case ActivityLog_FieldPathSelectorAuthentication:
		return &ActivityLog_FieldTerminalPathArrayOfValues{ActivityLog_FieldTerminalPath: *fp, values: values.([]*common.Authentication)}
	case ActivityLog_FieldPathSelectorAuthorization:
		return &ActivityLog_FieldTerminalPathArrayOfValues{ActivityLog_FieldTerminalPath: *fp, values: values.([]*common.Authorization)}
	case ActivityLog_FieldPathSelectorService:
		return &ActivityLog_FieldTerminalPathArrayOfValues{ActivityLog_FieldTerminalPath: *fp, values: values.([]*common.ServiceData)}
	case ActivityLog_FieldPathSelectorMethod:
		return &ActivityLog_FieldTerminalPathArrayOfValues{ActivityLog_FieldTerminalPath: *fp, values: values.([]*ActivityLog_Method)}
	case ActivityLog_FieldPathSelectorRequestMetadata:
		return &ActivityLog_FieldTerminalPathArrayOfValues{ActivityLog_FieldTerminalPath: *fp, values: values.([]*ActivityLog_RequestMetadata)}
	case ActivityLog_FieldPathSelectorRequestRouting:
		return &ActivityLog_FieldTerminalPathArrayOfValues{ActivityLog_FieldTerminalPath: *fp, values: values.([]*ActivityLog_RequestRouting)}
	case ActivityLog_FieldPathSelectorResource:
		return &ActivityLog_FieldTerminalPathArrayOfValues{ActivityLog_FieldTerminalPath: *fp, values: values.([]*ActivityLog_Resource)}
	case ActivityLog_FieldPathSelectorCategory:
		return &ActivityLog_FieldTerminalPathArrayOfValues{ActivityLog_FieldTerminalPath: *fp, values: values.([]ActivityLog_Category)}
	case ActivityLog_FieldPathSelectorLabels:
		return &ActivityLog_FieldTerminalPathArrayOfValues{ActivityLog_FieldTerminalPath: *fp, values: values.([]map[string]string)}
	case ActivityLog_FieldPathSelectorEvents:
		return &ActivityLog_FieldTerminalPathArrayOfValues{ActivityLog_FieldTerminalPath: *fp, values: values.([][]*ActivityLog_Event)}
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog: %d", fp.selector))
	}
	return fpaov
}

func (fp *ActivityLog_FieldTerminalPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
	return fp.WithIArrayOfValues(values)
}

func (fp *ActivityLog_FieldTerminalPath) WithIArrayItemValue(value interface{}) ActivityLog_FieldPathArrayItemValue {
	switch fp.selector {
	case ActivityLog_FieldPathSelectorEvents:
		return &ActivityLog_FieldTerminalPathArrayItemValue{ActivityLog_FieldTerminalPath: *fp, value: value.(*ActivityLog_Event)}
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog: %d", fp.selector))
	}
}

func (fp *ActivityLog_FieldTerminalPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
	return fp.WithIArrayItemValue(value)
}

// FieldPath for map type with additional Key information
type ActivityLog_FieldPathMap struct {
	key      string
	selector ActivityLog_FieldPathSelector
}

var _ ActivityLog_FieldPath = (*ActivityLog_FieldPathMap)(nil)

func (fpm *ActivityLog_FieldPathMap) Selector() ActivityLog_FieldPathSelector {
	return fpm.selector
}

func (fpm *ActivityLog_FieldPathMap) Key() string {
	return fpm.key
}

// String returns path representation in proto convention
func (fpm *ActivityLog_FieldPathMap) String() string {
	return fpm.selector.String() + "." + fpm.key
}

// JSONString returns path representation is JSON convention. Note that map keys are not transformed
func (fpm *ActivityLog_FieldPathMap) JSONString() string {
	return strcase.ToLowerCamel(fpm.selector.String()) + "." + fpm.key
}

// Get returns all values pointed by selected field map key from source ActivityLog
func (fpm *ActivityLog_FieldPathMap) Get(source *ActivityLog) (values []interface{}) {
	switch fpm.selector {
	case ActivityLog_FieldPathSelectorLabels:
		if value, ok := source.GetLabels()[fpm.key]; ok {
			values = append(values, value)
		}
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog: %d", fpm.selector))
	}
	return
}

func (fpm *ActivityLog_FieldPathMap) GetRaw(source proto.Message) []interface{} {
	return fpm.Get(source.(*ActivityLog))
}

// GetSingle returns value by selected field map key from source ActivityLog
func (fpm *ActivityLog_FieldPathMap) GetSingle(source *ActivityLog) (interface{}, bool) {
	switch fpm.selector {
	case ActivityLog_FieldPathSelectorLabels:
		res, ok := source.GetLabels()[fpm.key]
		return res, ok
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog: %d", fpm.selector))
	}
}

func (fpm *ActivityLog_FieldPathMap) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fpm.GetSingle(source.(*ActivityLog))
}

// GetDefault returns a default value of the field type
func (fpm *ActivityLog_FieldPathMap) GetDefault() interface{} {
	switch fpm.selector {
	case ActivityLog_FieldPathSelectorLabels:
		var v string
		return v
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog: %d", fpm.selector))
	}
}

func (fpm *ActivityLog_FieldPathMap) ClearValue(item *ActivityLog) {
	if item != nil {
		switch fpm.selector {
		case ActivityLog_FieldPathSelectorLabels:
			delete(item.Labels, fpm.key)
		default:
			panic(fmt.Sprintf("Invalid selector for ActivityLog: %d", fpm.selector))
		}
	}
}

func (fpm *ActivityLog_FieldPathMap) ClearValueRaw(item proto.Message) {
	fpm.ClearValue(item.(*ActivityLog))
}

// IsLeaf - whether field path is holds simple value
func (fpm *ActivityLog_FieldPathMap) IsLeaf() bool {
	switch fpm.selector {
	case ActivityLog_FieldPathSelectorLabels:
		return true
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog: %d", fpm.selector))
	}
}

func (fpm *ActivityLog_FieldPathMap) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
	return []gotenobject.FieldPath{fpm}
}

func (fpm *ActivityLog_FieldPathMap) WithIValue(value interface{}) ActivityLog_FieldPathValue {
	switch fpm.selector {
	case ActivityLog_FieldPathSelectorLabels:
		return &ActivityLog_FieldPathMapValue{ActivityLog_FieldPathMap: *fpm, value: value.(string)}
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog: %d", fpm.selector))
	}
}

func (fpm *ActivityLog_FieldPathMap) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
	return fpm.WithIValue(value)
}

func (fpm *ActivityLog_FieldPathMap) WithIArrayOfValues(values interface{}) ActivityLog_FieldPathArrayOfValues {
	switch fpm.selector {
	case ActivityLog_FieldPathSelectorLabels:
		return &ActivityLog_FieldPathMapArrayOfValues{ActivityLog_FieldPathMap: *fpm, values: values.([]string)}
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog: %d", fpm.selector))
	}
}

func (fpm *ActivityLog_FieldPathMap) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
	return fpm.WithIArrayOfValues(values)
}

func (fpm *ActivityLog_FieldPathMap) WithIArrayItemValue(value interface{}) ActivityLog_FieldPathArrayItemValue {
	panic("Cannot create array item value from map fieldpath")
}

func (fpm *ActivityLog_FieldPathMap) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
	return fpm.WithIArrayItemValue(value)
}

type ActivityLog_FieldSubPath struct {
	selector ActivityLog_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ ActivityLog_FieldPath = (*ActivityLog_FieldSubPath)(nil)

func (fps *ActivityLog_FieldSubPath) Selector() ActivityLog_FieldPathSelector {
	return fps.selector
}
func (fps *ActivityLog_FieldSubPath) AsAuthenticationSubPath() (common.Authentication_FieldPath, bool) {
	res, ok := fps.subPath.(common.Authentication_FieldPath)
	return res, ok
}
func (fps *ActivityLog_FieldSubPath) AsAuthorizationSubPath() (common.Authorization_FieldPath, bool) {
	res, ok := fps.subPath.(common.Authorization_FieldPath)
	return res, ok
}
func (fps *ActivityLog_FieldSubPath) AsServiceSubPath() (common.ServiceData_FieldPath, bool) {
	res, ok := fps.subPath.(common.ServiceData_FieldPath)
	return res, ok
}
func (fps *ActivityLog_FieldSubPath) AsMethodSubPath() (ActivityLogMethod_FieldPath, bool) {
	res, ok := fps.subPath.(ActivityLogMethod_FieldPath)
	return res, ok
}
func (fps *ActivityLog_FieldSubPath) AsRequestMetadataSubPath() (ActivityLogRequestMetadata_FieldPath, bool) {
	res, ok := fps.subPath.(ActivityLogRequestMetadata_FieldPath)
	return res, ok
}
func (fps *ActivityLog_FieldSubPath) AsRequestRoutingSubPath() (ActivityLogRequestRouting_FieldPath, bool) {
	res, ok := fps.subPath.(ActivityLogRequestRouting_FieldPath)
	return res, ok
}
func (fps *ActivityLog_FieldSubPath) AsResourceSubPath() (ActivityLogResource_FieldPath, bool) {
	res, ok := fps.subPath.(ActivityLogResource_FieldPath)
	return res, ok
}
func (fps *ActivityLog_FieldSubPath) AsEventsSubPath() (ActivityLogEvent_FieldPath, bool) {
	res, ok := fps.subPath.(ActivityLogEvent_FieldPath)
	return res, ok
}

// String returns path representation in proto convention
func (fps *ActivityLog_FieldSubPath) String() string {
	return fps.selector.String() + "." + fps.subPath.String()
}

// JSONString returns path representation is JSON convention
func (fps *ActivityLog_FieldSubPath) JSONString() string {
	return strcase.ToLowerCamel(fps.selector.String()) + "." + fps.subPath.JSONString()
}

// Get returns all values pointed by selected field from source ActivityLog
func (fps *ActivityLog_FieldSubPath) Get(source *ActivityLog) (values []interface{}) {
	switch fps.selector {
	case ActivityLog_FieldPathSelectorAuthentication:
		values = append(values, fps.subPath.GetRaw(source.GetAuthentication())...)
	case ActivityLog_FieldPathSelectorAuthorization:
		values = append(values, fps.subPath.GetRaw(source.GetAuthorization())...)
	case ActivityLog_FieldPathSelectorService:
		values = append(values, fps.subPath.GetRaw(source.GetService())...)
	case ActivityLog_FieldPathSelectorMethod:
		values = append(values, fps.subPath.GetRaw(source.GetMethod())...)
	case ActivityLog_FieldPathSelectorRequestMetadata:
		values = append(values, fps.subPath.GetRaw(source.GetRequestMetadata())...)
	case ActivityLog_FieldPathSelectorRequestRouting:
		values = append(values, fps.subPath.GetRaw(source.GetRequestRouting())...)
	case ActivityLog_FieldPathSelectorResource:
		values = append(values, fps.subPath.GetRaw(source.GetResource())...)
	case ActivityLog_FieldPathSelectorEvents:
		for _, item := range source.GetEvents() {
			values = append(values, fps.subPath.GetRaw(item)...)
		}
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog: %d", fps.selector))
	}
	return
}

func (fps *ActivityLog_FieldSubPath) GetRaw(source proto.Message) []interface{} {
	return fps.Get(source.(*ActivityLog))
}

// GetSingle returns value of selected field from source ActivityLog
func (fps *ActivityLog_FieldSubPath) GetSingle(source *ActivityLog) (interface{}, bool) {
	switch fps.selector {
	case ActivityLog_FieldPathSelectorAuthentication:
		if source.GetAuthentication() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetAuthentication())
	case ActivityLog_FieldPathSelectorAuthorization:
		if source.GetAuthorization() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetAuthorization())
	case ActivityLog_FieldPathSelectorService:
		if source.GetService() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetService())
	case ActivityLog_FieldPathSelectorMethod:
		if source.GetMethod() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetMethod())
	case ActivityLog_FieldPathSelectorRequestMetadata:
		if source.GetRequestMetadata() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetRequestMetadata())
	case ActivityLog_FieldPathSelectorRequestRouting:
		if source.GetRequestRouting() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetRequestRouting())
	case ActivityLog_FieldPathSelectorResource:
		if source.GetResource() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetResource())
	case ActivityLog_FieldPathSelectorEvents:
		if len(source.GetEvents()) == 0 {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetEvents()[0])
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog: %d", fps.selector))
	}
}

func (fps *ActivityLog_FieldSubPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fps.GetSingle(source.(*ActivityLog))
}

// GetDefault returns a default value of the field type
func (fps *ActivityLog_FieldSubPath) GetDefault() interface{} {
	return fps.subPath.GetDefault()
}

func (fps *ActivityLog_FieldSubPath) ClearValue(item *ActivityLog) {
	if item != nil {
		switch fps.selector {
		case ActivityLog_FieldPathSelectorAuthentication:
			fps.subPath.ClearValueRaw(item.Authentication)
		case ActivityLog_FieldPathSelectorAuthorization:
			fps.subPath.ClearValueRaw(item.Authorization)
		case ActivityLog_FieldPathSelectorService:
			fps.subPath.ClearValueRaw(item.Service)
		case ActivityLog_FieldPathSelectorMethod:
			fps.subPath.ClearValueRaw(item.Method)
		case ActivityLog_FieldPathSelectorRequestMetadata:
			fps.subPath.ClearValueRaw(item.RequestMetadata)
		case ActivityLog_FieldPathSelectorRequestRouting:
			fps.subPath.ClearValueRaw(item.RequestRouting)
		case ActivityLog_FieldPathSelectorResource:
			fps.subPath.ClearValueRaw(item.Resource)
		case ActivityLog_FieldPathSelectorEvents:
			for _, subItem := range item.Events {
				fps.subPath.ClearValueRaw(subItem)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for ActivityLog: %d", fps.selector))
		}
	}
}

func (fps *ActivityLog_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*ActivityLog))
}

// IsLeaf - whether field path is holds simple value
func (fps *ActivityLog_FieldSubPath) IsLeaf() bool {
	return fps.subPath.IsLeaf()
}

func (fps *ActivityLog_FieldSubPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
	iPaths := []gotenobject.FieldPath{&ActivityLog_FieldTerminalPath{selector: fps.selector}}
	iPaths = append(iPaths, fps.subPath.SplitIntoTerminalIPaths()...)
	return iPaths
}

func (fps *ActivityLog_FieldSubPath) WithIValue(value interface{}) ActivityLog_FieldPathValue {
	return &ActivityLog_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

func (fps *ActivityLog_FieldSubPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
	return fps.WithIValue(value)
}

func (fps *ActivityLog_FieldSubPath) WithIArrayOfValues(values interface{}) ActivityLog_FieldPathArrayOfValues {
	return &ActivityLog_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

func (fps *ActivityLog_FieldSubPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
	return fps.WithIArrayOfValues(values)
}

func (fps *ActivityLog_FieldSubPath) WithIArrayItemValue(value interface{}) ActivityLog_FieldPathArrayItemValue {
	return &ActivityLog_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

func (fps *ActivityLog_FieldSubPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
	return fps.WithIArrayItemValue(value)
}

// ActivityLog_FieldPathValue allows storing values for ActivityLog fields according to their type
type ActivityLog_FieldPathValue interface {
	ActivityLog_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **ActivityLog)
	CompareWith(*ActivityLog) (cmp int, comparable bool)
}

func ParseActivityLog_FieldPathValue(pathStr, valueStr string) (ActivityLog_FieldPathValue, error) {
	fp, err := ParseActivityLog_FieldPath(pathStr)
	if err != nil {
		return nil, err
	}
	fpv, err := gotenobject.ParseFieldPathValue(fp, valueStr)
	if err != nil {
		return nil, status.Errorf(codes.InvalidArgument, "error parsing ActivityLog field path value from %s: %v", valueStr, err)
	}
	return fpv.(ActivityLog_FieldPathValue), nil
}

func MustParseActivityLog_FieldPathValue(pathStr, valueStr string) ActivityLog_FieldPathValue {
	fpv, err := ParseActivityLog_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type ActivityLog_FieldTerminalPathValue struct {
	ActivityLog_FieldTerminalPath
	value interface{}
}

var _ ActivityLog_FieldPathValue = (*ActivityLog_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'ActivityLog' as interface{}
func (fpv *ActivityLog_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *ActivityLog_FieldTerminalPathValue) AsNameValue() (*Name, bool) {
	res, ok := fpv.value.(*Name)
	return res, ok
}
func (fpv *ActivityLog_FieldTerminalPathValue) AsScopeValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *ActivityLog_FieldTerminalPathValue) AsRequestIdValue() (uint64, bool) {
	res, ok := fpv.value.(uint64)
	return res, ok
}
func (fpv *ActivityLog_FieldTerminalPathValue) AsAuthenticationValue() (*common.Authentication, bool) {
	res, ok := fpv.value.(*common.Authentication)
	return res, ok
}
func (fpv *ActivityLog_FieldTerminalPathValue) AsAuthorizationValue() (*common.Authorization, bool) {
	res, ok := fpv.value.(*common.Authorization)
	return res, ok
}
func (fpv *ActivityLog_FieldTerminalPathValue) AsServiceValue() (*common.ServiceData, bool) {
	res, ok := fpv.value.(*common.ServiceData)
	return res, ok
}
func (fpv *ActivityLog_FieldTerminalPathValue) AsMethodValue() (*ActivityLog_Method, bool) {
	res, ok := fpv.value.(*ActivityLog_Method)
	return res, ok
}
func (fpv *ActivityLog_FieldTerminalPathValue) AsRequestMetadataValue() (*ActivityLog_RequestMetadata, bool) {
	res, ok := fpv.value.(*ActivityLog_RequestMetadata)
	return res, ok
}
func (fpv *ActivityLog_FieldTerminalPathValue) AsRequestRoutingValue() (*ActivityLog_RequestRouting, bool) {
	res, ok := fpv.value.(*ActivityLog_RequestRouting)
	return res, ok
}
func (fpv *ActivityLog_FieldTerminalPathValue) AsResourceValue() (*ActivityLog_Resource, bool) {
	res, ok := fpv.value.(*ActivityLog_Resource)
	return res, ok
}
func (fpv *ActivityLog_FieldTerminalPathValue) AsCategoryValue() (ActivityLog_Category, bool) {
	res, ok := fpv.value.(ActivityLog_Category)
	return res, ok
}
func (fpv *ActivityLog_FieldTerminalPathValue) AsLabelsValue() (map[string]string, bool) {
	res, ok := fpv.value.(map[string]string)
	return res, ok
}
func (fpv *ActivityLog_FieldTerminalPathValue) AsEventsValue() ([]*ActivityLog_Event, bool) {
	res, ok := fpv.value.([]*ActivityLog_Event)
	return res, ok
}

// SetTo stores value for selected field for object ActivityLog
func (fpv *ActivityLog_FieldTerminalPathValue) SetTo(target **ActivityLog) {
	if *target == nil {
		*target = new(ActivityLog)
	}
	switch fpv.selector {
	case ActivityLog_FieldPathSelectorName:
		(*target).Name = fpv.value.(*Name)
	case ActivityLog_FieldPathSelectorScope:
		(*target).Scope = fpv.value.(string)
	case ActivityLog_FieldPathSelectorRequestId:
		(*target).RequestId = fpv.value.(uint64)
	case ActivityLog_FieldPathSelectorAuthentication:
		(*target).Authentication = fpv.value.(*common.Authentication)
	case ActivityLog_FieldPathSelectorAuthorization:
		(*target).Authorization = fpv.value.(*common.Authorization)
	case ActivityLog_FieldPathSelectorService:
		(*target).Service = fpv.value.(*common.ServiceData)
	case ActivityLog_FieldPathSelectorMethod:
		(*target).Method = fpv.value.(*ActivityLog_Method)
	case ActivityLog_FieldPathSelectorRequestMetadata:
		(*target).RequestMetadata = fpv.value.(*ActivityLog_RequestMetadata)
	case ActivityLog_FieldPathSelectorRequestRouting:
		(*target).RequestRouting = fpv.value.(*ActivityLog_RequestRouting)
	case ActivityLog_FieldPathSelectorResource:
		(*target).Resource = fpv.value.(*ActivityLog_Resource)
	case ActivityLog_FieldPathSelectorCategory:
		(*target).Category = fpv.value.(ActivityLog_Category)
	case ActivityLog_FieldPathSelectorLabels:
		(*target).Labels = fpv.value.(map[string]string)
	case ActivityLog_FieldPathSelectorEvents:
		(*target).Events = fpv.value.([]*ActivityLog_Event)
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog: %d", fpv.selector))
	}
}

func (fpv *ActivityLog_FieldTerminalPathValue) SetToRaw(target proto.Message) {
	typedObject := target.(*ActivityLog)
	fpv.SetTo(&typedObject)
}

// CompareWith compares value in the 'ActivityLog_FieldTerminalPathValue' with the value under path in 'ActivityLog'.
func (fpv *ActivityLog_FieldTerminalPathValue) CompareWith(source *ActivityLog) (int, bool) {
	switch fpv.selector {
	case ActivityLog_FieldPathSelectorName:
		leftValue := fpv.value.(*Name)
		rightValue := source.GetName()
		if leftValue == nil {
			if rightValue != nil {
				return -1, true
			}
			return 0, true
		}
		if rightValue == nil {
			return 1, true
		}
		if leftValue.String() == rightValue.String() {
			return 0, true
		} else if leftValue.String() < rightValue.String() {
			return -1, true
		} else {
			return 1, true
		}
	case ActivityLog_FieldPathSelectorScope:
		leftValue := fpv.value.(string)
		rightValue := source.GetScope()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case ActivityLog_FieldPathSelectorRequestId:
		leftValue := fpv.value.(uint64)
		rightValue := source.GetRequestId()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case ActivityLog_FieldPathSelectorAuthentication:
		return 0, false
	case ActivityLog_FieldPathSelectorAuthorization:
		return 0, false
	case ActivityLog_FieldPathSelectorService:
		return 0, false
	case ActivityLog_FieldPathSelectorMethod:
		return 0, false
	case ActivityLog_FieldPathSelectorRequestMetadata:
		return 0, false
	case ActivityLog_FieldPathSelectorRequestRouting:
		return 0, false
	case ActivityLog_FieldPathSelectorResource:
		return 0, false
	case ActivityLog_FieldPathSelectorCategory:
		leftValue := fpv.value.(ActivityLog_Category)
		rightValue := source.GetCategory()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case ActivityLog_FieldPathSelectorLabels:
		return 0, false
	case ActivityLog_FieldPathSelectorEvents:
		return 0, false
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog: %d", fpv.selector))
	}
}

func (fpv *ActivityLog_FieldTerminalPathValue) CompareWithRaw(source proto.Message) (int, bool) {
	return fpv.CompareWith(source.(*ActivityLog))
}

type ActivityLog_FieldPathMapValue struct {
	ActivityLog_FieldPathMap
	value interface{}
}

var _ ActivityLog_FieldPathValue = (*ActivityLog_FieldPathMapValue)(nil)

// GetValue returns value stored under selected field in ActivityLog as interface{}
func (fpmv *ActivityLog_FieldPathMapValue) GetRawValue() interface{} {
	return fpmv.value
}
func (fpmv *ActivityLog_FieldPathMapValue) AsLabelsElementValue() (string, bool) {
	res, ok := fpmv.value.(string)
	return res, ok
}

// SetTo stores value for selected field in ActivityLog
func (fpmv *ActivityLog_FieldPathMapValue) SetTo(target **ActivityLog) {
	if *target == nil {
		*target = new(ActivityLog)
	}
	switch fpmv.selector {
	case ActivityLog_FieldPathSelectorLabels:
		if (*target).Labels == nil {
			(*target).Labels = make(map[string]string)
		}
		(*target).Labels[fpmv.key] = fpmv.value.(string)
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog: %d", fpmv.selector))
	}
}

func (fpmv *ActivityLog_FieldPathMapValue) SetToRaw(target proto.Message) {
	typedObject := target.(*ActivityLog)
	fpmv.SetTo(&typedObject)
}

// CompareWith compares value in the 'ActivityLog_FieldPathMapValue' with the value under path in 'ActivityLog'.
func (fpmv *ActivityLog_FieldPathMapValue) CompareWith(source *ActivityLog) (int, bool) {
	switch fpmv.selector {
	case ActivityLog_FieldPathSelectorLabels:
		leftValue := fpmv.value.(string)
		rightValue := source.GetLabels()[fpmv.key]
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog: %d", fpmv.selector))
	}
}

func (fpmv *ActivityLog_FieldPathMapValue) CompareWithRaw(source proto.Message) (int, bool) {
	return fpmv.CompareWith(source.(*ActivityLog))
}

type ActivityLog_FieldSubPathValue struct {
	ActivityLog_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ ActivityLog_FieldPathValue = (*ActivityLog_FieldSubPathValue)(nil)

func (fpvs *ActivityLog_FieldSubPathValue) AsAuthenticationPathValue() (common.Authentication_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(common.Authentication_FieldPathValue)
	return res, ok
}
func (fpvs *ActivityLog_FieldSubPathValue) AsAuthorizationPathValue() (common.Authorization_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(common.Authorization_FieldPathValue)
	return res, ok
}
func (fpvs *ActivityLog_FieldSubPathValue) AsServicePathValue() (common.ServiceData_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(common.ServiceData_FieldPathValue)
	return res, ok
}
func (fpvs *ActivityLog_FieldSubPathValue) AsMethodPathValue() (ActivityLogMethod_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(ActivityLogMethod_FieldPathValue)
	return res, ok
}
func (fpvs *ActivityLog_FieldSubPathValue) AsRequestMetadataPathValue() (ActivityLogRequestMetadata_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(ActivityLogRequestMetadata_FieldPathValue)
	return res, ok
}
func (fpvs *ActivityLog_FieldSubPathValue) AsRequestRoutingPathValue() (ActivityLogRequestRouting_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(ActivityLogRequestRouting_FieldPathValue)
	return res, ok
}
func (fpvs *ActivityLog_FieldSubPathValue) AsResourcePathValue() (ActivityLogResource_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(ActivityLogResource_FieldPathValue)
	return res, ok
}
func (fpvs *ActivityLog_FieldSubPathValue) AsEventsPathValue() (ActivityLogEvent_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(ActivityLogEvent_FieldPathValue)
	return res, ok
}

func (fpvs *ActivityLog_FieldSubPathValue) SetTo(target **ActivityLog) {
	if *target == nil {
		*target = new(ActivityLog)
	}
	switch fpvs.Selector() {
	case ActivityLog_FieldPathSelectorAuthentication:
		fpvs.subPathValue.(common.Authentication_FieldPathValue).SetTo(&(*target).Authentication)
	case ActivityLog_FieldPathSelectorAuthorization:
		fpvs.subPathValue.(common.Authorization_FieldPathValue).SetTo(&(*target).Authorization)
	case ActivityLog_FieldPathSelectorService:
		fpvs.subPathValue.(common.ServiceData_FieldPathValue).SetTo(&(*target).Service)
	case ActivityLog_FieldPathSelectorMethod:
		fpvs.subPathValue.(ActivityLogMethod_FieldPathValue).SetTo(&(*target).Method)
	case ActivityLog_FieldPathSelectorRequestMetadata:
		fpvs.subPathValue.(ActivityLogRequestMetadata_FieldPathValue).SetTo(&(*target).RequestMetadata)
	case ActivityLog_FieldPathSelectorRequestRouting:
		fpvs.subPathValue.(ActivityLogRequestRouting_FieldPathValue).SetTo(&(*target).RequestRouting)
	case ActivityLog_FieldPathSelectorResource:
		fpvs.subPathValue.(ActivityLogResource_FieldPathValue).SetTo(&(*target).Resource)
	case ActivityLog_FieldPathSelectorEvents:
		panic("FieldPath setter is unsupported for array subpaths")
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog: %d", fpvs.Selector()))
	}
}

func (fpvs *ActivityLog_FieldSubPathValue) SetToRaw(target proto.Message) {
	typedObject := target.(*ActivityLog)
	fpvs.SetTo(&typedObject)
}

func (fpvs *ActivityLog_FieldSubPathValue) GetRawValue() interface{} {
	return fpvs.subPathValue.GetRawValue()
}

func (fpvs *ActivityLog_FieldSubPathValue) CompareWith(source *ActivityLog) (int, bool) {
	switch fpvs.Selector() {
	case ActivityLog_FieldPathSelectorAuthentication:
		return fpvs.subPathValue.(common.Authentication_FieldPathValue).CompareWith(source.GetAuthentication())
	case ActivityLog_FieldPathSelectorAuthorization:
		return fpvs.subPathValue.(common.Authorization_FieldPathValue).CompareWith(source.GetAuthorization())
	case ActivityLog_FieldPathSelectorService:
		return fpvs.subPathValue.(common.ServiceData_FieldPathValue).CompareWith(source.GetService())
	case ActivityLog_FieldPathSelectorMethod:
		return fpvs.subPathValue.(ActivityLogMethod_FieldPathValue).CompareWith(source.GetMethod())
	case ActivityLog_FieldPathSelectorRequestMetadata:
		return fpvs.subPathValue.(ActivityLogRequestMetadata_FieldPathValue).CompareWith(source.GetRequestMetadata())
	case ActivityLog_FieldPathSelectorRequestRouting:
		return fpvs.subPathValue.(ActivityLogRequestRouting_FieldPathValue).CompareWith(source.GetRequestRouting())
	case ActivityLog_FieldPathSelectorResource:
		return fpvs.subPathValue.(ActivityLogResource_FieldPathValue).CompareWith(source.GetResource())
	case ActivityLog_FieldPathSelectorEvents:
		return 0, false // repeated field
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog: %d", fpvs.Selector()))
	}
}

func (fpvs *ActivityLog_FieldSubPathValue) CompareWithRaw(source proto.Message) (int, bool) {
	return fpvs.CompareWith(source.(*ActivityLog))
}

// ActivityLog_FieldPathArrayItemValue allows storing single item in Path-specific values for ActivityLog according to their type
// Present only for array (repeated) types.
type ActivityLog_FieldPathArrayItemValue interface {
	gotenobject.FieldPathArrayItemValue
	ActivityLog_FieldPath
	ContainsValue(*ActivityLog) bool
}

// ParseActivityLog_FieldPathArrayItemValue parses string and JSON-encoded value to its Value
func ParseActivityLog_FieldPathArrayItemValue(pathStr, valueStr string) (ActivityLog_FieldPathArrayItemValue, error) {
	fp, err := ParseActivityLog_FieldPath(pathStr)
	if err != nil {
		return nil, err
	}
	fpaiv, err := gotenobject.ParseFieldPathArrayItemValue(fp, valueStr)
	if err != nil {
		return nil, status.Errorf(codes.InvalidArgument, "error parsing ActivityLog field path array item value from %s: %v", valueStr, err)
	}
	return fpaiv.(ActivityLog_FieldPathArrayItemValue), nil
}

func MustParseActivityLog_FieldPathArrayItemValue(pathStr, valueStr string) ActivityLog_FieldPathArrayItemValue {
	fpaiv, err := ParseActivityLog_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type ActivityLog_FieldTerminalPathArrayItemValue struct {
	ActivityLog_FieldTerminalPath
	value interface{}
}

var _ ActivityLog_FieldPathArrayItemValue = (*ActivityLog_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object ActivityLog as interface{}
func (fpaiv *ActivityLog_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}
func (fpaiv *ActivityLog_FieldTerminalPathArrayItemValue) AsEventsItemValue() (*ActivityLog_Event, bool) {
	res, ok := fpaiv.value.(*ActivityLog_Event)
	return res, ok
}

func (fpaiv *ActivityLog_FieldTerminalPathArrayItemValue) GetSingle(source *ActivityLog) (interface{}, bool) {
	return nil, false
}

func (fpaiv *ActivityLog_FieldTerminalPathArrayItemValue) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fpaiv.GetSingle(source.(*ActivityLog))
}

// Contains returns a boolean indicating if value that is being held is present in given 'ActivityLog'
func (fpaiv *ActivityLog_FieldTerminalPathArrayItemValue) ContainsValue(source *ActivityLog) bool {
	slice := fpaiv.ActivityLog_FieldTerminalPath.Get(source)
	for _, v := range slice {
		if asProtoMsg, ok := fpaiv.value.(proto.Message); ok {
			if proto.Equal(asProtoMsg, v.(proto.Message)) {
				return true
			}
		} else if reflect.DeepEqual(v, fpaiv.value) {
			return true
		}
	}
	return false
}

type ActivityLog_FieldSubPathArrayItemValue struct {
	ActivityLog_FieldPath
	subPathItemValue gotenobject.FieldPathArrayItemValue
}

// GetRawValue returns stored array item value
func (fpaivs *ActivityLog_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *ActivityLog_FieldSubPathArrayItemValue) AsAuthenticationPathItemValue() (common.Authentication_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(common.Authentication_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *ActivityLog_FieldSubPathArrayItemValue) AsAuthorizationPathItemValue() (common.Authorization_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(common.Authorization_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *ActivityLog_FieldSubPathArrayItemValue) AsServicePathItemValue() (common.ServiceData_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(common.ServiceData_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *ActivityLog_FieldSubPathArrayItemValue) AsMethodPathItemValue() (ActivityLogMethod_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(ActivityLogMethod_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *ActivityLog_FieldSubPathArrayItemValue) AsRequestMetadataPathItemValue() (ActivityLogRequestMetadata_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(ActivityLogRequestMetadata_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *ActivityLog_FieldSubPathArrayItemValue) AsRequestRoutingPathItemValue() (ActivityLogRequestRouting_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(ActivityLogRequestRouting_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *ActivityLog_FieldSubPathArrayItemValue) AsResourcePathItemValue() (ActivityLogResource_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(ActivityLogResource_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *ActivityLog_FieldSubPathArrayItemValue) AsEventsPathItemValue() (ActivityLogEvent_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(ActivityLogEvent_FieldPathArrayItemValue)
	return res, ok
}

// Contains returns a boolean indicating if value that is being held is present in given 'ActivityLog'
func (fpaivs *ActivityLog_FieldSubPathArrayItemValue) ContainsValue(source *ActivityLog) bool {
	switch fpaivs.Selector() {
	case ActivityLog_FieldPathSelectorAuthentication:
		return fpaivs.subPathItemValue.(common.Authentication_FieldPathArrayItemValue).ContainsValue(source.GetAuthentication())
	case ActivityLog_FieldPathSelectorAuthorization:
		return fpaivs.subPathItemValue.(common.Authorization_FieldPathArrayItemValue).ContainsValue(source.GetAuthorization())
	case ActivityLog_FieldPathSelectorService:
		return fpaivs.subPathItemValue.(common.ServiceData_FieldPathArrayItemValue).ContainsValue(source.GetService())
	case ActivityLog_FieldPathSelectorMethod:
		return fpaivs.subPathItemValue.(ActivityLogMethod_FieldPathArrayItemValue).ContainsValue(source.GetMethod())
	case ActivityLog_FieldPathSelectorRequestMetadata:
		return fpaivs.subPathItemValue.(ActivityLogRequestMetadata_FieldPathArrayItemValue).ContainsValue(source.GetRequestMetadata())
	case ActivityLog_FieldPathSelectorRequestRouting:
		return fpaivs.subPathItemValue.(ActivityLogRequestRouting_FieldPathArrayItemValue).ContainsValue(source.GetRequestRouting())
	case ActivityLog_FieldPathSelectorResource:
		return fpaivs.subPathItemValue.(ActivityLogResource_FieldPathArrayItemValue).ContainsValue(source.GetResource())
	case ActivityLog_FieldPathSelectorEvents:
		return false // repeated/map field
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog: %d", fpaivs.Selector()))
	}
}

// ActivityLog_FieldPathArrayOfValues allows storing slice of values for ActivityLog fields according to their type
type ActivityLog_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	ActivityLog_FieldPath
}

func ParseActivityLog_FieldPathArrayOfValues(pathStr, valuesStr string) (ActivityLog_FieldPathArrayOfValues, error) {
	fp, err := ParseActivityLog_FieldPath(pathStr)
	if err != nil {
		return nil, err
	}
	fpaov, err := gotenobject.ParseFieldPathArrayOfValues(fp, valuesStr)
	if err != nil {
		return nil, status.Errorf(codes.InvalidArgument, "error parsing ActivityLog field path array of values from %s: %v", valuesStr, err)
	}
	return fpaov.(ActivityLog_FieldPathArrayOfValues), nil
}

func MustParseActivityLog_FieldPathArrayOfValues(pathStr, valuesStr string) ActivityLog_FieldPathArrayOfValues {
	fpaov, err := ParseActivityLog_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type ActivityLog_FieldTerminalPathArrayOfValues struct {
	ActivityLog_FieldTerminalPath
	values interface{}
}

var _ ActivityLog_FieldPathArrayOfValues = (*ActivityLog_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *ActivityLog_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case ActivityLog_FieldPathSelectorName:
		for _, v := range fpaov.values.([]*Name) {
			values = append(values, v)
		}
	case ActivityLog_FieldPathSelectorScope:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case ActivityLog_FieldPathSelectorRequestId:
		for _, v := range fpaov.values.([]uint64) {
			values = append(values, v)
		}
	case ActivityLog_FieldPathSelectorAuthentication:
		for _, v := range fpaov.values.([]*common.Authentication) {
			values = append(values, v)
		}
	case ActivityLog_FieldPathSelectorAuthorization:
		for _, v := range fpaov.values.([]*common.Authorization) {
			values = append(values, v)
		}
	case ActivityLog_FieldPathSelectorService:
		for _, v := range fpaov.values.([]*common.ServiceData) {
			values = append(values, v)
		}
	case ActivityLog_FieldPathSelectorMethod:
		for _, v := range fpaov.values.([]*ActivityLog_Method) {
			values = append(values, v)
		}
	case ActivityLog_FieldPathSelectorRequestMetadata:
		for _, v := range fpaov.values.([]*ActivityLog_RequestMetadata) {
			values = append(values, v)
		}
	case ActivityLog_FieldPathSelectorRequestRouting:
		for _, v := range fpaov.values.([]*ActivityLog_RequestRouting) {
			values = append(values, v)
		}
	case ActivityLog_FieldPathSelectorResource:
		for _, v := range fpaov.values.([]*ActivityLog_Resource) {
			values = append(values, v)
		}
	case ActivityLog_FieldPathSelectorCategory:
		for _, v := range fpaov.values.([]ActivityLog_Category) {
			values = append(values, v)
		}
	case ActivityLog_FieldPathSelectorLabels:
		for _, v := range fpaov.values.([]map[string]string) {
			values = append(values, v)
		}
	case ActivityLog_FieldPathSelectorEvents:
		for _, v := range fpaov.values.([][]*ActivityLog_Event) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *ActivityLog_FieldTerminalPathArrayOfValues) AsNameArrayOfValues() ([]*Name, bool) {
	res, ok := fpaov.values.([]*Name)
	return res, ok
}
func (fpaov *ActivityLog_FieldTerminalPathArrayOfValues) AsScopeArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *ActivityLog_FieldTerminalPathArrayOfValues) AsRequestIdArrayOfValues() ([]uint64, bool) {
	res, ok := fpaov.values.([]uint64)
	return res, ok
}
func (fpaov *ActivityLog_FieldTerminalPathArrayOfValues) AsAuthenticationArrayOfValues() ([]*common.Authentication, bool) {
	res, ok := fpaov.values.([]*common.Authentication)
	return res, ok
}
func (fpaov *ActivityLog_FieldTerminalPathArrayOfValues) AsAuthorizationArrayOfValues() ([]*common.Authorization, bool) {
	res, ok := fpaov.values.([]*common.Authorization)
	return res, ok
}
func (fpaov *ActivityLog_FieldTerminalPathArrayOfValues) AsServiceArrayOfValues() ([]*common.ServiceData, bool) {
	res, ok := fpaov.values.([]*common.ServiceData)
	return res, ok
}
func (fpaov *ActivityLog_FieldTerminalPathArrayOfValues) AsMethodArrayOfValues() ([]*ActivityLog_Method, bool) {
	res, ok := fpaov.values.([]*ActivityLog_Method)
	return res, ok
}
func (fpaov *ActivityLog_FieldTerminalPathArrayOfValues) AsRequestMetadataArrayOfValues() ([]*ActivityLog_RequestMetadata, bool) {
	res, ok := fpaov.values.([]*ActivityLog_RequestMetadata)
	return res, ok
}
func (fpaov *ActivityLog_FieldTerminalPathArrayOfValues) AsRequestRoutingArrayOfValues() ([]*ActivityLog_RequestRouting, bool) {
	res, ok := fpaov.values.([]*ActivityLog_RequestRouting)
	return res, ok
}
func (fpaov *ActivityLog_FieldTerminalPathArrayOfValues) AsResourceArrayOfValues() ([]*ActivityLog_Resource, bool) {
	res, ok := fpaov.values.([]*ActivityLog_Resource)
	return res, ok
}
func (fpaov *ActivityLog_FieldTerminalPathArrayOfValues) AsCategoryArrayOfValues() ([]ActivityLog_Category, bool) {
	res, ok := fpaov.values.([]ActivityLog_Category)
	return res, ok
}
func (fpaov *ActivityLog_FieldTerminalPathArrayOfValues) AsLabelsArrayOfValues() ([]map[string]string, bool) {
	res, ok := fpaov.values.([]map[string]string)
	return res, ok
}
func (fpaov *ActivityLog_FieldTerminalPathArrayOfValues) AsEventsArrayOfValues() ([][]*ActivityLog_Event, bool) {
	res, ok := fpaov.values.([][]*ActivityLog_Event)
	return res, ok
}

type ActivityLog_FieldPathMapArrayOfValues struct {
	ActivityLog_FieldPathMap
	values interface{}
}

var _ ActivityLog_FieldPathArrayOfValues = (*ActivityLog_FieldPathMapArrayOfValues)(nil)

func (fpmaov *ActivityLog_FieldPathMapArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpmaov.selector {
	case ActivityLog_FieldPathSelectorLabels:
		for _, v := range fpmaov.values.([]string) {
			values = append(values, v)
		}
	}
	return
}
func (fpmaov *ActivityLog_FieldPathMapArrayOfValues) AsLabelsArrayOfElementValues() ([]string, bool) {
	res, ok := fpmaov.values.([]string)
	return res, ok
}

type ActivityLog_FieldSubPathArrayOfValues struct {
	ActivityLog_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ ActivityLog_FieldPathArrayOfValues = (*ActivityLog_FieldSubPathArrayOfValues)(nil)

func (fpsaov *ActivityLog_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *ActivityLog_FieldSubPathArrayOfValues) AsAuthenticationPathArrayOfValues() (common.Authentication_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(common.Authentication_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *ActivityLog_FieldSubPathArrayOfValues) AsAuthorizationPathArrayOfValues() (common.Authorization_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(common.Authorization_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *ActivityLog_FieldSubPathArrayOfValues) AsServicePathArrayOfValues() (common.ServiceData_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(common.ServiceData_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *ActivityLog_FieldSubPathArrayOfValues) AsMethodPathArrayOfValues() (ActivityLogMethod_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(ActivityLogMethod_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *ActivityLog_FieldSubPathArrayOfValues) AsRequestMetadataPathArrayOfValues() (ActivityLogRequestMetadata_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(ActivityLogRequestMetadata_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *ActivityLog_FieldSubPathArrayOfValues) AsRequestRoutingPathArrayOfValues() (ActivityLogRequestRouting_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(ActivityLogRequestRouting_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *ActivityLog_FieldSubPathArrayOfValues) AsResourcePathArrayOfValues() (ActivityLogResource_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(ActivityLogResource_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *ActivityLog_FieldSubPathArrayOfValues) AsEventsPathArrayOfValues() (ActivityLogEvent_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(ActivityLogEvent_FieldPathArrayOfValues)
	return res, ok
}

// FieldPath provides implementation to handle
// https://github.com/protocolbuffers/protobuf/blob/master/src/google/protobuf/field_mask.proto
type ActivityLogEvent_FieldPath interface {
	gotenobject.FieldPath
	Selector() ActivityLogEvent_FieldPathSelector
	Get(source *ActivityLog_Event) []interface{}
	GetSingle(source *ActivityLog_Event) (interface{}, bool)
	ClearValue(item *ActivityLog_Event)

	// Those methods build corresponding ActivityLogEvent_FieldPathValue
	// (or array of values) and holds passed value. Panics if injected type is incorrect.
	WithIValue(value interface{}) ActivityLogEvent_FieldPathValue
	WithIArrayOfValues(values interface{}) ActivityLogEvent_FieldPathArrayOfValues
	WithIArrayItemValue(value interface{}) ActivityLogEvent_FieldPathArrayItemValue
}

type ActivityLogEvent_FieldPathSelector int32

const (
	ActivityLogEvent_FieldPathSelectorClientMessage         ActivityLogEvent_FieldPathSelector = 0
	ActivityLogEvent_FieldPathSelectorServerMessage         ActivityLogEvent_FieldPathSelector = 1
	ActivityLogEvent_FieldPathSelectorExit                  ActivityLogEvent_FieldPathSelector = 2
	ActivityLogEvent_FieldPathSelectorRegionalServerMessage ActivityLogEvent_FieldPathSelector = 3
	ActivityLogEvent_FieldPathSelectorRegionalExit          ActivityLogEvent_FieldPathSelector = 4
)

func (s ActivityLogEvent_FieldPathSelector) String() string {
	switch s {
	case ActivityLogEvent_FieldPathSelectorClientMessage:
		return "client_message"
	case ActivityLogEvent_FieldPathSelectorServerMessage:
		return "server_message"
	case ActivityLogEvent_FieldPathSelectorExit:
		return "exit"
	case ActivityLogEvent_FieldPathSelectorRegionalServerMessage:
		return "regional_server_message"
	case ActivityLogEvent_FieldPathSelectorRegionalExit:
		return "regional_exit"
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_Event: %d", s))
	}
}

func BuildActivityLogEvent_FieldPath(fp gotenobject.RawFieldPath) (ActivityLogEvent_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object ActivityLog_Event")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "client_message", "clientMessage", "client-message":
			return &ActivityLogEvent_FieldTerminalPath{selector: ActivityLogEvent_FieldPathSelectorClientMessage}, nil
		case "server_message", "serverMessage", "server-message":
			return &ActivityLogEvent_FieldTerminalPath{selector: ActivityLogEvent_FieldPathSelectorServerMessage}, nil
		case "exit":
			return &ActivityLogEvent_FieldTerminalPath{selector: ActivityLogEvent_FieldPathSelectorExit}, nil
		case "regional_server_message", "regionalServerMessage", "regional-server-message":
			return &ActivityLogEvent_FieldTerminalPath{selector: ActivityLogEvent_FieldPathSelectorRegionalServerMessage}, nil
		case "regional_exit", "regionalExit", "regional-exit":
			return &ActivityLogEvent_FieldTerminalPath{selector: ActivityLogEvent_FieldPathSelectorRegionalExit}, nil
		}
	} else {
		switch fp[0] {
		case "client_message", "clientMessage", "client-message":
			if subpath, err := BuildActivityLogEventClientMsgEvent_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &ActivityLogEvent_FieldSubPath{selector: ActivityLogEvent_FieldPathSelectorClientMessage, subPath: subpath}, nil
			}
		case "server_message", "serverMessage", "server-message":
			if subpath, err := BuildActivityLogEventServerMsgEvent_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &ActivityLogEvent_FieldSubPath{selector: ActivityLogEvent_FieldPathSelectorServerMessage, subPath: subpath}, nil
			}
		case "exit":
			if subpath, err := BuildActivityLogEventExitEvent_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &ActivityLogEvent_FieldSubPath{selector: ActivityLogEvent_FieldPathSelectorExit, subPath: subpath}, nil
			}
		case "regional_server_message", "regionalServerMessage", "regional-server-message":
			if subpath, err := BuildActivityLogEventRegionalServerMsgEvent_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &ActivityLogEvent_FieldSubPath{selector: ActivityLogEvent_FieldPathSelectorRegionalServerMessage, subPath: subpath}, nil
			}
		case "regional_exit", "regionalExit", "regional-exit":
			if subpath, err := BuildActivityLogEventRegionalServerMsgEvent_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &ActivityLogEvent_FieldSubPath{selector: ActivityLogEvent_FieldPathSelectorRegionalExit, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object ActivityLog_Event", fp)
}

func ParseActivityLogEvent_FieldPath(rawField string) (ActivityLogEvent_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildActivityLogEvent_FieldPath(fp)
}

func MustParseActivityLogEvent_FieldPath(rawField string) ActivityLogEvent_FieldPath {
	fp, err := ParseActivityLogEvent_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type ActivityLogEvent_FieldTerminalPath struct {
	selector ActivityLogEvent_FieldPathSelector
}

var _ ActivityLogEvent_FieldPath = (*ActivityLogEvent_FieldTerminalPath)(nil)

func (fp *ActivityLogEvent_FieldTerminalPath) Selector() ActivityLogEvent_FieldPathSelector {
	return fp.selector
}

// String returns path representation in proto convention
func (fp *ActivityLogEvent_FieldTerminalPath) String() string {
	return fp.selector.String()
}

// JSONString returns path representation is JSON convention
func (fp *ActivityLogEvent_FieldTerminalPath) JSONString() string {
	return strcase.ToLowerCamel(fp.String())
}

// Get returns all values pointed by specific field from source ActivityLog_Event
func (fp *ActivityLogEvent_FieldTerminalPath) Get(source *ActivityLog_Event) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case ActivityLogEvent_FieldPathSelectorClientMessage:
			if source, ok := source.Evt.(*ActivityLog_Event_ClientMessage); ok && source != nil {
				if source.ClientMessage != nil {
					values = append(values, source.ClientMessage)
				}
			}
		case ActivityLogEvent_FieldPathSelectorServerMessage:
			if source, ok := source.Evt.(*ActivityLog_Event_ServerMessage); ok && source != nil {
				if source.ServerMessage != nil {
					values = append(values, source.ServerMessage)
				}
			}
		case ActivityLogEvent_FieldPathSelectorExit:
			if source, ok := source.Evt.(*ActivityLog_Event_Exit); ok && source != nil {
				if source.Exit != nil {
					values = append(values, source.Exit)
				}
			}
		case ActivityLogEvent_FieldPathSelectorRegionalServerMessage:
			if source, ok := source.Evt.(*ActivityLog_Event_RegionalServerMessage); ok && source != nil {
				if source.RegionalServerMessage != nil {
					values = append(values, source.RegionalServerMessage)
				}
			}
		case ActivityLogEvent_FieldPathSelectorRegionalExit:
			if source, ok := source.Evt.(*ActivityLog_Event_RegionalExit); ok && source != nil {
				if source.RegionalExit != nil {
					values = append(values, source.RegionalExit)
				}
			}
		default:
			panic(fmt.Sprintf("Invalid selector for ActivityLog_Event: %d", fp.selector))
		}
	}
	return
}

func (fp *ActivityLogEvent_FieldTerminalPath) GetRaw(source proto.Message) []interface{} {
	return fp.Get(source.(*ActivityLog_Event))
}

// GetSingle returns value pointed by specific field of from source ActivityLog_Event
func (fp *ActivityLogEvent_FieldTerminalPath) GetSingle(source *ActivityLog_Event) (interface{}, bool) {
	switch fp.selector {
	case ActivityLogEvent_FieldPathSelectorClientMessage:
		res := source.GetClientMessage()
		return res, res != nil
	case ActivityLogEvent_FieldPathSelectorServerMessage:
		res := source.GetServerMessage()
		return res, res != nil
	case ActivityLogEvent_FieldPathSelectorExit:
		res := source.GetExit()
		return res, res != nil
	case ActivityLogEvent_FieldPathSelectorRegionalServerMessage:
		res := source.GetRegionalServerMessage()
		return res, res != nil
	case ActivityLogEvent_FieldPathSelectorRegionalExit:
		res := source.GetRegionalExit()
		return res, res != nil
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_Event: %d", fp.selector))
	}
}

func (fp *ActivityLogEvent_FieldTerminalPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fp.GetSingle(source.(*ActivityLog_Event))
}

// GetDefault returns a default value of the field type
func (fp *ActivityLogEvent_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case ActivityLogEvent_FieldPathSelectorClientMessage:
		return (*ActivityLog_Event_ClientMsgEvent)(nil)
	case ActivityLogEvent_FieldPathSelectorServerMessage:
		return (*ActivityLog_Event_ServerMsgEvent)(nil)
	case ActivityLogEvent_FieldPathSelectorExit:
		return (*ActivityLog_Event_ExitEvent)(nil)
	case ActivityLogEvent_FieldPathSelectorRegionalServerMessage:
		return (*ActivityLog_Event_RegionalServerMsgEvent)(nil)
	case ActivityLogEvent_FieldPathSelectorRegionalExit:
		return (*ActivityLog_Event_RegionalServerMsgEvent)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_Event: %d", fp.selector))
	}
}

func (fp *ActivityLogEvent_FieldTerminalPath) ClearValue(item *ActivityLog_Event) {
	if item != nil {
		switch fp.selector {
		case ActivityLogEvent_FieldPathSelectorClientMessage:
			if item, ok := item.Evt.(*ActivityLog_Event_ClientMessage); ok {
				item.ClientMessage = nil
			}
		case ActivityLogEvent_FieldPathSelectorServerMessage:
			if item, ok := item.Evt.(*ActivityLog_Event_ServerMessage); ok {
				item.ServerMessage = nil
			}
		case ActivityLogEvent_FieldPathSelectorExit:
			if item, ok := item.Evt.(*ActivityLog_Event_Exit); ok {
				item.Exit = nil
			}
		case ActivityLogEvent_FieldPathSelectorRegionalServerMessage:
			if item, ok := item.Evt.(*ActivityLog_Event_RegionalServerMessage); ok {
				item.RegionalServerMessage = nil
			}
		case ActivityLogEvent_FieldPathSelectorRegionalExit:
			if item, ok := item.Evt.(*ActivityLog_Event_RegionalExit); ok {
				item.RegionalExit = nil
			}
		default:
			panic(fmt.Sprintf("Invalid selector for ActivityLog_Event: %d", fp.selector))
		}
	}
}

func (fp *ActivityLogEvent_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*ActivityLog_Event))
}

// IsLeaf - whether field path is holds simple value
func (fp *ActivityLogEvent_FieldTerminalPath) IsLeaf() bool {
	return false
}

func (fp *ActivityLogEvent_FieldTerminalPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
	return []gotenobject.FieldPath{fp}
}

func (fp *ActivityLogEvent_FieldTerminalPath) WithIValue(value interface{}) ActivityLogEvent_FieldPathValue {
	switch fp.selector {
	case ActivityLogEvent_FieldPathSelectorClientMessage:
		return &ActivityLogEvent_FieldTerminalPathValue{ActivityLogEvent_FieldTerminalPath: *fp, value: value.(*ActivityLog_Event_ClientMsgEvent)}
	case ActivityLogEvent_FieldPathSelectorServerMessage:
		return &ActivityLogEvent_FieldTerminalPathValue{ActivityLogEvent_FieldTerminalPath: *fp, value: value.(*ActivityLog_Event_ServerMsgEvent)}
	case ActivityLogEvent_FieldPathSelectorExit:
		return &ActivityLogEvent_FieldTerminalPathValue{ActivityLogEvent_FieldTerminalPath: *fp, value: value.(*ActivityLog_Event_ExitEvent)}
	case ActivityLogEvent_FieldPathSelectorRegionalServerMessage:
		return &ActivityLogEvent_FieldTerminalPathValue{ActivityLogEvent_FieldTerminalPath: *fp, value: value.(*ActivityLog_Event_RegionalServerMsgEvent)}
	case ActivityLogEvent_FieldPathSelectorRegionalExit:
		return &ActivityLogEvent_FieldTerminalPathValue{ActivityLogEvent_FieldTerminalPath: *fp, value: value.(*ActivityLog_Event_RegionalServerMsgEvent)}
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_Event: %d", fp.selector))
	}
}

func (fp *ActivityLogEvent_FieldTerminalPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
	return fp.WithIValue(value)
}

func (fp *ActivityLogEvent_FieldTerminalPath) WithIArrayOfValues(values interface{}) ActivityLogEvent_FieldPathArrayOfValues {
	fpaov := &ActivityLogEvent_FieldTerminalPathArrayOfValues{ActivityLogEvent_FieldTerminalPath: *fp}
	switch fp.selector {
	case ActivityLogEvent_FieldPathSelectorClientMessage:
		return &ActivityLogEvent_FieldTerminalPathArrayOfValues{ActivityLogEvent_FieldTerminalPath: *fp, values: values.([]*ActivityLog_Event_ClientMsgEvent)}
	case ActivityLogEvent_FieldPathSelectorServerMessage:
		return &ActivityLogEvent_FieldTerminalPathArrayOfValues{ActivityLogEvent_FieldTerminalPath: *fp, values: values.([]*ActivityLog_Event_ServerMsgEvent)}
	case ActivityLogEvent_FieldPathSelectorExit:
		return &ActivityLogEvent_FieldTerminalPathArrayOfValues{ActivityLogEvent_FieldTerminalPath: *fp, values: values.([]*ActivityLog_Event_ExitEvent)}
	case ActivityLogEvent_FieldPathSelectorRegionalServerMessage:
		return &ActivityLogEvent_FieldTerminalPathArrayOfValues{ActivityLogEvent_FieldTerminalPath: *fp, values: values.([]*ActivityLog_Event_RegionalServerMsgEvent)}
	case ActivityLogEvent_FieldPathSelectorRegionalExit:
		return &ActivityLogEvent_FieldTerminalPathArrayOfValues{ActivityLogEvent_FieldTerminalPath: *fp, values: values.([]*ActivityLog_Event_RegionalServerMsgEvent)}
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_Event: %d", fp.selector))
	}
	return fpaov
}

func (fp *ActivityLogEvent_FieldTerminalPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
	return fp.WithIArrayOfValues(values)
}

func (fp *ActivityLogEvent_FieldTerminalPath) WithIArrayItemValue(value interface{}) ActivityLogEvent_FieldPathArrayItemValue {
	switch fp.selector {
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_Event: %d", fp.selector))
	}
}

func (fp *ActivityLogEvent_FieldTerminalPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
	return fp.WithIArrayItemValue(value)
}

type ActivityLogEvent_FieldSubPath struct {
	selector ActivityLogEvent_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ ActivityLogEvent_FieldPath = (*ActivityLogEvent_FieldSubPath)(nil)

func (fps *ActivityLogEvent_FieldSubPath) Selector() ActivityLogEvent_FieldPathSelector {
	return fps.selector
}
func (fps *ActivityLogEvent_FieldSubPath) AsClientMessageSubPath() (ActivityLogEventClientMsgEvent_FieldPath, bool) {
	res, ok := fps.subPath.(ActivityLogEventClientMsgEvent_FieldPath)
	return res, ok
}
func (fps *ActivityLogEvent_FieldSubPath) AsServerMessageSubPath() (ActivityLogEventServerMsgEvent_FieldPath, bool) {
	res, ok := fps.subPath.(ActivityLogEventServerMsgEvent_FieldPath)
	return res, ok
}
func (fps *ActivityLogEvent_FieldSubPath) AsExitSubPath() (ActivityLogEventExitEvent_FieldPath, bool) {
	res, ok := fps.subPath.(ActivityLogEventExitEvent_FieldPath)
	return res, ok
}
func (fps *ActivityLogEvent_FieldSubPath) AsRegionalServerMessageSubPath() (ActivityLogEventRegionalServerMsgEvent_FieldPath, bool) {
	res, ok := fps.subPath.(ActivityLogEventRegionalServerMsgEvent_FieldPath)
	return res, ok
}
func (fps *ActivityLogEvent_FieldSubPath) AsRegionalExitSubPath() (ActivityLogEventRegionalServerMsgEvent_FieldPath, bool) {
	res, ok := fps.subPath.(ActivityLogEventRegionalServerMsgEvent_FieldPath)
	return res, ok
}

// String returns path representation in proto convention
func (fps *ActivityLogEvent_FieldSubPath) String() string {
	return fps.selector.String() + "." + fps.subPath.String()
}

// JSONString returns path representation is JSON convention
func (fps *ActivityLogEvent_FieldSubPath) JSONString() string {
	return strcase.ToLowerCamel(fps.selector.String()) + "." + fps.subPath.JSONString()
}

// Get returns all values pointed by selected field from source ActivityLog_Event
func (fps *ActivityLogEvent_FieldSubPath) Get(source *ActivityLog_Event) (values []interface{}) {
	switch fps.selector {
	case ActivityLogEvent_FieldPathSelectorClientMessage:
		values = append(values, fps.subPath.GetRaw(source.GetClientMessage())...)
	case ActivityLogEvent_FieldPathSelectorServerMessage:
		values = append(values, fps.subPath.GetRaw(source.GetServerMessage())...)
	case ActivityLogEvent_FieldPathSelectorExit:
		values = append(values, fps.subPath.GetRaw(source.GetExit())...)
	case ActivityLogEvent_FieldPathSelectorRegionalServerMessage:
		values = append(values, fps.subPath.GetRaw(source.GetRegionalServerMessage())...)
	case ActivityLogEvent_FieldPathSelectorRegionalExit:
		values = append(values, fps.subPath.GetRaw(source.GetRegionalExit())...)
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_Event: %d", fps.selector))
	}
	return
}

func (fps *ActivityLogEvent_FieldSubPath) GetRaw(source proto.Message) []interface{} {
	return fps.Get(source.(*ActivityLog_Event))
}

// GetSingle returns value of selected field from source ActivityLog_Event
func (fps *ActivityLogEvent_FieldSubPath) GetSingle(source *ActivityLog_Event) (interface{}, bool) {
	switch fps.selector {
	case ActivityLogEvent_FieldPathSelectorClientMessage:
		if source.GetClientMessage() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetClientMessage())
	case ActivityLogEvent_FieldPathSelectorServerMessage:
		if source.GetServerMessage() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetServerMessage())
	case ActivityLogEvent_FieldPathSelectorExit:
		if source.GetExit() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetExit())
	case ActivityLogEvent_FieldPathSelectorRegionalServerMessage:
		if source.GetRegionalServerMessage() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetRegionalServerMessage())
	case ActivityLogEvent_FieldPathSelectorRegionalExit:
		if source.GetRegionalExit() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetRegionalExit())
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_Event: %d", fps.selector))
	}
}

func (fps *ActivityLogEvent_FieldSubPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fps.GetSingle(source.(*ActivityLog_Event))
}

// GetDefault returns a default value of the field type
func (fps *ActivityLogEvent_FieldSubPath) GetDefault() interface{} {
	return fps.subPath.GetDefault()
}

func (fps *ActivityLogEvent_FieldSubPath) ClearValue(item *ActivityLog_Event) {
	if item != nil {
		switch fps.selector {
		case ActivityLogEvent_FieldPathSelectorClientMessage:
			if item.Evt != nil {
				if item, ok := item.Evt.(*ActivityLog_Event_ClientMessage); ok {
					fps.subPath.ClearValueRaw(item.ClientMessage)
				}
			}
		case ActivityLogEvent_FieldPathSelectorServerMessage:
			if item.Evt != nil {
				if item, ok := item.Evt.(*ActivityLog_Event_ServerMessage); ok {
					fps.subPath.ClearValueRaw(item.ServerMessage)
				}
			}
		case ActivityLogEvent_FieldPathSelectorExit:
			if item.Evt != nil {
				if item, ok := item.Evt.(*ActivityLog_Event_Exit); ok {
					fps.subPath.ClearValueRaw(item.Exit)
				}
			}
		case ActivityLogEvent_FieldPathSelectorRegionalServerMessage:
			if item.Evt != nil {
				if item, ok := item.Evt.(*ActivityLog_Event_RegionalServerMessage); ok {
					fps.subPath.ClearValueRaw(item.RegionalServerMessage)
				}
			}
		case ActivityLogEvent_FieldPathSelectorRegionalExit:
			if item.Evt != nil {
				if item, ok := item.Evt.(*ActivityLog_Event_RegionalExit); ok {
					fps.subPath.ClearValueRaw(item.RegionalExit)
				}
			}
		default:
			panic(fmt.Sprintf("Invalid selector for ActivityLog_Event: %d", fps.selector))
		}
	}
}

func (fps *ActivityLogEvent_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*ActivityLog_Event))
}

// IsLeaf - whether field path is holds simple value
func (fps *ActivityLogEvent_FieldSubPath) IsLeaf() bool {
	return fps.subPath.IsLeaf()
}

func (fps *ActivityLogEvent_FieldSubPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
	iPaths := []gotenobject.FieldPath{&ActivityLogEvent_FieldTerminalPath{selector: fps.selector}}
	iPaths = append(iPaths, fps.subPath.SplitIntoTerminalIPaths()...)
	return iPaths
}

func (fps *ActivityLogEvent_FieldSubPath) WithIValue(value interface{}) ActivityLogEvent_FieldPathValue {
	return &ActivityLogEvent_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

func (fps *ActivityLogEvent_FieldSubPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
	return fps.WithIValue(value)
}

func (fps *ActivityLogEvent_FieldSubPath) WithIArrayOfValues(values interface{}) ActivityLogEvent_FieldPathArrayOfValues {
	return &ActivityLogEvent_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

func (fps *ActivityLogEvent_FieldSubPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
	return fps.WithIArrayOfValues(values)
}

func (fps *ActivityLogEvent_FieldSubPath) WithIArrayItemValue(value interface{}) ActivityLogEvent_FieldPathArrayItemValue {
	return &ActivityLogEvent_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

func (fps *ActivityLogEvent_FieldSubPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
	return fps.WithIArrayItemValue(value)
}

// ActivityLogEvent_FieldPathValue allows storing values for Event fields according to their type
type ActivityLogEvent_FieldPathValue interface {
	ActivityLogEvent_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **ActivityLog_Event)
	CompareWith(*ActivityLog_Event) (cmp int, comparable bool)
}

func ParseActivityLogEvent_FieldPathValue(pathStr, valueStr string) (ActivityLogEvent_FieldPathValue, error) {
	fp, err := ParseActivityLogEvent_FieldPath(pathStr)
	if err != nil {
		return nil, err
	}
	fpv, err := gotenobject.ParseFieldPathValue(fp, valueStr)
	if err != nil {
		return nil, status.Errorf(codes.InvalidArgument, "error parsing Event field path value from %s: %v", valueStr, err)
	}
	return fpv.(ActivityLogEvent_FieldPathValue), nil
}

func MustParseActivityLogEvent_FieldPathValue(pathStr, valueStr string) ActivityLogEvent_FieldPathValue {
	fpv, err := ParseActivityLogEvent_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type ActivityLogEvent_FieldTerminalPathValue struct {
	ActivityLogEvent_FieldTerminalPath
	value interface{}
}

var _ ActivityLogEvent_FieldPathValue = (*ActivityLogEvent_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'Event' as interface{}
func (fpv *ActivityLogEvent_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *ActivityLogEvent_FieldTerminalPathValue) AsClientMessageValue() (*ActivityLog_Event_ClientMsgEvent, bool) {
	res, ok := fpv.value.(*ActivityLog_Event_ClientMsgEvent)
	return res, ok
}
func (fpv *ActivityLogEvent_FieldTerminalPathValue) AsServerMessageValue() (*ActivityLog_Event_ServerMsgEvent, bool) {
	res, ok := fpv.value.(*ActivityLog_Event_ServerMsgEvent)
	return res, ok
}
func (fpv *ActivityLogEvent_FieldTerminalPathValue) AsExitValue() (*ActivityLog_Event_ExitEvent, bool) {
	res, ok := fpv.value.(*ActivityLog_Event_ExitEvent)
	return res, ok
}
func (fpv *ActivityLogEvent_FieldTerminalPathValue) AsRegionalServerMessageValue() (*ActivityLog_Event_RegionalServerMsgEvent, bool) {
	res, ok := fpv.value.(*ActivityLog_Event_RegionalServerMsgEvent)
	return res, ok
}
func (fpv *ActivityLogEvent_FieldTerminalPathValue) AsRegionalExitValue() (*ActivityLog_Event_RegionalServerMsgEvent, bool) {
	res, ok := fpv.value.(*ActivityLog_Event_RegionalServerMsgEvent)
	return res, ok
}

// SetTo stores value for selected field for object Event
func (fpv *ActivityLogEvent_FieldTerminalPathValue) SetTo(target **ActivityLog_Event) {
	if *target == nil {
		*target = new(ActivityLog_Event)
	}
	switch fpv.selector {
	case ActivityLogEvent_FieldPathSelectorClientMessage:
		if _, ok := (*target).Evt.(*ActivityLog_Event_ClientMessage); !ok {
			(*target).Evt = &ActivityLog_Event_ClientMessage{}
		}
		(*target).Evt.(*ActivityLog_Event_ClientMessage).ClientMessage = fpv.value.(*ActivityLog_Event_ClientMsgEvent)
	case ActivityLogEvent_FieldPathSelectorServerMessage:
		if _, ok := (*target).Evt.(*ActivityLog_Event_ServerMessage); !ok {
			(*target).Evt = &ActivityLog_Event_ServerMessage{}
		}
		(*target).Evt.(*ActivityLog_Event_ServerMessage).ServerMessage = fpv.value.(*ActivityLog_Event_ServerMsgEvent)
	case ActivityLogEvent_FieldPathSelectorExit:
		if _, ok := (*target).Evt.(*ActivityLog_Event_Exit); !ok {
			(*target).Evt = &ActivityLog_Event_Exit{}
		}
		(*target).Evt.(*ActivityLog_Event_Exit).Exit = fpv.value.(*ActivityLog_Event_ExitEvent)
	case ActivityLogEvent_FieldPathSelectorRegionalServerMessage:
		if _, ok := (*target).Evt.(*ActivityLog_Event_RegionalServerMessage); !ok {
			(*target).Evt = &ActivityLog_Event_RegionalServerMessage{}
		}
		(*target).Evt.(*ActivityLog_Event_RegionalServerMessage).RegionalServerMessage = fpv.value.(*ActivityLog_Event_RegionalServerMsgEvent)
	case ActivityLogEvent_FieldPathSelectorRegionalExit:
		if _, ok := (*target).Evt.(*ActivityLog_Event_RegionalExit); !ok {
			(*target).Evt = &ActivityLog_Event_RegionalExit{}
		}
		(*target).Evt.(*ActivityLog_Event_RegionalExit).RegionalExit = fpv.value.(*ActivityLog_Event_RegionalServerMsgEvent)
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_Event: %d", fpv.selector))
	}
}

func (fpv *ActivityLogEvent_FieldTerminalPathValue) SetToRaw(target proto.Message) {
	typedObject := target.(*ActivityLog_Event)
	fpv.SetTo(&typedObject)
}

// CompareWith compares value in the 'ActivityLogEvent_FieldTerminalPathValue' with the value under path in 'ActivityLog_Event'.
func (fpv *ActivityLogEvent_FieldTerminalPathValue) CompareWith(source *ActivityLog_Event) (int, bool) {
	switch fpv.selector {
	case ActivityLogEvent_FieldPathSelectorClientMessage:
		return 0, false
	case ActivityLogEvent_FieldPathSelectorServerMessage:
		return 0, false
	case ActivityLogEvent_FieldPathSelectorExit:
		return 0, false
	case ActivityLogEvent_FieldPathSelectorRegionalServerMessage:
		return 0, false
	case ActivityLogEvent_FieldPathSelectorRegionalExit:
		return 0, false
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_Event: %d", fpv.selector))
	}
}

func (fpv *ActivityLogEvent_FieldTerminalPathValue) CompareWithRaw(source proto.Message) (int, bool) {
	return fpv.CompareWith(source.(*ActivityLog_Event))
}

type ActivityLogEvent_FieldSubPathValue struct {
	ActivityLogEvent_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ ActivityLogEvent_FieldPathValue = (*ActivityLogEvent_FieldSubPathValue)(nil)

func (fpvs *ActivityLogEvent_FieldSubPathValue) AsClientMessagePathValue() (ActivityLogEventClientMsgEvent_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(ActivityLogEventClientMsgEvent_FieldPathValue)
	return res, ok
}
func (fpvs *ActivityLogEvent_FieldSubPathValue) AsServerMessagePathValue() (ActivityLogEventServerMsgEvent_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(ActivityLogEventServerMsgEvent_FieldPathValue)
	return res, ok
}
func (fpvs *ActivityLogEvent_FieldSubPathValue) AsExitPathValue() (ActivityLogEventExitEvent_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(ActivityLogEventExitEvent_FieldPathValue)
	return res, ok
}
func (fpvs *ActivityLogEvent_FieldSubPathValue) AsRegionalServerMessagePathValue() (ActivityLogEventRegionalServerMsgEvent_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(ActivityLogEventRegionalServerMsgEvent_FieldPathValue)
	return res, ok
}
func (fpvs *ActivityLogEvent_FieldSubPathValue) AsRegionalExitPathValue() (ActivityLogEventRegionalServerMsgEvent_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(ActivityLogEventRegionalServerMsgEvent_FieldPathValue)
	return res, ok
}

func (fpvs *ActivityLogEvent_FieldSubPathValue) SetTo(target **ActivityLog_Event) {
	if *target == nil {
		*target = new(ActivityLog_Event)
	}
	switch fpvs.Selector() {
	case ActivityLogEvent_FieldPathSelectorClientMessage:
		if _, ok := (*target).Evt.(*ActivityLog_Event_ClientMessage); !ok {
			(*target).Evt = &ActivityLog_Event_ClientMessage{}
		}
		fpvs.subPathValue.(ActivityLogEventClientMsgEvent_FieldPathValue).SetTo(&(*target).Evt.(*ActivityLog_Event_ClientMessage).ClientMessage)
	case ActivityLogEvent_FieldPathSelectorServerMessage:
		if _, ok := (*target).Evt.(*ActivityLog_Event_ServerMessage); !ok {
			(*target).Evt = &ActivityLog_Event_ServerMessage{}
		}
		fpvs.subPathValue.(ActivityLogEventServerMsgEvent_FieldPathValue).SetTo(&(*target).Evt.(*ActivityLog_Event_ServerMessage).ServerMessage)
	case ActivityLogEvent_FieldPathSelectorExit:
		if _, ok := (*target).Evt.(*ActivityLog_Event_Exit); !ok {
			(*target).Evt = &ActivityLog_Event_Exit{}
		}
		fpvs.subPathValue.(ActivityLogEventExitEvent_FieldPathValue).SetTo(&(*target).Evt.(*ActivityLog_Event_Exit).Exit)
	case ActivityLogEvent_FieldPathSelectorRegionalServerMessage:
		if _, ok := (*target).Evt.(*ActivityLog_Event_RegionalServerMessage); !ok {
			(*target).Evt = &ActivityLog_Event_RegionalServerMessage{}
		}
		fpvs.subPathValue.(ActivityLogEventRegionalServerMsgEvent_FieldPathValue).SetTo(&(*target).Evt.(*ActivityLog_Event_RegionalServerMessage).RegionalServerMessage)
	case ActivityLogEvent_FieldPathSelectorRegionalExit:
		if _, ok := (*target).Evt.(*ActivityLog_Event_RegionalExit); !ok {
			(*target).Evt = &ActivityLog_Event_RegionalExit{}
		}
		fpvs.subPathValue.(ActivityLogEventRegionalServerMsgEvent_FieldPathValue).SetTo(&(*target).Evt.(*ActivityLog_Event_RegionalExit).RegionalExit)
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_Event: %d", fpvs.Selector()))
	}
}

func (fpvs *ActivityLogEvent_FieldSubPathValue) SetToRaw(target proto.Message) {
	typedObject := target.(*ActivityLog_Event)
	fpvs.SetTo(&typedObject)
}

func (fpvs *ActivityLogEvent_FieldSubPathValue) GetRawValue() interface{} {
	return fpvs.subPathValue.GetRawValue()
}

func (fpvs *ActivityLogEvent_FieldSubPathValue) CompareWith(source *ActivityLog_Event) (int, bool) {
	switch fpvs.Selector() {
	case ActivityLogEvent_FieldPathSelectorClientMessage:
		return fpvs.subPathValue.(ActivityLogEventClientMsgEvent_FieldPathValue).CompareWith(source.GetClientMessage())
	case ActivityLogEvent_FieldPathSelectorServerMessage:
		return fpvs.subPathValue.(ActivityLogEventServerMsgEvent_FieldPathValue).CompareWith(source.GetServerMessage())
	case ActivityLogEvent_FieldPathSelectorExit:
		return fpvs.subPathValue.(ActivityLogEventExitEvent_FieldPathValue).CompareWith(source.GetExit())
	case ActivityLogEvent_FieldPathSelectorRegionalServerMessage:
		return fpvs.subPathValue.(ActivityLogEventRegionalServerMsgEvent_FieldPathValue).CompareWith(source.GetRegionalServerMessage())
	case ActivityLogEvent_FieldPathSelectorRegionalExit:
		return fpvs.subPathValue.(ActivityLogEventRegionalServerMsgEvent_FieldPathValue).CompareWith(source.GetRegionalExit())
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_Event: %d", fpvs.Selector()))
	}
}

func (fpvs *ActivityLogEvent_FieldSubPathValue) CompareWithRaw(source proto.Message) (int, bool) {
	return fpvs.CompareWith(source.(*ActivityLog_Event))
}

// ActivityLogEvent_FieldPathArrayItemValue allows storing single item in Path-specific values for Event according to their type
// Present only for array (repeated) types.
type ActivityLogEvent_FieldPathArrayItemValue interface {
	gotenobject.FieldPathArrayItemValue
	ActivityLogEvent_FieldPath
	ContainsValue(*ActivityLog_Event) bool
}

// ParseActivityLogEvent_FieldPathArrayItemValue parses string and JSON-encoded value to its Value
func ParseActivityLogEvent_FieldPathArrayItemValue(pathStr, valueStr string) (ActivityLogEvent_FieldPathArrayItemValue, error) {
	fp, err := ParseActivityLogEvent_FieldPath(pathStr)
	if err != nil {
		return nil, err
	}
	fpaiv, err := gotenobject.ParseFieldPathArrayItemValue(fp, valueStr)
	if err != nil {
		return nil, status.Errorf(codes.InvalidArgument, "error parsing Event field path array item value from %s: %v", valueStr, err)
	}
	return fpaiv.(ActivityLogEvent_FieldPathArrayItemValue), nil
}

func MustParseActivityLogEvent_FieldPathArrayItemValue(pathStr, valueStr string) ActivityLogEvent_FieldPathArrayItemValue {
	fpaiv, err := ParseActivityLogEvent_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type ActivityLogEvent_FieldTerminalPathArrayItemValue struct {
	ActivityLogEvent_FieldTerminalPath
	value interface{}
}

var _ ActivityLogEvent_FieldPathArrayItemValue = (*ActivityLogEvent_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object ActivityLog_Event as interface{}
func (fpaiv *ActivityLogEvent_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}

func (fpaiv *ActivityLogEvent_FieldTerminalPathArrayItemValue) GetSingle(source *ActivityLog_Event) (interface{}, bool) {
	return nil, false
}

func (fpaiv *ActivityLogEvent_FieldTerminalPathArrayItemValue) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fpaiv.GetSingle(source.(*ActivityLog_Event))
}

// Contains returns a boolean indicating if value that is being held is present in given 'Event'
func (fpaiv *ActivityLogEvent_FieldTerminalPathArrayItemValue) ContainsValue(source *ActivityLog_Event) bool {
	slice := fpaiv.ActivityLogEvent_FieldTerminalPath.Get(source)
	for _, v := range slice {
		if asProtoMsg, ok := fpaiv.value.(proto.Message); ok {
			if proto.Equal(asProtoMsg, v.(proto.Message)) {
				return true
			}
		} else if reflect.DeepEqual(v, fpaiv.value) {
			return true
		}
	}
	return false
}

type ActivityLogEvent_FieldSubPathArrayItemValue struct {
	ActivityLogEvent_FieldPath
	subPathItemValue gotenobject.FieldPathArrayItemValue
}

// GetRawValue returns stored array item value
func (fpaivs *ActivityLogEvent_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *ActivityLogEvent_FieldSubPathArrayItemValue) AsClientMessagePathItemValue() (ActivityLogEventClientMsgEvent_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(ActivityLogEventClientMsgEvent_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *ActivityLogEvent_FieldSubPathArrayItemValue) AsServerMessagePathItemValue() (ActivityLogEventServerMsgEvent_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(ActivityLogEventServerMsgEvent_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *ActivityLogEvent_FieldSubPathArrayItemValue) AsExitPathItemValue() (ActivityLogEventExitEvent_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(ActivityLogEventExitEvent_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *ActivityLogEvent_FieldSubPathArrayItemValue) AsRegionalServerMessagePathItemValue() (ActivityLogEventRegionalServerMsgEvent_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(ActivityLogEventRegionalServerMsgEvent_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *ActivityLogEvent_FieldSubPathArrayItemValue) AsRegionalExitPathItemValue() (ActivityLogEventRegionalServerMsgEvent_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(ActivityLogEventRegionalServerMsgEvent_FieldPathArrayItemValue)
	return res, ok
}

// Contains returns a boolean indicating if value that is being held is present in given 'Event'
func (fpaivs *ActivityLogEvent_FieldSubPathArrayItemValue) ContainsValue(source *ActivityLog_Event) bool {
	switch fpaivs.Selector() {
	case ActivityLogEvent_FieldPathSelectorClientMessage:
		return fpaivs.subPathItemValue.(ActivityLogEventClientMsgEvent_FieldPathArrayItemValue).ContainsValue(source.GetClientMessage())
	case ActivityLogEvent_FieldPathSelectorServerMessage:
		return fpaivs.subPathItemValue.(ActivityLogEventServerMsgEvent_FieldPathArrayItemValue).ContainsValue(source.GetServerMessage())
	case ActivityLogEvent_FieldPathSelectorExit:
		return fpaivs.subPathItemValue.(ActivityLogEventExitEvent_FieldPathArrayItemValue).ContainsValue(source.GetExit())
	case ActivityLogEvent_FieldPathSelectorRegionalServerMessage:
		return fpaivs.subPathItemValue.(ActivityLogEventRegionalServerMsgEvent_FieldPathArrayItemValue).ContainsValue(source.GetRegionalServerMessage())
	case ActivityLogEvent_FieldPathSelectorRegionalExit:
		return fpaivs.subPathItemValue.(ActivityLogEventRegionalServerMsgEvent_FieldPathArrayItemValue).ContainsValue(source.GetRegionalExit())
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_Event: %d", fpaivs.Selector()))
	}
}

// ActivityLogEvent_FieldPathArrayOfValues allows storing slice of values for Event fields according to their type
type ActivityLogEvent_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	ActivityLogEvent_FieldPath
}

func ParseActivityLogEvent_FieldPathArrayOfValues(pathStr, valuesStr string) (ActivityLogEvent_FieldPathArrayOfValues, error) {
	fp, err := ParseActivityLogEvent_FieldPath(pathStr)
	if err != nil {
		return nil, err
	}
	fpaov, err := gotenobject.ParseFieldPathArrayOfValues(fp, valuesStr)
	if err != nil {
		return nil, status.Errorf(codes.InvalidArgument, "error parsing Event field path array of values from %s: %v", valuesStr, err)
	}
	return fpaov.(ActivityLogEvent_FieldPathArrayOfValues), nil
}

func MustParseActivityLogEvent_FieldPathArrayOfValues(pathStr, valuesStr string) ActivityLogEvent_FieldPathArrayOfValues {
	fpaov, err := ParseActivityLogEvent_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type ActivityLogEvent_FieldTerminalPathArrayOfValues struct {
	ActivityLogEvent_FieldTerminalPath
	values interface{}
}

var _ ActivityLogEvent_FieldPathArrayOfValues = (*ActivityLogEvent_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *ActivityLogEvent_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case ActivityLogEvent_FieldPathSelectorClientMessage:
		for _, v := range fpaov.values.([]*ActivityLog_Event_ClientMsgEvent) {
			values = append(values, v)
		}
	case ActivityLogEvent_FieldPathSelectorServerMessage:
		for _, v := range fpaov.values.([]*ActivityLog_Event_ServerMsgEvent) {
			values = append(values, v)
		}
	case ActivityLogEvent_FieldPathSelectorExit:
		for _, v := range fpaov.values.([]*ActivityLog_Event_ExitEvent) {
			values = append(values, v)
		}
	case ActivityLogEvent_FieldPathSelectorRegionalServerMessage:
		for _, v := range fpaov.values.([]*ActivityLog_Event_RegionalServerMsgEvent) {
			values = append(values, v)
		}
	case ActivityLogEvent_FieldPathSelectorRegionalExit:
		for _, v := range fpaov.values.([]*ActivityLog_Event_RegionalServerMsgEvent) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *ActivityLogEvent_FieldTerminalPathArrayOfValues) AsClientMessageArrayOfValues() ([]*ActivityLog_Event_ClientMsgEvent, bool) {
	res, ok := fpaov.values.([]*ActivityLog_Event_ClientMsgEvent)
	return res, ok
}
func (fpaov *ActivityLogEvent_FieldTerminalPathArrayOfValues) AsServerMessageArrayOfValues() ([]*ActivityLog_Event_ServerMsgEvent, bool) {
	res, ok := fpaov.values.([]*ActivityLog_Event_ServerMsgEvent)
	return res, ok
}
func (fpaov *ActivityLogEvent_FieldTerminalPathArrayOfValues) AsExitArrayOfValues() ([]*ActivityLog_Event_ExitEvent, bool) {
	res, ok := fpaov.values.([]*ActivityLog_Event_ExitEvent)
	return res, ok
}
func (fpaov *ActivityLogEvent_FieldTerminalPathArrayOfValues) AsRegionalServerMessageArrayOfValues() ([]*ActivityLog_Event_RegionalServerMsgEvent, bool) {
	res, ok := fpaov.values.([]*ActivityLog_Event_RegionalServerMsgEvent)
	return res, ok
}
func (fpaov *ActivityLogEvent_FieldTerminalPathArrayOfValues) AsRegionalExitArrayOfValues() ([]*ActivityLog_Event_RegionalServerMsgEvent, bool) {
	res, ok := fpaov.values.([]*ActivityLog_Event_RegionalServerMsgEvent)
	return res, ok
}

type ActivityLogEvent_FieldSubPathArrayOfValues struct {
	ActivityLogEvent_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ ActivityLogEvent_FieldPathArrayOfValues = (*ActivityLogEvent_FieldSubPathArrayOfValues)(nil)

func (fpsaov *ActivityLogEvent_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *ActivityLogEvent_FieldSubPathArrayOfValues) AsClientMessagePathArrayOfValues() (ActivityLogEventClientMsgEvent_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(ActivityLogEventClientMsgEvent_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *ActivityLogEvent_FieldSubPathArrayOfValues) AsServerMessagePathArrayOfValues() (ActivityLogEventServerMsgEvent_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(ActivityLogEventServerMsgEvent_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *ActivityLogEvent_FieldSubPathArrayOfValues) AsExitPathArrayOfValues() (ActivityLogEventExitEvent_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(ActivityLogEventExitEvent_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *ActivityLogEvent_FieldSubPathArrayOfValues) AsRegionalServerMessagePathArrayOfValues() (ActivityLogEventRegionalServerMsgEvent_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(ActivityLogEventRegionalServerMsgEvent_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *ActivityLogEvent_FieldSubPathArrayOfValues) AsRegionalExitPathArrayOfValues() (ActivityLogEventRegionalServerMsgEvent_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(ActivityLogEventRegionalServerMsgEvent_FieldPathArrayOfValues)
	return res, ok
}

// FieldPath provides implementation to handle
// https://github.com/protocolbuffers/protobuf/blob/master/src/google/protobuf/field_mask.proto
type ActivityLogMethod_FieldPath interface {
	gotenobject.FieldPath
	Selector() ActivityLogMethod_FieldPathSelector
	Get(source *ActivityLog_Method) []interface{}
	GetSingle(source *ActivityLog_Method) (interface{}, bool)
	ClearValue(item *ActivityLog_Method)

	// Those methods build corresponding ActivityLogMethod_FieldPathValue
	// (or array of values) and holds passed value. Panics if injected type is incorrect.
	WithIValue(value interface{}) ActivityLogMethod_FieldPathValue
	WithIArrayOfValues(values interface{}) ActivityLogMethod_FieldPathArrayOfValues
	WithIArrayItemValue(value interface{}) ActivityLogMethod_FieldPathArrayItemValue
}

type ActivityLogMethod_FieldPathSelector int32

const (
	ActivityLogMethod_FieldPathSelectorType    ActivityLogMethod_FieldPathSelector = 0
	ActivityLogMethod_FieldPathSelectorVersion ActivityLogMethod_FieldPathSelector = 1
)

func (s ActivityLogMethod_FieldPathSelector) String() string {
	switch s {
	case ActivityLogMethod_FieldPathSelectorType:
		return "type"
	case ActivityLogMethod_FieldPathSelectorVersion:
		return "version"
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_Method: %d", s))
	}
}

func BuildActivityLogMethod_FieldPath(fp gotenobject.RawFieldPath) (ActivityLogMethod_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object ActivityLog_Method")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "type":
			return &ActivityLogMethod_FieldTerminalPath{selector: ActivityLogMethod_FieldPathSelectorType}, nil
		case "version":
			return &ActivityLogMethod_FieldTerminalPath{selector: ActivityLogMethod_FieldPathSelectorVersion}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object ActivityLog_Method", fp)
}

func ParseActivityLogMethod_FieldPath(rawField string) (ActivityLogMethod_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildActivityLogMethod_FieldPath(fp)
}

func MustParseActivityLogMethod_FieldPath(rawField string) ActivityLogMethod_FieldPath {
	fp, err := ParseActivityLogMethod_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type ActivityLogMethod_FieldTerminalPath struct {
	selector ActivityLogMethod_FieldPathSelector
}

var _ ActivityLogMethod_FieldPath = (*ActivityLogMethod_FieldTerminalPath)(nil)

func (fp *ActivityLogMethod_FieldTerminalPath) Selector() ActivityLogMethod_FieldPathSelector {
	return fp.selector
}

// String returns path representation in proto convention
func (fp *ActivityLogMethod_FieldTerminalPath) String() string {
	return fp.selector.String()
}

// JSONString returns path representation is JSON convention
func (fp *ActivityLogMethod_FieldTerminalPath) JSONString() string {
	return strcase.ToLowerCamel(fp.String())
}

// Get returns all values pointed by specific field from source ActivityLog_Method
func (fp *ActivityLogMethod_FieldTerminalPath) Get(source *ActivityLog_Method) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case ActivityLogMethod_FieldPathSelectorType:
			values = append(values, source.Type)
		case ActivityLogMethod_FieldPathSelectorVersion:
			values = append(values, source.Version)
		default:
			panic(fmt.Sprintf("Invalid selector for ActivityLog_Method: %d", fp.selector))
		}
	}
	return
}

func (fp *ActivityLogMethod_FieldTerminalPath) GetRaw(source proto.Message) []interface{} {
	return fp.Get(source.(*ActivityLog_Method))
}

// GetSingle returns value pointed by specific field of from source ActivityLog_Method
func (fp *ActivityLogMethod_FieldTerminalPath) GetSingle(source *ActivityLog_Method) (interface{}, bool) {
	switch fp.selector {
	case ActivityLogMethod_FieldPathSelectorType:
		return source.GetType(), source != nil
	case ActivityLogMethod_FieldPathSelectorVersion:
		return source.GetVersion(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_Method: %d", fp.selector))
	}
}

func (fp *ActivityLogMethod_FieldTerminalPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fp.GetSingle(source.(*ActivityLog_Method))
}

// GetDefault returns a default value of the field type
func (fp *ActivityLogMethod_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case ActivityLogMethod_FieldPathSelectorType:
		return ""
	case ActivityLogMethod_FieldPathSelectorVersion:
		return ""
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_Method: %d", fp.selector))
	}
}

func (fp *ActivityLogMethod_FieldTerminalPath) ClearValue(item *ActivityLog_Method) {
	if item != nil {
		switch fp.selector {
		case ActivityLogMethod_FieldPathSelectorType:
			item.Type = ""
		case ActivityLogMethod_FieldPathSelectorVersion:
			item.Version = ""
		default:
			panic(fmt.Sprintf("Invalid selector for ActivityLog_Method: %d", fp.selector))
		}
	}
}

func (fp *ActivityLogMethod_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*ActivityLog_Method))
}

// IsLeaf - whether field path is holds simple value
func (fp *ActivityLogMethod_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == ActivityLogMethod_FieldPathSelectorType ||
		fp.selector == ActivityLogMethod_FieldPathSelectorVersion
}

func (fp *ActivityLogMethod_FieldTerminalPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
	return []gotenobject.FieldPath{fp}
}

func (fp *ActivityLogMethod_FieldTerminalPath) WithIValue(value interface{}) ActivityLogMethod_FieldPathValue {
	switch fp.selector {
	case ActivityLogMethod_FieldPathSelectorType:
		return &ActivityLogMethod_FieldTerminalPathValue{ActivityLogMethod_FieldTerminalPath: *fp, value: value.(string)}
	case ActivityLogMethod_FieldPathSelectorVersion:
		return &ActivityLogMethod_FieldTerminalPathValue{ActivityLogMethod_FieldTerminalPath: *fp, value: value.(string)}
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_Method: %d", fp.selector))
	}
}

func (fp *ActivityLogMethod_FieldTerminalPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
	return fp.WithIValue(value)
}

func (fp *ActivityLogMethod_FieldTerminalPath) WithIArrayOfValues(values interface{}) ActivityLogMethod_FieldPathArrayOfValues {
	fpaov := &ActivityLogMethod_FieldTerminalPathArrayOfValues{ActivityLogMethod_FieldTerminalPath: *fp}
	switch fp.selector {
	case ActivityLogMethod_FieldPathSelectorType:
		return &ActivityLogMethod_FieldTerminalPathArrayOfValues{ActivityLogMethod_FieldTerminalPath: *fp, values: values.([]string)}
	case ActivityLogMethod_FieldPathSelectorVersion:
		return &ActivityLogMethod_FieldTerminalPathArrayOfValues{ActivityLogMethod_FieldTerminalPath: *fp, values: values.([]string)}
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_Method: %d", fp.selector))
	}
	return fpaov
}

func (fp *ActivityLogMethod_FieldTerminalPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
	return fp.WithIArrayOfValues(values)
}

func (fp *ActivityLogMethod_FieldTerminalPath) WithIArrayItemValue(value interface{}) ActivityLogMethod_FieldPathArrayItemValue {
	switch fp.selector {
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_Method: %d", fp.selector))
	}
}

func (fp *ActivityLogMethod_FieldTerminalPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
	return fp.WithIArrayItemValue(value)
}

// ActivityLogMethod_FieldPathValue allows storing values for Method fields according to their type
type ActivityLogMethod_FieldPathValue interface {
	ActivityLogMethod_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **ActivityLog_Method)
	CompareWith(*ActivityLog_Method) (cmp int, comparable bool)
}

func ParseActivityLogMethod_FieldPathValue(pathStr, valueStr string) (ActivityLogMethod_FieldPathValue, error) {
	fp, err := ParseActivityLogMethod_FieldPath(pathStr)
	if err != nil {
		return nil, err
	}
	fpv, err := gotenobject.ParseFieldPathValue(fp, valueStr)
	if err != nil {
		return nil, status.Errorf(codes.InvalidArgument, "error parsing Method field path value from %s: %v", valueStr, err)
	}
	return fpv.(ActivityLogMethod_FieldPathValue), nil
}

func MustParseActivityLogMethod_FieldPathValue(pathStr, valueStr string) ActivityLogMethod_FieldPathValue {
	fpv, err := ParseActivityLogMethod_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type ActivityLogMethod_FieldTerminalPathValue struct {
	ActivityLogMethod_FieldTerminalPath
	value interface{}
}

var _ ActivityLogMethod_FieldPathValue = (*ActivityLogMethod_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'Method' as interface{}
func (fpv *ActivityLogMethod_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *ActivityLogMethod_FieldTerminalPathValue) AsTypeValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *ActivityLogMethod_FieldTerminalPathValue) AsVersionValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}

// SetTo stores value for selected field for object Method
func (fpv *ActivityLogMethod_FieldTerminalPathValue) SetTo(target **ActivityLog_Method) {
	if *target == nil {
		*target = new(ActivityLog_Method)
	}
	switch fpv.selector {
	case ActivityLogMethod_FieldPathSelectorType:
		(*target).Type = fpv.value.(string)
	case ActivityLogMethod_FieldPathSelectorVersion:
		(*target).Version = fpv.value.(string)
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_Method: %d", fpv.selector))
	}
}

func (fpv *ActivityLogMethod_FieldTerminalPathValue) SetToRaw(target proto.Message) {
	typedObject := target.(*ActivityLog_Method)
	fpv.SetTo(&typedObject)
}

// CompareWith compares value in the 'ActivityLogMethod_FieldTerminalPathValue' with the value under path in 'ActivityLog_Method'.
func (fpv *ActivityLogMethod_FieldTerminalPathValue) CompareWith(source *ActivityLog_Method) (int, bool) {
	switch fpv.selector {
	case ActivityLogMethod_FieldPathSelectorType:
		leftValue := fpv.value.(string)
		rightValue := source.GetType()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case ActivityLogMethod_FieldPathSelectorVersion:
		leftValue := fpv.value.(string)
		rightValue := source.GetVersion()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_Method: %d", fpv.selector))
	}
}

func (fpv *ActivityLogMethod_FieldTerminalPathValue) CompareWithRaw(source proto.Message) (int, bool) {
	return fpv.CompareWith(source.(*ActivityLog_Method))
}

// ActivityLogMethod_FieldPathArrayItemValue allows storing single item in Path-specific values for Method according to their type
// Present only for array (repeated) types.
type ActivityLogMethod_FieldPathArrayItemValue interface {
	gotenobject.FieldPathArrayItemValue
	ActivityLogMethod_FieldPath
	ContainsValue(*ActivityLog_Method) bool
}

// ParseActivityLogMethod_FieldPathArrayItemValue parses string and JSON-encoded value to its Value
func ParseActivityLogMethod_FieldPathArrayItemValue(pathStr, valueStr string) (ActivityLogMethod_FieldPathArrayItemValue, error) {
	fp, err := ParseActivityLogMethod_FieldPath(pathStr)
	if err != nil {
		return nil, err
	}
	fpaiv, err := gotenobject.ParseFieldPathArrayItemValue(fp, valueStr)
	if err != nil {
		return nil, status.Errorf(codes.InvalidArgument, "error parsing Method field path array item value from %s: %v", valueStr, err)
	}
	return fpaiv.(ActivityLogMethod_FieldPathArrayItemValue), nil
}

func MustParseActivityLogMethod_FieldPathArrayItemValue(pathStr, valueStr string) ActivityLogMethod_FieldPathArrayItemValue {
	fpaiv, err := ParseActivityLogMethod_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type ActivityLogMethod_FieldTerminalPathArrayItemValue struct {
	ActivityLogMethod_FieldTerminalPath
	value interface{}
}

var _ ActivityLogMethod_FieldPathArrayItemValue = (*ActivityLogMethod_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object ActivityLog_Method as interface{}
func (fpaiv *ActivityLogMethod_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}

func (fpaiv *ActivityLogMethod_FieldTerminalPathArrayItemValue) GetSingle(source *ActivityLog_Method) (interface{}, bool) {
	return nil, false
}

func (fpaiv *ActivityLogMethod_FieldTerminalPathArrayItemValue) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fpaiv.GetSingle(source.(*ActivityLog_Method))
}

// Contains returns a boolean indicating if value that is being held is present in given 'Method'
func (fpaiv *ActivityLogMethod_FieldTerminalPathArrayItemValue) ContainsValue(source *ActivityLog_Method) bool {
	slice := fpaiv.ActivityLogMethod_FieldTerminalPath.Get(source)
	for _, v := range slice {
		if asProtoMsg, ok := fpaiv.value.(proto.Message); ok {
			if proto.Equal(asProtoMsg, v.(proto.Message)) {
				return true
			}
		} else if reflect.DeepEqual(v, fpaiv.value) {
			return true
		}
	}
	return false
}

// ActivityLogMethod_FieldPathArrayOfValues allows storing slice of values for Method fields according to their type
type ActivityLogMethod_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	ActivityLogMethod_FieldPath
}

func ParseActivityLogMethod_FieldPathArrayOfValues(pathStr, valuesStr string) (ActivityLogMethod_FieldPathArrayOfValues, error) {
	fp, err := ParseActivityLogMethod_FieldPath(pathStr)
	if err != nil {
		return nil, err
	}
	fpaov, err := gotenobject.ParseFieldPathArrayOfValues(fp, valuesStr)
	if err != nil {
		return nil, status.Errorf(codes.InvalidArgument, "error parsing Method field path array of values from %s: %v", valuesStr, err)
	}
	return fpaov.(ActivityLogMethod_FieldPathArrayOfValues), nil
}

func MustParseActivityLogMethod_FieldPathArrayOfValues(pathStr, valuesStr string) ActivityLogMethod_FieldPathArrayOfValues {
	fpaov, err := ParseActivityLogMethod_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type ActivityLogMethod_FieldTerminalPathArrayOfValues struct {
	ActivityLogMethod_FieldTerminalPath
	values interface{}
}

var _ ActivityLogMethod_FieldPathArrayOfValues = (*ActivityLogMethod_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *ActivityLogMethod_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case ActivityLogMethod_FieldPathSelectorType:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case ActivityLogMethod_FieldPathSelectorVersion:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *ActivityLogMethod_FieldTerminalPathArrayOfValues) AsTypeArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *ActivityLogMethod_FieldTerminalPathArrayOfValues) AsVersionArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}

// FieldPath provides implementation to handle
// https://github.com/protocolbuffers/protobuf/blob/master/src/google/protobuf/field_mask.proto
type ActivityLogRequestMetadata_FieldPath interface {
	gotenobject.FieldPath
	Selector() ActivityLogRequestMetadata_FieldPathSelector
	Get(source *ActivityLog_RequestMetadata) []interface{}
	GetSingle(source *ActivityLog_RequestMetadata) (interface{}, bool)
	ClearValue(item *ActivityLog_RequestMetadata)

	// Those methods build corresponding ActivityLogRequestMetadata_FieldPathValue
	// (or array of values) and holds passed value. Panics if injected type is incorrect.
	WithIValue(value interface{}) ActivityLogRequestMetadata_FieldPathValue
	WithIArrayOfValues(values interface{}) ActivityLogRequestMetadata_FieldPathArrayOfValues
	WithIArrayItemValue(value interface{}) ActivityLogRequestMetadata_FieldPathArrayItemValue
}

type ActivityLogRequestMetadata_FieldPathSelector int32

const (
	ActivityLogRequestMetadata_FieldPathSelectorIpAddress ActivityLogRequestMetadata_FieldPathSelector = 0
	ActivityLogRequestMetadata_FieldPathSelectorUserAgent ActivityLogRequestMetadata_FieldPathSelector = 1
)

func (s ActivityLogRequestMetadata_FieldPathSelector) String() string {
	switch s {
	case ActivityLogRequestMetadata_FieldPathSelectorIpAddress:
		return "ip_address"
	case ActivityLogRequestMetadata_FieldPathSelectorUserAgent:
		return "user_agent"
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_RequestMetadata: %d", s))
	}
}

func BuildActivityLogRequestMetadata_FieldPath(fp gotenobject.RawFieldPath) (ActivityLogRequestMetadata_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object ActivityLog_RequestMetadata")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "ip_address", "ipAddress", "ip-address":
			return &ActivityLogRequestMetadata_FieldTerminalPath{selector: ActivityLogRequestMetadata_FieldPathSelectorIpAddress}, nil
		case "user_agent", "userAgent", "user-agent":
			return &ActivityLogRequestMetadata_FieldTerminalPath{selector: ActivityLogRequestMetadata_FieldPathSelectorUserAgent}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object ActivityLog_RequestMetadata", fp)
}

func ParseActivityLogRequestMetadata_FieldPath(rawField string) (ActivityLogRequestMetadata_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildActivityLogRequestMetadata_FieldPath(fp)
}

func MustParseActivityLogRequestMetadata_FieldPath(rawField string) ActivityLogRequestMetadata_FieldPath {
	fp, err := ParseActivityLogRequestMetadata_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type ActivityLogRequestMetadata_FieldTerminalPath struct {
	selector ActivityLogRequestMetadata_FieldPathSelector
}

var _ ActivityLogRequestMetadata_FieldPath = (*ActivityLogRequestMetadata_FieldTerminalPath)(nil)

func (fp *ActivityLogRequestMetadata_FieldTerminalPath) Selector() ActivityLogRequestMetadata_FieldPathSelector {
	return fp.selector
}

// String returns path representation in proto convention
func (fp *ActivityLogRequestMetadata_FieldTerminalPath) String() string {
	return fp.selector.String()
}

// JSONString returns path representation is JSON convention
func (fp *ActivityLogRequestMetadata_FieldTerminalPath) JSONString() string {
	return strcase.ToLowerCamel(fp.String())
}

// Get returns all values pointed by specific field from source ActivityLog_RequestMetadata
func (fp *ActivityLogRequestMetadata_FieldTerminalPath) Get(source *ActivityLog_RequestMetadata) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case ActivityLogRequestMetadata_FieldPathSelectorIpAddress:
			values = append(values, source.IpAddress)
		case ActivityLogRequestMetadata_FieldPathSelectorUserAgent:
			values = append(values, source.UserAgent)
		default:
			panic(fmt.Sprintf("Invalid selector for ActivityLog_RequestMetadata: %d", fp.selector))
		}
	}
	return
}

func (fp *ActivityLogRequestMetadata_FieldTerminalPath) GetRaw(source proto.Message) []interface{} {
	return fp.Get(source.(*ActivityLog_RequestMetadata))
}

// GetSingle returns value pointed by specific field of from source ActivityLog_RequestMetadata
func (fp *ActivityLogRequestMetadata_FieldTerminalPath) GetSingle(source *ActivityLog_RequestMetadata) (interface{}, bool) {
	switch fp.selector {
	case ActivityLogRequestMetadata_FieldPathSelectorIpAddress:
		return source.GetIpAddress(), source != nil
	case ActivityLogRequestMetadata_FieldPathSelectorUserAgent:
		return source.GetUserAgent(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_RequestMetadata: %d", fp.selector))
	}
}

func (fp *ActivityLogRequestMetadata_FieldTerminalPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fp.GetSingle(source.(*ActivityLog_RequestMetadata))
}

// GetDefault returns a default value of the field type
func (fp *ActivityLogRequestMetadata_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case ActivityLogRequestMetadata_FieldPathSelectorIpAddress:
		return ""
	case ActivityLogRequestMetadata_FieldPathSelectorUserAgent:
		return ""
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_RequestMetadata: %d", fp.selector))
	}
}

func (fp *ActivityLogRequestMetadata_FieldTerminalPath) ClearValue(item *ActivityLog_RequestMetadata) {
	if item != nil {
		switch fp.selector {
		case ActivityLogRequestMetadata_FieldPathSelectorIpAddress:
			item.IpAddress = ""
		case ActivityLogRequestMetadata_FieldPathSelectorUserAgent:
			item.UserAgent = ""
		default:
			panic(fmt.Sprintf("Invalid selector for ActivityLog_RequestMetadata: %d", fp.selector))
		}
	}
}

func (fp *ActivityLogRequestMetadata_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*ActivityLog_RequestMetadata))
}

// IsLeaf - whether field path is holds simple value
func (fp *ActivityLogRequestMetadata_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == ActivityLogRequestMetadata_FieldPathSelectorIpAddress ||
		fp.selector == ActivityLogRequestMetadata_FieldPathSelectorUserAgent
}

func (fp *ActivityLogRequestMetadata_FieldTerminalPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
	return []gotenobject.FieldPath{fp}
}

func (fp *ActivityLogRequestMetadata_FieldTerminalPath) WithIValue(value interface{}) ActivityLogRequestMetadata_FieldPathValue {
	switch fp.selector {
	case ActivityLogRequestMetadata_FieldPathSelectorIpAddress:
		return &ActivityLogRequestMetadata_FieldTerminalPathValue{ActivityLogRequestMetadata_FieldTerminalPath: *fp, value: value.(string)}
	case ActivityLogRequestMetadata_FieldPathSelectorUserAgent:
		return &ActivityLogRequestMetadata_FieldTerminalPathValue{ActivityLogRequestMetadata_FieldTerminalPath: *fp, value: value.(string)}
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_RequestMetadata: %d", fp.selector))
	}
}

func (fp *ActivityLogRequestMetadata_FieldTerminalPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
	return fp.WithIValue(value)
}

func (fp *ActivityLogRequestMetadata_FieldTerminalPath) WithIArrayOfValues(values interface{}) ActivityLogRequestMetadata_FieldPathArrayOfValues {
	fpaov := &ActivityLogRequestMetadata_FieldTerminalPathArrayOfValues{ActivityLogRequestMetadata_FieldTerminalPath: *fp}
	switch fp.selector {
	case ActivityLogRequestMetadata_FieldPathSelectorIpAddress:
		return &ActivityLogRequestMetadata_FieldTerminalPathArrayOfValues{ActivityLogRequestMetadata_FieldTerminalPath: *fp, values: values.([]string)}
	case ActivityLogRequestMetadata_FieldPathSelectorUserAgent:
		return &ActivityLogRequestMetadata_FieldTerminalPathArrayOfValues{ActivityLogRequestMetadata_FieldTerminalPath: *fp, values: values.([]string)}
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_RequestMetadata: %d", fp.selector))
	}
	return fpaov
}

func (fp *ActivityLogRequestMetadata_FieldTerminalPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
	return fp.WithIArrayOfValues(values)
}

func (fp *ActivityLogRequestMetadata_FieldTerminalPath) WithIArrayItemValue(value interface{}) ActivityLogRequestMetadata_FieldPathArrayItemValue {
	switch fp.selector {
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_RequestMetadata: %d", fp.selector))
	}
}

func (fp *ActivityLogRequestMetadata_FieldTerminalPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
	return fp.WithIArrayItemValue(value)
}

// ActivityLogRequestMetadata_FieldPathValue allows storing values for RequestMetadata fields according to their type
type ActivityLogRequestMetadata_FieldPathValue interface {
	ActivityLogRequestMetadata_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **ActivityLog_RequestMetadata)
	CompareWith(*ActivityLog_RequestMetadata) (cmp int, comparable bool)
}

func ParseActivityLogRequestMetadata_FieldPathValue(pathStr, valueStr string) (ActivityLogRequestMetadata_FieldPathValue, error) {
	fp, err := ParseActivityLogRequestMetadata_FieldPath(pathStr)
	if err != nil {
		return nil, err
	}
	fpv, err := gotenobject.ParseFieldPathValue(fp, valueStr)
	if err != nil {
		return nil, status.Errorf(codes.InvalidArgument, "error parsing RequestMetadata field path value from %s: %v", valueStr, err)
	}
	return fpv.(ActivityLogRequestMetadata_FieldPathValue), nil
}

func MustParseActivityLogRequestMetadata_FieldPathValue(pathStr, valueStr string) ActivityLogRequestMetadata_FieldPathValue {
	fpv, err := ParseActivityLogRequestMetadata_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type ActivityLogRequestMetadata_FieldTerminalPathValue struct {
	ActivityLogRequestMetadata_FieldTerminalPath
	value interface{}
}

var _ ActivityLogRequestMetadata_FieldPathValue = (*ActivityLogRequestMetadata_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'RequestMetadata' as interface{}
func (fpv *ActivityLogRequestMetadata_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *ActivityLogRequestMetadata_FieldTerminalPathValue) AsIpAddressValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *ActivityLogRequestMetadata_FieldTerminalPathValue) AsUserAgentValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}

// SetTo stores value for selected field for object RequestMetadata
func (fpv *ActivityLogRequestMetadata_FieldTerminalPathValue) SetTo(target **ActivityLog_RequestMetadata) {
	if *target == nil {
		*target = new(ActivityLog_RequestMetadata)
	}
	switch fpv.selector {
	case ActivityLogRequestMetadata_FieldPathSelectorIpAddress:
		(*target).IpAddress = fpv.value.(string)
	case ActivityLogRequestMetadata_FieldPathSelectorUserAgent:
		(*target).UserAgent = fpv.value.(string)
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_RequestMetadata: %d", fpv.selector))
	}
}

func (fpv *ActivityLogRequestMetadata_FieldTerminalPathValue) SetToRaw(target proto.Message) {
	typedObject := target.(*ActivityLog_RequestMetadata)
	fpv.SetTo(&typedObject)
}

// CompareWith compares value in the 'ActivityLogRequestMetadata_FieldTerminalPathValue' with the value under path in 'ActivityLog_RequestMetadata'.
func (fpv *ActivityLogRequestMetadata_FieldTerminalPathValue) CompareWith(source *ActivityLog_RequestMetadata) (int, bool) {
	switch fpv.selector {
	case ActivityLogRequestMetadata_FieldPathSelectorIpAddress:
		leftValue := fpv.value.(string)
		rightValue := source.GetIpAddress()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case ActivityLogRequestMetadata_FieldPathSelectorUserAgent:
		leftValue := fpv.value.(string)
		rightValue := source.GetUserAgent()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_RequestMetadata: %d", fpv.selector))
	}
}

func (fpv *ActivityLogRequestMetadata_FieldTerminalPathValue) CompareWithRaw(source proto.Message) (int, bool) {
	return fpv.CompareWith(source.(*ActivityLog_RequestMetadata))
}

// ActivityLogRequestMetadata_FieldPathArrayItemValue allows storing single item in Path-specific values for RequestMetadata according to their type
// Present only for array (repeated) types.
type ActivityLogRequestMetadata_FieldPathArrayItemValue interface {
	gotenobject.FieldPathArrayItemValue
	ActivityLogRequestMetadata_FieldPath
	ContainsValue(*ActivityLog_RequestMetadata) bool
}

// ParseActivityLogRequestMetadata_FieldPathArrayItemValue parses string and JSON-encoded value to its Value
func ParseActivityLogRequestMetadata_FieldPathArrayItemValue(pathStr, valueStr string) (ActivityLogRequestMetadata_FieldPathArrayItemValue, error) {
	fp, err := ParseActivityLogRequestMetadata_FieldPath(pathStr)
	if err != nil {
		return nil, err
	}
	fpaiv, err := gotenobject.ParseFieldPathArrayItemValue(fp, valueStr)
	if err != nil {
		return nil, status.Errorf(codes.InvalidArgument, "error parsing RequestMetadata field path array item value from %s: %v", valueStr, err)
	}
	return fpaiv.(ActivityLogRequestMetadata_FieldPathArrayItemValue), nil
}

func MustParseActivityLogRequestMetadata_FieldPathArrayItemValue(pathStr, valueStr string) ActivityLogRequestMetadata_FieldPathArrayItemValue {
	fpaiv, err := ParseActivityLogRequestMetadata_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type ActivityLogRequestMetadata_FieldTerminalPathArrayItemValue struct {
	ActivityLogRequestMetadata_FieldTerminalPath
	value interface{}
}

var _ ActivityLogRequestMetadata_FieldPathArrayItemValue = (*ActivityLogRequestMetadata_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object ActivityLog_RequestMetadata as interface{}
func (fpaiv *ActivityLogRequestMetadata_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}

func (fpaiv *ActivityLogRequestMetadata_FieldTerminalPathArrayItemValue) GetSingle(source *ActivityLog_RequestMetadata) (interface{}, bool) {
	return nil, false
}

func (fpaiv *ActivityLogRequestMetadata_FieldTerminalPathArrayItemValue) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fpaiv.GetSingle(source.(*ActivityLog_RequestMetadata))
}

// Contains returns a boolean indicating if value that is being held is present in given 'RequestMetadata'
func (fpaiv *ActivityLogRequestMetadata_FieldTerminalPathArrayItemValue) ContainsValue(source *ActivityLog_RequestMetadata) bool {
	slice := fpaiv.ActivityLogRequestMetadata_FieldTerminalPath.Get(source)
	for _, v := range slice {
		if asProtoMsg, ok := fpaiv.value.(proto.Message); ok {
			if proto.Equal(asProtoMsg, v.(proto.Message)) {
				return true
			}
		} else if reflect.DeepEqual(v, fpaiv.value) {
			return true
		}
	}
	return false
}

// ActivityLogRequestMetadata_FieldPathArrayOfValues allows storing slice of values for RequestMetadata fields according to their type
type ActivityLogRequestMetadata_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	ActivityLogRequestMetadata_FieldPath
}

func ParseActivityLogRequestMetadata_FieldPathArrayOfValues(pathStr, valuesStr string) (ActivityLogRequestMetadata_FieldPathArrayOfValues, error) {
	fp, err := ParseActivityLogRequestMetadata_FieldPath(pathStr)
	if err != nil {
		return nil, err
	}
	fpaov, err := gotenobject.ParseFieldPathArrayOfValues(fp, valuesStr)
	if err != nil {
		return nil, status.Errorf(codes.InvalidArgument, "error parsing RequestMetadata field path array of values from %s: %v", valuesStr, err)
	}
	return fpaov.(ActivityLogRequestMetadata_FieldPathArrayOfValues), nil
}

func MustParseActivityLogRequestMetadata_FieldPathArrayOfValues(pathStr, valuesStr string) ActivityLogRequestMetadata_FieldPathArrayOfValues {
	fpaov, err := ParseActivityLogRequestMetadata_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type ActivityLogRequestMetadata_FieldTerminalPathArrayOfValues struct {
	ActivityLogRequestMetadata_FieldTerminalPath
	values interface{}
}

var _ ActivityLogRequestMetadata_FieldPathArrayOfValues = (*ActivityLogRequestMetadata_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *ActivityLogRequestMetadata_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case ActivityLogRequestMetadata_FieldPathSelectorIpAddress:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case ActivityLogRequestMetadata_FieldPathSelectorUserAgent:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *ActivityLogRequestMetadata_FieldTerminalPathArrayOfValues) AsIpAddressArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *ActivityLogRequestMetadata_FieldTerminalPathArrayOfValues) AsUserAgentArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}

// FieldPath provides implementation to handle
// https://github.com/protocolbuffers/protobuf/blob/master/src/google/protobuf/field_mask.proto
type ActivityLogRequestRouting_FieldPath interface {
	gotenobject.FieldPath
	Selector() ActivityLogRequestRouting_FieldPathSelector
	Get(source *ActivityLog_RequestRouting) []interface{}
	GetSingle(source *ActivityLog_RequestRouting) (interface{}, bool)
	ClearValue(item *ActivityLog_RequestRouting)

	// Those methods build corresponding ActivityLogRequestRouting_FieldPathValue
	// (or array of values) and holds passed value. Panics if injected type is incorrect.
	WithIValue(value interface{}) ActivityLogRequestRouting_FieldPathValue
	WithIArrayOfValues(values interface{}) ActivityLogRequestRouting_FieldPathArrayOfValues
	WithIArrayItemValue(value interface{}) ActivityLogRequestRouting_FieldPathArrayItemValue
}

type ActivityLogRequestRouting_FieldPathSelector int32

const (
	ActivityLogRequestRouting_FieldPathSelectorViaRegion   ActivityLogRequestRouting_FieldPathSelector = 0
	ActivityLogRequestRouting_FieldPathSelectorDestRegions ActivityLogRequestRouting_FieldPathSelector = 1
)

func (s ActivityLogRequestRouting_FieldPathSelector) String() string {
	switch s {
	case ActivityLogRequestRouting_FieldPathSelectorViaRegion:
		return "via_region"
	case ActivityLogRequestRouting_FieldPathSelectorDestRegions:
		return "dest_regions"
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_RequestRouting: %d", s))
	}
}

func BuildActivityLogRequestRouting_FieldPath(fp gotenobject.RawFieldPath) (ActivityLogRequestRouting_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object ActivityLog_RequestRouting")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "via_region", "viaRegion", "via-region":
			return &ActivityLogRequestRouting_FieldTerminalPath{selector: ActivityLogRequestRouting_FieldPathSelectorViaRegion}, nil
		case "dest_regions", "destRegions", "dest-regions":
			return &ActivityLogRequestRouting_FieldTerminalPath{selector: ActivityLogRequestRouting_FieldPathSelectorDestRegions}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object ActivityLog_RequestRouting", fp)
}

func ParseActivityLogRequestRouting_FieldPath(rawField string) (ActivityLogRequestRouting_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildActivityLogRequestRouting_FieldPath(fp)
}

func MustParseActivityLogRequestRouting_FieldPath(rawField string) ActivityLogRequestRouting_FieldPath {
	fp, err := ParseActivityLogRequestRouting_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type ActivityLogRequestRouting_FieldTerminalPath struct {
	selector ActivityLogRequestRouting_FieldPathSelector
}

var _ ActivityLogRequestRouting_FieldPath = (*ActivityLogRequestRouting_FieldTerminalPath)(nil)

func (fp *ActivityLogRequestRouting_FieldTerminalPath) Selector() ActivityLogRequestRouting_FieldPathSelector {
	return fp.selector
}

// String returns path representation in proto convention
func (fp *ActivityLogRequestRouting_FieldTerminalPath) String() string {
	return fp.selector.String()
}

// JSONString returns path representation is JSON convention
func (fp *ActivityLogRequestRouting_FieldTerminalPath) JSONString() string {
	return strcase.ToLowerCamel(fp.String())
}

// Get returns all values pointed by specific field from source ActivityLog_RequestRouting
func (fp *ActivityLogRequestRouting_FieldTerminalPath) Get(source *ActivityLog_RequestRouting) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case ActivityLogRequestRouting_FieldPathSelectorViaRegion:
			values = append(values, source.ViaRegion)
		case ActivityLogRequestRouting_FieldPathSelectorDestRegions:
			for _, value := range source.GetDestRegions() {
				values = append(values, value)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for ActivityLog_RequestRouting: %d", fp.selector))
		}
	}
	return
}

func (fp *ActivityLogRequestRouting_FieldTerminalPath) GetRaw(source proto.Message) []interface{} {
	return fp.Get(source.(*ActivityLog_RequestRouting))
}

// GetSingle returns value pointed by specific field of from source ActivityLog_RequestRouting
func (fp *ActivityLogRequestRouting_FieldTerminalPath) GetSingle(source *ActivityLog_RequestRouting) (interface{}, bool) {
	switch fp.selector {
	case ActivityLogRequestRouting_FieldPathSelectorViaRegion:
		return source.GetViaRegion(), source != nil
	case ActivityLogRequestRouting_FieldPathSelectorDestRegions:
		res := source.GetDestRegions()
		return res, res != nil
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_RequestRouting: %d", fp.selector))
	}
}

func (fp *ActivityLogRequestRouting_FieldTerminalPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fp.GetSingle(source.(*ActivityLog_RequestRouting))
}

// GetDefault returns a default value of the field type
func (fp *ActivityLogRequestRouting_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case ActivityLogRequestRouting_FieldPathSelectorViaRegion:
		return ""
	case ActivityLogRequestRouting_FieldPathSelectorDestRegions:
		return ([]string)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_RequestRouting: %d", fp.selector))
	}
}

func (fp *ActivityLogRequestRouting_FieldTerminalPath) ClearValue(item *ActivityLog_RequestRouting) {
	if item != nil {
		switch fp.selector {
		case ActivityLogRequestRouting_FieldPathSelectorViaRegion:
			item.ViaRegion = ""
		case ActivityLogRequestRouting_FieldPathSelectorDestRegions:
			item.DestRegions = nil
		default:
			panic(fmt.Sprintf("Invalid selector for ActivityLog_RequestRouting: %d", fp.selector))
		}
	}
}

func (fp *ActivityLogRequestRouting_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*ActivityLog_RequestRouting))
}

// IsLeaf - whether field path is holds simple value
func (fp *ActivityLogRequestRouting_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == ActivityLogRequestRouting_FieldPathSelectorViaRegion ||
		fp.selector == ActivityLogRequestRouting_FieldPathSelectorDestRegions
}

func (fp *ActivityLogRequestRouting_FieldTerminalPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
	return []gotenobject.FieldPath{fp}
}

func (fp *ActivityLogRequestRouting_FieldTerminalPath) WithIValue(value interface{}) ActivityLogRequestRouting_FieldPathValue {
	switch fp.selector {
	case ActivityLogRequestRouting_FieldPathSelectorViaRegion:
		return &ActivityLogRequestRouting_FieldTerminalPathValue{ActivityLogRequestRouting_FieldTerminalPath: *fp, value: value.(string)}
	case ActivityLogRequestRouting_FieldPathSelectorDestRegions:
		return &ActivityLogRequestRouting_FieldTerminalPathValue{ActivityLogRequestRouting_FieldTerminalPath: *fp, value: value.([]string)}
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_RequestRouting: %d", fp.selector))
	}
}

func (fp *ActivityLogRequestRouting_FieldTerminalPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
	return fp.WithIValue(value)
}

func (fp *ActivityLogRequestRouting_FieldTerminalPath) WithIArrayOfValues(values interface{}) ActivityLogRequestRouting_FieldPathArrayOfValues {
	fpaov := &ActivityLogRequestRouting_FieldTerminalPathArrayOfValues{ActivityLogRequestRouting_FieldTerminalPath: *fp}
	switch fp.selector {
	case ActivityLogRequestRouting_FieldPathSelectorViaRegion:
		return &ActivityLogRequestRouting_FieldTerminalPathArrayOfValues{ActivityLogRequestRouting_FieldTerminalPath: *fp, values: values.([]string)}
	case ActivityLogRequestRouting_FieldPathSelectorDestRegions:
		return &ActivityLogRequestRouting_FieldTerminalPathArrayOfValues{ActivityLogRequestRouting_FieldTerminalPath: *fp, values: values.([][]string)}
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_RequestRouting: %d", fp.selector))
	}
	return fpaov
}

func (fp *ActivityLogRequestRouting_FieldTerminalPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
	return fp.WithIArrayOfValues(values)
}

func (fp *ActivityLogRequestRouting_FieldTerminalPath) WithIArrayItemValue(value interface{}) ActivityLogRequestRouting_FieldPathArrayItemValue {
	switch fp.selector {
	case ActivityLogRequestRouting_FieldPathSelectorDestRegions:
		return &ActivityLogRequestRouting_FieldTerminalPathArrayItemValue{ActivityLogRequestRouting_FieldTerminalPath: *fp, value: value.(string)}
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_RequestRouting: %d", fp.selector))
	}
}

func (fp *ActivityLogRequestRouting_FieldTerminalPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
	return fp.WithIArrayItemValue(value)
}

// ActivityLogRequestRouting_FieldPathValue allows storing values for RequestRouting fields according to their type
type ActivityLogRequestRouting_FieldPathValue interface {
	ActivityLogRequestRouting_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **ActivityLog_RequestRouting)
	CompareWith(*ActivityLog_RequestRouting) (cmp int, comparable bool)
}

func ParseActivityLogRequestRouting_FieldPathValue(pathStr, valueStr string) (ActivityLogRequestRouting_FieldPathValue, error) {
	fp, err := ParseActivityLogRequestRouting_FieldPath(pathStr)
	if err != nil {
		return nil, err
	}
	fpv, err := gotenobject.ParseFieldPathValue(fp, valueStr)
	if err != nil {
		return nil, status.Errorf(codes.InvalidArgument, "error parsing RequestRouting field path value from %s: %v", valueStr, err)
	}
	return fpv.(ActivityLogRequestRouting_FieldPathValue), nil
}

func MustParseActivityLogRequestRouting_FieldPathValue(pathStr, valueStr string) ActivityLogRequestRouting_FieldPathValue {
	fpv, err := ParseActivityLogRequestRouting_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type ActivityLogRequestRouting_FieldTerminalPathValue struct {
	ActivityLogRequestRouting_FieldTerminalPath
	value interface{}
}

var _ ActivityLogRequestRouting_FieldPathValue = (*ActivityLogRequestRouting_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'RequestRouting' as interface{}
func (fpv *ActivityLogRequestRouting_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *ActivityLogRequestRouting_FieldTerminalPathValue) AsViaRegionValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *ActivityLogRequestRouting_FieldTerminalPathValue) AsDestRegionsValue() ([]string, bool) {
	res, ok := fpv.value.([]string)
	return res, ok
}

// SetTo stores value for selected field for object RequestRouting
func (fpv *ActivityLogRequestRouting_FieldTerminalPathValue) SetTo(target **ActivityLog_RequestRouting) {
	if *target == nil {
		*target = new(ActivityLog_RequestRouting)
	}
	switch fpv.selector {
	case ActivityLogRequestRouting_FieldPathSelectorViaRegion:
		(*target).ViaRegion = fpv.value.(string)
	case ActivityLogRequestRouting_FieldPathSelectorDestRegions:
		(*target).DestRegions = fpv.value.([]string)
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_RequestRouting: %d", fpv.selector))
	}
}

func (fpv *ActivityLogRequestRouting_FieldTerminalPathValue) SetToRaw(target proto.Message) {
	typedObject := target.(*ActivityLog_RequestRouting)
	fpv.SetTo(&typedObject)
}

// CompareWith compares value in the 'ActivityLogRequestRouting_FieldTerminalPathValue' with the value under path in 'ActivityLog_RequestRouting'.
func (fpv *ActivityLogRequestRouting_FieldTerminalPathValue) CompareWith(source *ActivityLog_RequestRouting) (int, bool) {
	switch fpv.selector {
	case ActivityLogRequestRouting_FieldPathSelectorViaRegion:
		leftValue := fpv.value.(string)
		rightValue := source.GetViaRegion()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case ActivityLogRequestRouting_FieldPathSelectorDestRegions:
		return 0, false
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_RequestRouting: %d", fpv.selector))
	}
}

func (fpv *ActivityLogRequestRouting_FieldTerminalPathValue) CompareWithRaw(source proto.Message) (int, bool) {
	return fpv.CompareWith(source.(*ActivityLog_RequestRouting))
}

// ActivityLogRequestRouting_FieldPathArrayItemValue allows storing single item in Path-specific values for RequestRouting according to their type
// Present only for array (repeated) types.
type ActivityLogRequestRouting_FieldPathArrayItemValue interface {
	gotenobject.FieldPathArrayItemValue
	ActivityLogRequestRouting_FieldPath
	ContainsValue(*ActivityLog_RequestRouting) bool
}

// ParseActivityLogRequestRouting_FieldPathArrayItemValue parses string and JSON-encoded value to its Value
func ParseActivityLogRequestRouting_FieldPathArrayItemValue(pathStr, valueStr string) (ActivityLogRequestRouting_FieldPathArrayItemValue, error) {
	fp, err := ParseActivityLogRequestRouting_FieldPath(pathStr)
	if err != nil {
		return nil, err
	}
	fpaiv, err := gotenobject.ParseFieldPathArrayItemValue(fp, valueStr)
	if err != nil {
		return nil, status.Errorf(codes.InvalidArgument, "error parsing RequestRouting field path array item value from %s: %v", valueStr, err)
	}
	return fpaiv.(ActivityLogRequestRouting_FieldPathArrayItemValue), nil
}

func MustParseActivityLogRequestRouting_FieldPathArrayItemValue(pathStr, valueStr string) ActivityLogRequestRouting_FieldPathArrayItemValue {
	fpaiv, err := ParseActivityLogRequestRouting_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type ActivityLogRequestRouting_FieldTerminalPathArrayItemValue struct {
	ActivityLogRequestRouting_FieldTerminalPath
	value interface{}
}

var _ ActivityLogRequestRouting_FieldPathArrayItemValue = (*ActivityLogRequestRouting_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object ActivityLog_RequestRouting as interface{}
func (fpaiv *ActivityLogRequestRouting_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}
func (fpaiv *ActivityLogRequestRouting_FieldTerminalPathArrayItemValue) AsDestRegionsItemValue() (string, bool) {
	res, ok := fpaiv.value.(string)
	return res, ok
}

func (fpaiv *ActivityLogRequestRouting_FieldTerminalPathArrayItemValue) GetSingle(source *ActivityLog_RequestRouting) (interface{}, bool) {
	return nil, false
}

func (fpaiv *ActivityLogRequestRouting_FieldTerminalPathArrayItemValue) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fpaiv.GetSingle(source.(*ActivityLog_RequestRouting))
}

// Contains returns a boolean indicating if value that is being held is present in given 'RequestRouting'
func (fpaiv *ActivityLogRequestRouting_FieldTerminalPathArrayItemValue) ContainsValue(source *ActivityLog_RequestRouting) bool {
	slice := fpaiv.ActivityLogRequestRouting_FieldTerminalPath.Get(source)
	for _, v := range slice {
		if asProtoMsg, ok := fpaiv.value.(proto.Message); ok {
			if proto.Equal(asProtoMsg, v.(proto.Message)) {
				return true
			}
		} else if reflect.DeepEqual(v, fpaiv.value) {
			return true
		}
	}
	return false
}

// ActivityLogRequestRouting_FieldPathArrayOfValues allows storing slice of values for RequestRouting fields according to their type
type ActivityLogRequestRouting_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	ActivityLogRequestRouting_FieldPath
}

func ParseActivityLogRequestRouting_FieldPathArrayOfValues(pathStr, valuesStr string) (ActivityLogRequestRouting_FieldPathArrayOfValues, error) {
	fp, err := ParseActivityLogRequestRouting_FieldPath(pathStr)
	if err != nil {
		return nil, err
	}
	fpaov, err := gotenobject.ParseFieldPathArrayOfValues(fp, valuesStr)
	if err != nil {
		return nil, status.Errorf(codes.InvalidArgument, "error parsing RequestRouting field path array of values from %s: %v", valuesStr, err)
	}
	return fpaov.(ActivityLogRequestRouting_FieldPathArrayOfValues), nil
}

func MustParseActivityLogRequestRouting_FieldPathArrayOfValues(pathStr, valuesStr string) ActivityLogRequestRouting_FieldPathArrayOfValues {
	fpaov, err := ParseActivityLogRequestRouting_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type ActivityLogRequestRouting_FieldTerminalPathArrayOfValues struct {
	ActivityLogRequestRouting_FieldTerminalPath
	values interface{}
}

var _ ActivityLogRequestRouting_FieldPathArrayOfValues = (*ActivityLogRequestRouting_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *ActivityLogRequestRouting_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case ActivityLogRequestRouting_FieldPathSelectorViaRegion:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case ActivityLogRequestRouting_FieldPathSelectorDestRegions:
		for _, v := range fpaov.values.([][]string) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *ActivityLogRequestRouting_FieldTerminalPathArrayOfValues) AsViaRegionArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *ActivityLogRequestRouting_FieldTerminalPathArrayOfValues) AsDestRegionsArrayOfValues() ([][]string, bool) {
	res, ok := fpaov.values.([][]string)
	return res, ok
}

// FieldPath provides implementation to handle
// https://github.com/protocolbuffers/protobuf/blob/master/src/google/protobuf/field_mask.proto
type ActivityLogResource_FieldPath interface {
	gotenobject.FieldPath
	Selector() ActivityLogResource_FieldPathSelector
	Get(source *ActivityLog_Resource) []interface{}
	GetSingle(source *ActivityLog_Resource) (interface{}, bool)
	ClearValue(item *ActivityLog_Resource)

	// Those methods build corresponding ActivityLogResource_FieldPathValue
	// (or array of values) and holds passed value. Panics if injected type is incorrect.
	WithIValue(value interface{}) ActivityLogResource_FieldPathValue
	WithIArrayOfValues(values interface{}) ActivityLogResource_FieldPathArrayOfValues
	WithIArrayItemValue(value interface{}) ActivityLogResource_FieldPathArrayItemValue
}

type ActivityLogResource_FieldPathSelector int32

const (
	ActivityLogResource_FieldPathSelectorName       ActivityLogResource_FieldPathSelector = 0
	ActivityLogResource_FieldPathSelectorDifference ActivityLogResource_FieldPathSelector = 1
)

func (s ActivityLogResource_FieldPathSelector) String() string {
	switch s {
	case ActivityLogResource_FieldPathSelectorName:
		return "name"
	case ActivityLogResource_FieldPathSelectorDifference:
		return "difference"
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_Resource: %d", s))
	}
}

func BuildActivityLogResource_FieldPath(fp gotenobject.RawFieldPath) (ActivityLogResource_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object ActivityLog_Resource")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "name":
			return &ActivityLogResource_FieldTerminalPath{selector: ActivityLogResource_FieldPathSelectorName}, nil
		case "difference":
			return &ActivityLogResource_FieldTerminalPath{selector: ActivityLogResource_FieldPathSelectorDifference}, nil
		}
	} else {
		switch fp[0] {
		case "difference":
			if subpath, err := BuildActivityLogResourceDifference_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &ActivityLogResource_FieldSubPath{selector: ActivityLogResource_FieldPathSelectorDifference, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object ActivityLog_Resource", fp)
}

func ParseActivityLogResource_FieldPath(rawField string) (ActivityLogResource_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildActivityLogResource_FieldPath(fp)
}

func MustParseActivityLogResource_FieldPath(rawField string) ActivityLogResource_FieldPath {
	fp, err := ParseActivityLogResource_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type ActivityLogResource_FieldTerminalPath struct {
	selector ActivityLogResource_FieldPathSelector
}

var _ ActivityLogResource_FieldPath = (*ActivityLogResource_FieldTerminalPath)(nil)

func (fp *ActivityLogResource_FieldTerminalPath) Selector() ActivityLogResource_FieldPathSelector {
	return fp.selector
}

// String returns path representation in proto convention
func (fp *ActivityLogResource_FieldTerminalPath) String() string {
	return fp.selector.String()
}

// JSONString returns path representation is JSON convention
func (fp *ActivityLogResource_FieldTerminalPath) JSONString() string {
	return strcase.ToLowerCamel(fp.String())
}

// Get returns all values pointed by specific field from source ActivityLog_Resource
func (fp *ActivityLogResource_FieldTerminalPath) Get(source *ActivityLog_Resource) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case ActivityLogResource_FieldPathSelectorName:
			values = append(values, source.Name)
		case ActivityLogResource_FieldPathSelectorDifference:
			if source.Difference != nil {
				values = append(values, source.Difference)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for ActivityLog_Resource: %d", fp.selector))
		}
	}
	return
}

func (fp *ActivityLogResource_FieldTerminalPath) GetRaw(source proto.Message) []interface{} {
	return fp.Get(source.(*ActivityLog_Resource))
}

// GetSingle returns value pointed by specific field of from source ActivityLog_Resource
func (fp *ActivityLogResource_FieldTerminalPath) GetSingle(source *ActivityLog_Resource) (interface{}, bool) {
	switch fp.selector {
	case ActivityLogResource_FieldPathSelectorName:
		return source.GetName(), source != nil
	case ActivityLogResource_FieldPathSelectorDifference:
		res := source.GetDifference()
		return res, res != nil
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_Resource: %d", fp.selector))
	}
}

func (fp *ActivityLogResource_FieldTerminalPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fp.GetSingle(source.(*ActivityLog_Resource))
}

// GetDefault returns a default value of the field type
func (fp *ActivityLogResource_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case ActivityLogResource_FieldPathSelectorName:
		return ""
	case ActivityLogResource_FieldPathSelectorDifference:
		return (*ActivityLog_Resource_Difference)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_Resource: %d", fp.selector))
	}
}

func (fp *ActivityLogResource_FieldTerminalPath) ClearValue(item *ActivityLog_Resource) {
	if item != nil {
		switch fp.selector {
		case ActivityLogResource_FieldPathSelectorName:
			item.Name = ""
		case ActivityLogResource_FieldPathSelectorDifference:
			item.Difference = nil
		default:
			panic(fmt.Sprintf("Invalid selector for ActivityLog_Resource: %d", fp.selector))
		}
	}
}

func (fp *ActivityLogResource_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*ActivityLog_Resource))
}

// IsLeaf - whether field path is holds simple value
func (fp *ActivityLogResource_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == ActivityLogResource_FieldPathSelectorName
}

func (fp *ActivityLogResource_FieldTerminalPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
	return []gotenobject.FieldPath{fp}
}

func (fp *ActivityLogResource_FieldTerminalPath) WithIValue(value interface{}) ActivityLogResource_FieldPathValue {
	switch fp.selector {
	case ActivityLogResource_FieldPathSelectorName:
		return &ActivityLogResource_FieldTerminalPathValue{ActivityLogResource_FieldTerminalPath: *fp, value: value.(string)}
	case ActivityLogResource_FieldPathSelectorDifference:
		return &ActivityLogResource_FieldTerminalPathValue{ActivityLogResource_FieldTerminalPath: *fp, value: value.(*ActivityLog_Resource_Difference)}
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_Resource: %d", fp.selector))
	}
}

func (fp *ActivityLogResource_FieldTerminalPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
	return fp.WithIValue(value)
}

func (fp *ActivityLogResource_FieldTerminalPath) WithIArrayOfValues(values interface{}) ActivityLogResource_FieldPathArrayOfValues {
	fpaov := &ActivityLogResource_FieldTerminalPathArrayOfValues{ActivityLogResource_FieldTerminalPath: *fp}
	switch fp.selector {
	case ActivityLogResource_FieldPathSelectorName:
		return &ActivityLogResource_FieldTerminalPathArrayOfValues{ActivityLogResource_FieldTerminalPath: *fp, values: values.([]string)}
	case ActivityLogResource_FieldPathSelectorDifference:
		return &ActivityLogResource_FieldTerminalPathArrayOfValues{ActivityLogResource_FieldTerminalPath: *fp, values: values.([]*ActivityLog_Resource_Difference)}
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_Resource: %d", fp.selector))
	}
	return fpaov
}

func (fp *ActivityLogResource_FieldTerminalPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
	return fp.WithIArrayOfValues(values)
}

func (fp *ActivityLogResource_FieldTerminalPath) WithIArrayItemValue(value interface{}) ActivityLogResource_FieldPathArrayItemValue {
	switch fp.selector {
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_Resource: %d", fp.selector))
	}
}

func (fp *ActivityLogResource_FieldTerminalPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
	return fp.WithIArrayItemValue(value)
}

type ActivityLogResource_FieldSubPath struct {
	selector ActivityLogResource_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ ActivityLogResource_FieldPath = (*ActivityLogResource_FieldSubPath)(nil)

func (fps *ActivityLogResource_FieldSubPath) Selector() ActivityLogResource_FieldPathSelector {
	return fps.selector
}
func (fps *ActivityLogResource_FieldSubPath) AsDifferenceSubPath() (ActivityLogResourceDifference_FieldPath, bool) {
	res, ok := fps.subPath.(ActivityLogResourceDifference_FieldPath)
	return res, ok
}

// String returns path representation in proto convention
func (fps *ActivityLogResource_FieldSubPath) String() string {
	return fps.selector.String() + "." + fps.subPath.String()
}

// JSONString returns path representation is JSON convention
func (fps *ActivityLogResource_FieldSubPath) JSONString() string {
	return strcase.ToLowerCamel(fps.selector.String()) + "." + fps.subPath.JSONString()
}

// Get returns all values pointed by selected field from source ActivityLog_Resource
func (fps *ActivityLogResource_FieldSubPath) Get(source *ActivityLog_Resource) (values []interface{}) {
	switch fps.selector {
	case ActivityLogResource_FieldPathSelectorDifference:
		values = append(values, fps.subPath.GetRaw(source.GetDifference())...)
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_Resource: %d", fps.selector))
	}
	return
}

func (fps *ActivityLogResource_FieldSubPath) GetRaw(source proto.Message) []interface{} {
	return fps.Get(source.(*ActivityLog_Resource))
}

// GetSingle returns value of selected field from source ActivityLog_Resource
func (fps *ActivityLogResource_FieldSubPath) GetSingle(source *ActivityLog_Resource) (interface{}, bool) {
	switch fps.selector {
	case ActivityLogResource_FieldPathSelectorDifference:
		if source.GetDifference() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetDifference())
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_Resource: %d", fps.selector))
	}
}

func (fps *ActivityLogResource_FieldSubPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fps.GetSingle(source.(*ActivityLog_Resource))
}

// GetDefault returns a default value of the field type
func (fps *ActivityLogResource_FieldSubPath) GetDefault() interface{} {
	return fps.subPath.GetDefault()
}

func (fps *ActivityLogResource_FieldSubPath) ClearValue(item *ActivityLog_Resource) {
	if item != nil {
		switch fps.selector {
		case ActivityLogResource_FieldPathSelectorDifference:
			fps.subPath.ClearValueRaw(item.Difference)
		default:
			panic(fmt.Sprintf("Invalid selector for ActivityLog_Resource: %d", fps.selector))
		}
	}
}

func (fps *ActivityLogResource_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*ActivityLog_Resource))
}

// IsLeaf - whether field path is holds simple value
func (fps *ActivityLogResource_FieldSubPath) IsLeaf() bool {
	return fps.subPath.IsLeaf()
}

func (fps *ActivityLogResource_FieldSubPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
	iPaths := []gotenobject.FieldPath{&ActivityLogResource_FieldTerminalPath{selector: fps.selector}}
	iPaths = append(iPaths, fps.subPath.SplitIntoTerminalIPaths()...)
	return iPaths
}

func (fps *ActivityLogResource_FieldSubPath) WithIValue(value interface{}) ActivityLogResource_FieldPathValue {
	return &ActivityLogResource_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

func (fps *ActivityLogResource_FieldSubPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
	return fps.WithIValue(value)
}

func (fps *ActivityLogResource_FieldSubPath) WithIArrayOfValues(values interface{}) ActivityLogResource_FieldPathArrayOfValues {
	return &ActivityLogResource_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

func (fps *ActivityLogResource_FieldSubPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
	return fps.WithIArrayOfValues(values)
}

func (fps *ActivityLogResource_FieldSubPath) WithIArrayItemValue(value interface{}) ActivityLogResource_FieldPathArrayItemValue {
	return &ActivityLogResource_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

func (fps *ActivityLogResource_FieldSubPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
	return fps.WithIArrayItemValue(value)
}

// ActivityLogResource_FieldPathValue allows storing values for Resource fields according to their type
type ActivityLogResource_FieldPathValue interface {
	ActivityLogResource_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **ActivityLog_Resource)
	CompareWith(*ActivityLog_Resource) (cmp int, comparable bool)
}

func ParseActivityLogResource_FieldPathValue(pathStr, valueStr string) (ActivityLogResource_FieldPathValue, error) {
	fp, err := ParseActivityLogResource_FieldPath(pathStr)
	if err != nil {
		return nil, err
	}
	fpv, err := gotenobject.ParseFieldPathValue(fp, valueStr)
	if err != nil {
		return nil, status.Errorf(codes.InvalidArgument, "error parsing Resource field path value from %s: %v", valueStr, err)
	}
	return fpv.(ActivityLogResource_FieldPathValue), nil
}

func MustParseActivityLogResource_FieldPathValue(pathStr, valueStr string) ActivityLogResource_FieldPathValue {
	fpv, err := ParseActivityLogResource_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type ActivityLogResource_FieldTerminalPathValue struct {
	ActivityLogResource_FieldTerminalPath
	value interface{}
}

var _ ActivityLogResource_FieldPathValue = (*ActivityLogResource_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'Resource' as interface{}
func (fpv *ActivityLogResource_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *ActivityLogResource_FieldTerminalPathValue) AsNameValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *ActivityLogResource_FieldTerminalPathValue) AsDifferenceValue() (*ActivityLog_Resource_Difference, bool) {
	res, ok := fpv.value.(*ActivityLog_Resource_Difference)
	return res, ok
}

// SetTo stores value for selected field for object Resource
func (fpv *ActivityLogResource_FieldTerminalPathValue) SetTo(target **ActivityLog_Resource) {
	if *target == nil {
		*target = new(ActivityLog_Resource)
	}
	switch fpv.selector {
	case ActivityLogResource_FieldPathSelectorName:
		(*target).Name = fpv.value.(string)
	case ActivityLogResource_FieldPathSelectorDifference:
		(*target).Difference = fpv.value.(*ActivityLog_Resource_Difference)
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_Resource: %d", fpv.selector))
	}
}

func (fpv *ActivityLogResource_FieldTerminalPathValue) SetToRaw(target proto.Message) {
	typedObject := target.(*ActivityLog_Resource)
	fpv.SetTo(&typedObject)
}

// CompareWith compares value in the 'ActivityLogResource_FieldTerminalPathValue' with the value under path in 'ActivityLog_Resource'.
func (fpv *ActivityLogResource_FieldTerminalPathValue) CompareWith(source *ActivityLog_Resource) (int, bool) {
	switch fpv.selector {
	case ActivityLogResource_FieldPathSelectorName:
		leftValue := fpv.value.(string)
		rightValue := source.GetName()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case ActivityLogResource_FieldPathSelectorDifference:
		return 0, false
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_Resource: %d", fpv.selector))
	}
}

func (fpv *ActivityLogResource_FieldTerminalPathValue) CompareWithRaw(source proto.Message) (int, bool) {
	return fpv.CompareWith(source.(*ActivityLog_Resource))
}

type ActivityLogResource_FieldSubPathValue struct {
	ActivityLogResource_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ ActivityLogResource_FieldPathValue = (*ActivityLogResource_FieldSubPathValue)(nil)

func (fpvs *ActivityLogResource_FieldSubPathValue) AsDifferencePathValue() (ActivityLogResourceDifference_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(ActivityLogResourceDifference_FieldPathValue)
	return res, ok
}

func (fpvs *ActivityLogResource_FieldSubPathValue) SetTo(target **ActivityLog_Resource) {
	if *target == nil {
		*target = new(ActivityLog_Resource)
	}
	switch fpvs.Selector() {
	case ActivityLogResource_FieldPathSelectorDifference:
		fpvs.subPathValue.(ActivityLogResourceDifference_FieldPathValue).SetTo(&(*target).Difference)
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_Resource: %d", fpvs.Selector()))
	}
}

func (fpvs *ActivityLogResource_FieldSubPathValue) SetToRaw(target proto.Message) {
	typedObject := target.(*ActivityLog_Resource)
	fpvs.SetTo(&typedObject)
}

func (fpvs *ActivityLogResource_FieldSubPathValue) GetRawValue() interface{} {
	return fpvs.subPathValue.GetRawValue()
}

func (fpvs *ActivityLogResource_FieldSubPathValue) CompareWith(source *ActivityLog_Resource) (int, bool) {
	switch fpvs.Selector() {
	case ActivityLogResource_FieldPathSelectorDifference:
		return fpvs.subPathValue.(ActivityLogResourceDifference_FieldPathValue).CompareWith(source.GetDifference())
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_Resource: %d", fpvs.Selector()))
	}
}

func (fpvs *ActivityLogResource_FieldSubPathValue) CompareWithRaw(source proto.Message) (int, bool) {
	return fpvs.CompareWith(source.(*ActivityLog_Resource))
}

// ActivityLogResource_FieldPathArrayItemValue allows storing single item in Path-specific values for Resource according to their type
// Present only for array (repeated) types.
type ActivityLogResource_FieldPathArrayItemValue interface {
	gotenobject.FieldPathArrayItemValue
	ActivityLogResource_FieldPath
	ContainsValue(*ActivityLog_Resource) bool
}

// ParseActivityLogResource_FieldPathArrayItemValue parses string and JSON-encoded value to its Value
func ParseActivityLogResource_FieldPathArrayItemValue(pathStr, valueStr string) (ActivityLogResource_FieldPathArrayItemValue, error) {
	fp, err := ParseActivityLogResource_FieldPath(pathStr)
	if err != nil {
		return nil, err
	}
	fpaiv, err := gotenobject.ParseFieldPathArrayItemValue(fp, valueStr)
	if err != nil {
		return nil, status.Errorf(codes.InvalidArgument, "error parsing Resource field path array item value from %s: %v", valueStr, err)
	}
	return fpaiv.(ActivityLogResource_FieldPathArrayItemValue), nil
}

func MustParseActivityLogResource_FieldPathArrayItemValue(pathStr, valueStr string) ActivityLogResource_FieldPathArrayItemValue {
	fpaiv, err := ParseActivityLogResource_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type ActivityLogResource_FieldTerminalPathArrayItemValue struct {
	ActivityLogResource_FieldTerminalPath
	value interface{}
}

var _ ActivityLogResource_FieldPathArrayItemValue = (*ActivityLogResource_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object ActivityLog_Resource as interface{}
func (fpaiv *ActivityLogResource_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}

func (fpaiv *ActivityLogResource_FieldTerminalPathArrayItemValue) GetSingle(source *ActivityLog_Resource) (interface{}, bool) {
	return nil, false
}

func (fpaiv *ActivityLogResource_FieldTerminalPathArrayItemValue) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fpaiv.GetSingle(source.(*ActivityLog_Resource))
}

// Contains returns a boolean indicating if value that is being held is present in given 'Resource'
func (fpaiv *ActivityLogResource_FieldTerminalPathArrayItemValue) ContainsValue(source *ActivityLog_Resource) bool {
	slice := fpaiv.ActivityLogResource_FieldTerminalPath.Get(source)
	for _, v := range slice {
		if asProtoMsg, ok := fpaiv.value.(proto.Message); ok {
			if proto.Equal(asProtoMsg, v.(proto.Message)) {
				return true
			}
		} else if reflect.DeepEqual(v, fpaiv.value) {
			return true
		}
	}
	return false
}

type ActivityLogResource_FieldSubPathArrayItemValue struct {
	ActivityLogResource_FieldPath
	subPathItemValue gotenobject.FieldPathArrayItemValue
}

// GetRawValue returns stored array item value
func (fpaivs *ActivityLogResource_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *ActivityLogResource_FieldSubPathArrayItemValue) AsDifferencePathItemValue() (ActivityLogResourceDifference_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(ActivityLogResourceDifference_FieldPathArrayItemValue)
	return res, ok
}

// Contains returns a boolean indicating if value that is being held is present in given 'Resource'
func (fpaivs *ActivityLogResource_FieldSubPathArrayItemValue) ContainsValue(source *ActivityLog_Resource) bool {
	switch fpaivs.Selector() {
	case ActivityLogResource_FieldPathSelectorDifference:
		return fpaivs.subPathItemValue.(ActivityLogResourceDifference_FieldPathArrayItemValue).ContainsValue(source.GetDifference())
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_Resource: %d", fpaivs.Selector()))
	}
}

// ActivityLogResource_FieldPathArrayOfValues allows storing slice of values for Resource fields according to their type
type ActivityLogResource_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	ActivityLogResource_FieldPath
}

func ParseActivityLogResource_FieldPathArrayOfValues(pathStr, valuesStr string) (ActivityLogResource_FieldPathArrayOfValues, error) {
	fp, err := ParseActivityLogResource_FieldPath(pathStr)
	if err != nil {
		return nil, err
	}
	fpaov, err := gotenobject.ParseFieldPathArrayOfValues(fp, valuesStr)
	if err != nil {
		return nil, status.Errorf(codes.InvalidArgument, "error parsing Resource field path array of values from %s: %v", valuesStr, err)
	}
	return fpaov.(ActivityLogResource_FieldPathArrayOfValues), nil
}

func MustParseActivityLogResource_FieldPathArrayOfValues(pathStr, valuesStr string) ActivityLogResource_FieldPathArrayOfValues {
	fpaov, err := ParseActivityLogResource_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type ActivityLogResource_FieldTerminalPathArrayOfValues struct {
	ActivityLogResource_FieldTerminalPath
	values interface{}
}

var _ ActivityLogResource_FieldPathArrayOfValues = (*ActivityLogResource_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *ActivityLogResource_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case ActivityLogResource_FieldPathSelectorName:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case ActivityLogResource_FieldPathSelectorDifference:
		for _, v := range fpaov.values.([]*ActivityLog_Resource_Difference) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *ActivityLogResource_FieldTerminalPathArrayOfValues) AsNameArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *ActivityLogResource_FieldTerminalPathArrayOfValues) AsDifferenceArrayOfValues() ([]*ActivityLog_Resource_Difference, bool) {
	res, ok := fpaov.values.([]*ActivityLog_Resource_Difference)
	return res, ok
}

type ActivityLogResource_FieldSubPathArrayOfValues struct {
	ActivityLogResource_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ ActivityLogResource_FieldPathArrayOfValues = (*ActivityLogResource_FieldSubPathArrayOfValues)(nil)

func (fpsaov *ActivityLogResource_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *ActivityLogResource_FieldSubPathArrayOfValues) AsDifferencePathArrayOfValues() (ActivityLogResourceDifference_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(ActivityLogResourceDifference_FieldPathArrayOfValues)
	return res, ok
}

// FieldPath provides implementation to handle
// https://github.com/protocolbuffers/protobuf/blob/master/src/google/protobuf/field_mask.proto
type ActivityLogEventClientMsgEvent_FieldPath interface {
	gotenobject.FieldPath
	Selector() ActivityLogEventClientMsgEvent_FieldPathSelector
	Get(source *ActivityLog_Event_ClientMsgEvent) []interface{}
	GetSingle(source *ActivityLog_Event_ClientMsgEvent) (interface{}, bool)
	ClearValue(item *ActivityLog_Event_ClientMsgEvent)

	// Those methods build corresponding ActivityLogEventClientMsgEvent_FieldPathValue
	// (or array of values) and holds passed value. Panics if injected type is incorrect.
	WithIValue(value interface{}) ActivityLogEventClientMsgEvent_FieldPathValue
	WithIArrayOfValues(values interface{}) ActivityLogEventClientMsgEvent_FieldPathArrayOfValues
	WithIArrayItemValue(value interface{}) ActivityLogEventClientMsgEvent_FieldPathArrayItemValue
}

type ActivityLogEventClientMsgEvent_FieldPathSelector int32

const (
	ActivityLogEventClientMsgEvent_FieldPathSelectorData ActivityLogEventClientMsgEvent_FieldPathSelector = 0
	ActivityLogEventClientMsgEvent_FieldPathSelectorTime ActivityLogEventClientMsgEvent_FieldPathSelector = 1
)

func (s ActivityLogEventClientMsgEvent_FieldPathSelector) String() string {
	switch s {
	case ActivityLogEventClientMsgEvent_FieldPathSelectorData:
		return "data"
	case ActivityLogEventClientMsgEvent_FieldPathSelectorTime:
		return "time"
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_Event_ClientMsgEvent: %d", s))
	}
}

func BuildActivityLogEventClientMsgEvent_FieldPath(fp gotenobject.RawFieldPath) (ActivityLogEventClientMsgEvent_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object ActivityLog_Event_ClientMsgEvent")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "data":
			return &ActivityLogEventClientMsgEvent_FieldTerminalPath{selector: ActivityLogEventClientMsgEvent_FieldPathSelectorData}, nil
		case "time":
			return &ActivityLogEventClientMsgEvent_FieldTerminalPath{selector: ActivityLogEventClientMsgEvent_FieldPathSelectorTime}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object ActivityLog_Event_ClientMsgEvent", fp)
}

func ParseActivityLogEventClientMsgEvent_FieldPath(rawField string) (ActivityLogEventClientMsgEvent_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildActivityLogEventClientMsgEvent_FieldPath(fp)
}

func MustParseActivityLogEventClientMsgEvent_FieldPath(rawField string) ActivityLogEventClientMsgEvent_FieldPath {
	fp, err := ParseActivityLogEventClientMsgEvent_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type ActivityLogEventClientMsgEvent_FieldTerminalPath struct {
	selector ActivityLogEventClientMsgEvent_FieldPathSelector
}

var _ ActivityLogEventClientMsgEvent_FieldPath = (*ActivityLogEventClientMsgEvent_FieldTerminalPath)(nil)

func (fp *ActivityLogEventClientMsgEvent_FieldTerminalPath) Selector() ActivityLogEventClientMsgEvent_FieldPathSelector {
	return fp.selector
}

// String returns path representation in proto convention
func (fp *ActivityLogEventClientMsgEvent_FieldTerminalPath) String() string {
	return fp.selector.String()
}

// JSONString returns path representation is JSON convention
func (fp *ActivityLogEventClientMsgEvent_FieldTerminalPath) JSONString() string {
	return strcase.ToLowerCamel(fp.String())
}

// Get returns all values pointed by specific field from source ActivityLog_Event_ClientMsgEvent
func (fp *ActivityLogEventClientMsgEvent_FieldTerminalPath) Get(source *ActivityLog_Event_ClientMsgEvent) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case ActivityLogEventClientMsgEvent_FieldPathSelectorData:
			if source.Data != nil {
				values = append(values, source.Data)
			}
		case ActivityLogEventClientMsgEvent_FieldPathSelectorTime:
			if source.Time != nil {
				values = append(values, source.Time)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for ActivityLog_Event_ClientMsgEvent: %d", fp.selector))
		}
	}
	return
}

func (fp *ActivityLogEventClientMsgEvent_FieldTerminalPath) GetRaw(source proto.Message) []interface{} {
	return fp.Get(source.(*ActivityLog_Event_ClientMsgEvent))
}

// GetSingle returns value pointed by specific field of from source ActivityLog_Event_ClientMsgEvent
func (fp *ActivityLogEventClientMsgEvent_FieldTerminalPath) GetSingle(source *ActivityLog_Event_ClientMsgEvent) (interface{}, bool) {
	switch fp.selector {
	case ActivityLogEventClientMsgEvent_FieldPathSelectorData:
		res := source.GetData()
		return res, res != nil
	case ActivityLogEventClientMsgEvent_FieldPathSelectorTime:
		res := source.GetTime()
		return res, res != nil
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_Event_ClientMsgEvent: %d", fp.selector))
	}
}

func (fp *ActivityLogEventClientMsgEvent_FieldTerminalPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fp.GetSingle(source.(*ActivityLog_Event_ClientMsgEvent))
}

// GetDefault returns a default value of the field type
func (fp *ActivityLogEventClientMsgEvent_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case ActivityLogEventClientMsgEvent_FieldPathSelectorData:
		return (*anypb.Any)(nil)
	case ActivityLogEventClientMsgEvent_FieldPathSelectorTime:
		return (*timestamppb.Timestamp)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_Event_ClientMsgEvent: %d", fp.selector))
	}
}

func (fp *ActivityLogEventClientMsgEvent_FieldTerminalPath) ClearValue(item *ActivityLog_Event_ClientMsgEvent) {
	if item != nil {
		switch fp.selector {
		case ActivityLogEventClientMsgEvent_FieldPathSelectorData:
			item.Data = nil
		case ActivityLogEventClientMsgEvent_FieldPathSelectorTime:
			item.Time = nil
		default:
			panic(fmt.Sprintf("Invalid selector for ActivityLog_Event_ClientMsgEvent: %d", fp.selector))
		}
	}
}

func (fp *ActivityLogEventClientMsgEvent_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*ActivityLog_Event_ClientMsgEvent))
}

// IsLeaf - whether field path is holds simple value
func (fp *ActivityLogEventClientMsgEvent_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == ActivityLogEventClientMsgEvent_FieldPathSelectorData ||
		fp.selector == ActivityLogEventClientMsgEvent_FieldPathSelectorTime
}

func (fp *ActivityLogEventClientMsgEvent_FieldTerminalPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
	return []gotenobject.FieldPath{fp}
}

func (fp *ActivityLogEventClientMsgEvent_FieldTerminalPath) WithIValue(value interface{}) ActivityLogEventClientMsgEvent_FieldPathValue {
	switch fp.selector {
	case ActivityLogEventClientMsgEvent_FieldPathSelectorData:
		return &ActivityLogEventClientMsgEvent_FieldTerminalPathValue{ActivityLogEventClientMsgEvent_FieldTerminalPath: *fp, value: value.(*anypb.Any)}
	case ActivityLogEventClientMsgEvent_FieldPathSelectorTime:
		return &ActivityLogEventClientMsgEvent_FieldTerminalPathValue{ActivityLogEventClientMsgEvent_FieldTerminalPath: *fp, value: value.(*timestamppb.Timestamp)}
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_Event_ClientMsgEvent: %d", fp.selector))
	}
}

func (fp *ActivityLogEventClientMsgEvent_FieldTerminalPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
	return fp.WithIValue(value)
}

func (fp *ActivityLogEventClientMsgEvent_FieldTerminalPath) WithIArrayOfValues(values interface{}) ActivityLogEventClientMsgEvent_FieldPathArrayOfValues {
	fpaov := &ActivityLogEventClientMsgEvent_FieldTerminalPathArrayOfValues{ActivityLogEventClientMsgEvent_FieldTerminalPath: *fp}
	switch fp.selector {
	case ActivityLogEventClientMsgEvent_FieldPathSelectorData:
		return &ActivityLogEventClientMsgEvent_FieldTerminalPathArrayOfValues{ActivityLogEventClientMsgEvent_FieldTerminalPath: *fp, values: values.([]*anypb.Any)}
	case ActivityLogEventClientMsgEvent_FieldPathSelectorTime:
		return &ActivityLogEventClientMsgEvent_FieldTerminalPathArrayOfValues{ActivityLogEventClientMsgEvent_FieldTerminalPath: *fp, values: values.([]*timestamppb.Timestamp)}
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_Event_ClientMsgEvent: %d", fp.selector))
	}
	return fpaov
}

func (fp *ActivityLogEventClientMsgEvent_FieldTerminalPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
	return fp.WithIArrayOfValues(values)
}

func (fp *ActivityLogEventClientMsgEvent_FieldTerminalPath) WithIArrayItemValue(value interface{}) ActivityLogEventClientMsgEvent_FieldPathArrayItemValue {
	switch fp.selector {
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_Event_ClientMsgEvent: %d", fp.selector))
	}
}

func (fp *ActivityLogEventClientMsgEvent_FieldTerminalPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
	return fp.WithIArrayItemValue(value)
}

// ActivityLogEventClientMsgEvent_FieldPathValue allows storing values for ClientMsgEvent fields according to their type
type ActivityLogEventClientMsgEvent_FieldPathValue interface {
	ActivityLogEventClientMsgEvent_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **ActivityLog_Event_ClientMsgEvent)
	CompareWith(*ActivityLog_Event_ClientMsgEvent) (cmp int, comparable bool)
}

func ParseActivityLogEventClientMsgEvent_FieldPathValue(pathStr, valueStr string) (ActivityLogEventClientMsgEvent_FieldPathValue, error) {
	fp, err := ParseActivityLogEventClientMsgEvent_FieldPath(pathStr)
	if err != nil {
		return nil, err
	}
	fpv, err := gotenobject.ParseFieldPathValue(fp, valueStr)
	if err != nil {
		return nil, status.Errorf(codes.InvalidArgument, "error parsing ClientMsgEvent field path value from %s: %v", valueStr, err)
	}
	return fpv.(ActivityLogEventClientMsgEvent_FieldPathValue), nil
}

func MustParseActivityLogEventClientMsgEvent_FieldPathValue(pathStr, valueStr string) ActivityLogEventClientMsgEvent_FieldPathValue {
	fpv, err := ParseActivityLogEventClientMsgEvent_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type ActivityLogEventClientMsgEvent_FieldTerminalPathValue struct {
	ActivityLogEventClientMsgEvent_FieldTerminalPath
	value interface{}
}

var _ ActivityLogEventClientMsgEvent_FieldPathValue = (*ActivityLogEventClientMsgEvent_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'ClientMsgEvent' as interface{}
func (fpv *ActivityLogEventClientMsgEvent_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *ActivityLogEventClientMsgEvent_FieldTerminalPathValue) AsDataValue() (*anypb.Any, bool) {
	res, ok := fpv.value.(*anypb.Any)
	return res, ok
}
func (fpv *ActivityLogEventClientMsgEvent_FieldTerminalPathValue) AsTimeValue() (*timestamppb.Timestamp, bool) {
	res, ok := fpv.value.(*timestamppb.Timestamp)
	return res, ok
}

// SetTo stores value for selected field for object ClientMsgEvent
func (fpv *ActivityLogEventClientMsgEvent_FieldTerminalPathValue) SetTo(target **ActivityLog_Event_ClientMsgEvent) {
	if *target == nil {
		*target = new(ActivityLog_Event_ClientMsgEvent)
	}
	switch fpv.selector {
	case ActivityLogEventClientMsgEvent_FieldPathSelectorData:
		(*target).Data = fpv.value.(*anypb.Any)
	case ActivityLogEventClientMsgEvent_FieldPathSelectorTime:
		(*target).Time = fpv.value.(*timestamppb.Timestamp)
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_Event_ClientMsgEvent: %d", fpv.selector))
	}
}

func (fpv *ActivityLogEventClientMsgEvent_FieldTerminalPathValue) SetToRaw(target proto.Message) {
	typedObject := target.(*ActivityLog_Event_ClientMsgEvent)
	fpv.SetTo(&typedObject)
}

// CompareWith compares value in the 'ActivityLogEventClientMsgEvent_FieldTerminalPathValue' with the value under path in 'ActivityLog_Event_ClientMsgEvent'.
func (fpv *ActivityLogEventClientMsgEvent_FieldTerminalPathValue) CompareWith(source *ActivityLog_Event_ClientMsgEvent) (int, bool) {
	switch fpv.selector {
	case ActivityLogEventClientMsgEvent_FieldPathSelectorData:
		return 0, false
	case ActivityLogEventClientMsgEvent_FieldPathSelectorTime:
		leftValue := fpv.value.(*timestamppb.Timestamp)
		rightValue := source.GetTime()
		if leftValue == nil {
			if rightValue != nil {
				return -1, true
			}
			return 0, true
		}
		if rightValue == nil {
			return 1, true
		}
		if leftValue.AsTime().Equal(rightValue.AsTime()) {
			return 0, true
		} else if leftValue.AsTime().Before(rightValue.AsTime()) {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_Event_ClientMsgEvent: %d", fpv.selector))
	}
}

func (fpv *ActivityLogEventClientMsgEvent_FieldTerminalPathValue) CompareWithRaw(source proto.Message) (int, bool) {
	return fpv.CompareWith(source.(*ActivityLog_Event_ClientMsgEvent))
}

// ActivityLogEventClientMsgEvent_FieldPathArrayItemValue allows storing single item in Path-specific values for ClientMsgEvent according to their type
// Present only for array (repeated) types.
type ActivityLogEventClientMsgEvent_FieldPathArrayItemValue interface {
	gotenobject.FieldPathArrayItemValue
	ActivityLogEventClientMsgEvent_FieldPath
	ContainsValue(*ActivityLog_Event_ClientMsgEvent) bool
}

// ParseActivityLogEventClientMsgEvent_FieldPathArrayItemValue parses string and JSON-encoded value to its Value
func ParseActivityLogEventClientMsgEvent_FieldPathArrayItemValue(pathStr, valueStr string) (ActivityLogEventClientMsgEvent_FieldPathArrayItemValue, error) {
	fp, err := ParseActivityLogEventClientMsgEvent_FieldPath(pathStr)
	if err != nil {
		return nil, err
	}
	fpaiv, err := gotenobject.ParseFieldPathArrayItemValue(fp, valueStr)
	if err != nil {
		return nil, status.Errorf(codes.InvalidArgument, "error parsing ClientMsgEvent field path array item value from %s: %v", valueStr, err)
	}
	return fpaiv.(ActivityLogEventClientMsgEvent_FieldPathArrayItemValue), nil
}

func MustParseActivityLogEventClientMsgEvent_FieldPathArrayItemValue(pathStr, valueStr string) ActivityLogEventClientMsgEvent_FieldPathArrayItemValue {
	fpaiv, err := ParseActivityLogEventClientMsgEvent_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type ActivityLogEventClientMsgEvent_FieldTerminalPathArrayItemValue struct {
	ActivityLogEventClientMsgEvent_FieldTerminalPath
	value interface{}
}

var _ ActivityLogEventClientMsgEvent_FieldPathArrayItemValue = (*ActivityLogEventClientMsgEvent_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object ActivityLog_Event_ClientMsgEvent as interface{}
func (fpaiv *ActivityLogEventClientMsgEvent_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}

func (fpaiv *ActivityLogEventClientMsgEvent_FieldTerminalPathArrayItemValue) GetSingle(source *ActivityLog_Event_ClientMsgEvent) (interface{}, bool) {
	return nil, false
}

func (fpaiv *ActivityLogEventClientMsgEvent_FieldTerminalPathArrayItemValue) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fpaiv.GetSingle(source.(*ActivityLog_Event_ClientMsgEvent))
}

// Contains returns a boolean indicating if value that is being held is present in given 'ClientMsgEvent'
func (fpaiv *ActivityLogEventClientMsgEvent_FieldTerminalPathArrayItemValue) ContainsValue(source *ActivityLog_Event_ClientMsgEvent) bool {
	slice := fpaiv.ActivityLogEventClientMsgEvent_FieldTerminalPath.Get(source)
	for _, v := range slice {
		if asProtoMsg, ok := fpaiv.value.(proto.Message); ok {
			if proto.Equal(asProtoMsg, v.(proto.Message)) {
				return true
			}
		} else if reflect.DeepEqual(v, fpaiv.value) {
			return true
		}
	}
	return false
}

// ActivityLogEventClientMsgEvent_FieldPathArrayOfValues allows storing slice of values for ClientMsgEvent fields according to their type
type ActivityLogEventClientMsgEvent_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	ActivityLogEventClientMsgEvent_FieldPath
}

func ParseActivityLogEventClientMsgEvent_FieldPathArrayOfValues(pathStr, valuesStr string) (ActivityLogEventClientMsgEvent_FieldPathArrayOfValues, error) {
	fp, err := ParseActivityLogEventClientMsgEvent_FieldPath(pathStr)
	if err != nil {
		return nil, err
	}
	fpaov, err := gotenobject.ParseFieldPathArrayOfValues(fp, valuesStr)
	if err != nil {
		return nil, status.Errorf(codes.InvalidArgument, "error parsing ClientMsgEvent field path array of values from %s: %v", valuesStr, err)
	}
	return fpaov.(ActivityLogEventClientMsgEvent_FieldPathArrayOfValues), nil
}

func MustParseActivityLogEventClientMsgEvent_FieldPathArrayOfValues(pathStr, valuesStr string) ActivityLogEventClientMsgEvent_FieldPathArrayOfValues {
	fpaov, err := ParseActivityLogEventClientMsgEvent_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type ActivityLogEventClientMsgEvent_FieldTerminalPathArrayOfValues struct {
	ActivityLogEventClientMsgEvent_FieldTerminalPath
	values interface{}
}

var _ ActivityLogEventClientMsgEvent_FieldPathArrayOfValues = (*ActivityLogEventClientMsgEvent_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *ActivityLogEventClientMsgEvent_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case ActivityLogEventClientMsgEvent_FieldPathSelectorData:
		for _, v := range fpaov.values.([]*anypb.Any) {
			values = append(values, v)
		}
	case ActivityLogEventClientMsgEvent_FieldPathSelectorTime:
		for _, v := range fpaov.values.([]*timestamppb.Timestamp) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *ActivityLogEventClientMsgEvent_FieldTerminalPathArrayOfValues) AsDataArrayOfValues() ([]*anypb.Any, bool) {
	res, ok := fpaov.values.([]*anypb.Any)
	return res, ok
}
func (fpaov *ActivityLogEventClientMsgEvent_FieldTerminalPathArrayOfValues) AsTimeArrayOfValues() ([]*timestamppb.Timestamp, bool) {
	res, ok := fpaov.values.([]*timestamppb.Timestamp)
	return res, ok
}

// FieldPath provides implementation to handle
// https://github.com/protocolbuffers/protobuf/blob/master/src/google/protobuf/field_mask.proto
type ActivityLogEventRegionalServerMsgEvent_FieldPath interface {
	gotenobject.FieldPath
	Selector() ActivityLogEventRegionalServerMsgEvent_FieldPathSelector
	Get(source *ActivityLog_Event_RegionalServerMsgEvent) []interface{}
	GetSingle(source *ActivityLog_Event_RegionalServerMsgEvent) (interface{}, bool)
	ClearValue(item *ActivityLog_Event_RegionalServerMsgEvent)

	// Those methods build corresponding ActivityLogEventRegionalServerMsgEvent_FieldPathValue
	// (or array of values) and holds passed value. Panics if injected type is incorrect.
	WithIValue(value interface{}) ActivityLogEventRegionalServerMsgEvent_FieldPathValue
	WithIArrayOfValues(values interface{}) ActivityLogEventRegionalServerMsgEvent_FieldPathArrayOfValues
	WithIArrayItemValue(value interface{}) ActivityLogEventRegionalServerMsgEvent_FieldPathArrayItemValue
}

type ActivityLogEventRegionalServerMsgEvent_FieldPathSelector int32

const (
	ActivityLogEventRegionalServerMsgEvent_FieldPathSelectorData     ActivityLogEventRegionalServerMsgEvent_FieldPathSelector = 0
	ActivityLogEventRegionalServerMsgEvent_FieldPathSelectorTime     ActivityLogEventRegionalServerMsgEvent_FieldPathSelector = 1
	ActivityLogEventRegionalServerMsgEvent_FieldPathSelectorRegionId ActivityLogEventRegionalServerMsgEvent_FieldPathSelector = 2
)

func (s ActivityLogEventRegionalServerMsgEvent_FieldPathSelector) String() string {
	switch s {
	case ActivityLogEventRegionalServerMsgEvent_FieldPathSelectorData:
		return "data"
	case ActivityLogEventRegionalServerMsgEvent_FieldPathSelectorTime:
		return "time"
	case ActivityLogEventRegionalServerMsgEvent_FieldPathSelectorRegionId:
		return "region_id"
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_Event_RegionalServerMsgEvent: %d", s))
	}
}

func BuildActivityLogEventRegionalServerMsgEvent_FieldPath(fp gotenobject.RawFieldPath) (ActivityLogEventRegionalServerMsgEvent_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object ActivityLog_Event_RegionalServerMsgEvent")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "data":
			return &ActivityLogEventRegionalServerMsgEvent_FieldTerminalPath{selector: ActivityLogEventRegionalServerMsgEvent_FieldPathSelectorData}, nil
		case "time":
			return &ActivityLogEventRegionalServerMsgEvent_FieldTerminalPath{selector: ActivityLogEventRegionalServerMsgEvent_FieldPathSelectorTime}, nil
		case "region_id", "regionId", "region-id":
			return &ActivityLogEventRegionalServerMsgEvent_FieldTerminalPath{selector: ActivityLogEventRegionalServerMsgEvent_FieldPathSelectorRegionId}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object ActivityLog_Event_RegionalServerMsgEvent", fp)
}

func ParseActivityLogEventRegionalServerMsgEvent_FieldPath(rawField string) (ActivityLogEventRegionalServerMsgEvent_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildActivityLogEventRegionalServerMsgEvent_FieldPath(fp)
}

func MustParseActivityLogEventRegionalServerMsgEvent_FieldPath(rawField string) ActivityLogEventRegionalServerMsgEvent_FieldPath {
	fp, err := ParseActivityLogEventRegionalServerMsgEvent_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type ActivityLogEventRegionalServerMsgEvent_FieldTerminalPath struct {
	selector ActivityLogEventRegionalServerMsgEvent_FieldPathSelector
}

var _ ActivityLogEventRegionalServerMsgEvent_FieldPath = (*ActivityLogEventRegionalServerMsgEvent_FieldTerminalPath)(nil)

func (fp *ActivityLogEventRegionalServerMsgEvent_FieldTerminalPath) Selector() ActivityLogEventRegionalServerMsgEvent_FieldPathSelector {
	return fp.selector
}

// String returns path representation in proto convention
func (fp *ActivityLogEventRegionalServerMsgEvent_FieldTerminalPath) String() string {
	return fp.selector.String()
}

// JSONString returns path representation is JSON convention
func (fp *ActivityLogEventRegionalServerMsgEvent_FieldTerminalPath) JSONString() string {
	return strcase.ToLowerCamel(fp.String())
}

// Get returns all values pointed by specific field from source ActivityLog_Event_RegionalServerMsgEvent
func (fp *ActivityLogEventRegionalServerMsgEvent_FieldTerminalPath) Get(source *ActivityLog_Event_RegionalServerMsgEvent) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case ActivityLogEventRegionalServerMsgEvent_FieldPathSelectorData:
			if source.Data != nil {
				values = append(values, source.Data)
			}
		case ActivityLogEventRegionalServerMsgEvent_FieldPathSelectorTime:
			if source.Time != nil {
				values = append(values, source.Time)
			}
		case ActivityLogEventRegionalServerMsgEvent_FieldPathSelectorRegionId:
			values = append(values, source.RegionId)
		default:
			panic(fmt.Sprintf("Invalid selector for ActivityLog_Event_RegionalServerMsgEvent: %d", fp.selector))
		}
	}
	return
}

func (fp *ActivityLogEventRegionalServerMsgEvent_FieldTerminalPath) GetRaw(source proto.Message) []interface{} {
	return fp.Get(source.(*ActivityLog_Event_RegionalServerMsgEvent))
}

// GetSingle returns value pointed by specific field of from source ActivityLog_Event_RegionalServerMsgEvent
func (fp *ActivityLogEventRegionalServerMsgEvent_FieldTerminalPath) GetSingle(source *ActivityLog_Event_RegionalServerMsgEvent) (interface{}, bool) {
	switch fp.selector {
	case ActivityLogEventRegionalServerMsgEvent_FieldPathSelectorData:
		res := source.GetData()
		return res, res != nil
	case ActivityLogEventRegionalServerMsgEvent_FieldPathSelectorTime:
		res := source.GetTime()
		return res, res != nil
	case ActivityLogEventRegionalServerMsgEvent_FieldPathSelectorRegionId:
		return source.GetRegionId(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_Event_RegionalServerMsgEvent: %d", fp.selector))
	}
}

func (fp *ActivityLogEventRegionalServerMsgEvent_FieldTerminalPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fp.GetSingle(source.(*ActivityLog_Event_RegionalServerMsgEvent))
}

// GetDefault returns a default value of the field type
func (fp *ActivityLogEventRegionalServerMsgEvent_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case ActivityLogEventRegionalServerMsgEvent_FieldPathSelectorData:
		return (*anypb.Any)(nil)
	case ActivityLogEventRegionalServerMsgEvent_FieldPathSelectorTime:
		return (*timestamppb.Timestamp)(nil)
	case ActivityLogEventRegionalServerMsgEvent_FieldPathSelectorRegionId:
		return ""
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_Event_RegionalServerMsgEvent: %d", fp.selector))
	}
}

func (fp *ActivityLogEventRegionalServerMsgEvent_FieldTerminalPath) ClearValue(item *ActivityLog_Event_RegionalServerMsgEvent) {
	if item != nil {
		switch fp.selector {
		case ActivityLogEventRegionalServerMsgEvent_FieldPathSelectorData:
			item.Data = nil
		case ActivityLogEventRegionalServerMsgEvent_FieldPathSelectorTime:
			item.Time = nil
		case ActivityLogEventRegionalServerMsgEvent_FieldPathSelectorRegionId:
			item.RegionId = ""
		default:
			panic(fmt.Sprintf("Invalid selector for ActivityLog_Event_RegionalServerMsgEvent: %d", fp.selector))
		}
	}
}

func (fp *ActivityLogEventRegionalServerMsgEvent_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*ActivityLog_Event_RegionalServerMsgEvent))
}

// IsLeaf - whether field path is holds simple value
func (fp *ActivityLogEventRegionalServerMsgEvent_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == ActivityLogEventRegionalServerMsgEvent_FieldPathSelectorData ||
		fp.selector == ActivityLogEventRegionalServerMsgEvent_FieldPathSelectorTime ||
		fp.selector == ActivityLogEventRegionalServerMsgEvent_FieldPathSelectorRegionId
}

func (fp *ActivityLogEventRegionalServerMsgEvent_FieldTerminalPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
	return []gotenobject.FieldPath{fp}
}

func (fp *ActivityLogEventRegionalServerMsgEvent_FieldTerminalPath) WithIValue(value interface{}) ActivityLogEventRegionalServerMsgEvent_FieldPathValue {
	switch fp.selector {
	case ActivityLogEventRegionalServerMsgEvent_FieldPathSelectorData:
		return &ActivityLogEventRegionalServerMsgEvent_FieldTerminalPathValue{ActivityLogEventRegionalServerMsgEvent_FieldTerminalPath: *fp, value: value.(*anypb.Any)}
	case ActivityLogEventRegionalServerMsgEvent_FieldPathSelectorTime:
		return &ActivityLogEventRegionalServerMsgEvent_FieldTerminalPathValue{ActivityLogEventRegionalServerMsgEvent_FieldTerminalPath: *fp, value: value.(*timestamppb.Timestamp)}
	case ActivityLogEventRegionalServerMsgEvent_FieldPathSelectorRegionId:
		return &ActivityLogEventRegionalServerMsgEvent_FieldTerminalPathValue{ActivityLogEventRegionalServerMsgEvent_FieldTerminalPath: *fp, value: value.(string)}
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_Event_RegionalServerMsgEvent: %d", fp.selector))
	}
}

func (fp *ActivityLogEventRegionalServerMsgEvent_FieldTerminalPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
	return fp.WithIValue(value)
}

func (fp *ActivityLogEventRegionalServerMsgEvent_FieldTerminalPath) WithIArrayOfValues(values interface{}) ActivityLogEventRegionalServerMsgEvent_FieldPathArrayOfValues {
	fpaov := &ActivityLogEventRegionalServerMsgEvent_FieldTerminalPathArrayOfValues{ActivityLogEventRegionalServerMsgEvent_FieldTerminalPath: *fp}
	switch fp.selector {
	case ActivityLogEventRegionalServerMsgEvent_FieldPathSelectorData:
		return &ActivityLogEventRegionalServerMsgEvent_FieldTerminalPathArrayOfValues{ActivityLogEventRegionalServerMsgEvent_FieldTerminalPath: *fp, values: values.([]*anypb.Any)}
	case ActivityLogEventRegionalServerMsgEvent_FieldPathSelectorTime:
		return &ActivityLogEventRegionalServerMsgEvent_FieldTerminalPathArrayOfValues{ActivityLogEventRegionalServerMsgEvent_FieldTerminalPath: *fp, values: values.([]*timestamppb.Timestamp)}
	case ActivityLogEventRegionalServerMsgEvent_FieldPathSelectorRegionId:
		return &ActivityLogEventRegionalServerMsgEvent_FieldTerminalPathArrayOfValues{ActivityLogEventRegionalServerMsgEvent_FieldTerminalPath: *fp, values: values.([]string)}
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_Event_RegionalServerMsgEvent: %d", fp.selector))
	}
	return fpaov
}

func (fp *ActivityLogEventRegionalServerMsgEvent_FieldTerminalPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
	return fp.WithIArrayOfValues(values)
}

func (fp *ActivityLogEventRegionalServerMsgEvent_FieldTerminalPath) WithIArrayItemValue(value interface{}) ActivityLogEventRegionalServerMsgEvent_FieldPathArrayItemValue {
	switch fp.selector {
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_Event_RegionalServerMsgEvent: %d", fp.selector))
	}
}

func (fp *ActivityLogEventRegionalServerMsgEvent_FieldTerminalPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
	return fp.WithIArrayItemValue(value)
}

// ActivityLogEventRegionalServerMsgEvent_FieldPathValue allows storing values for RegionalServerMsgEvent fields according to their type
type ActivityLogEventRegionalServerMsgEvent_FieldPathValue interface {
	ActivityLogEventRegionalServerMsgEvent_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **ActivityLog_Event_RegionalServerMsgEvent)
	CompareWith(*ActivityLog_Event_RegionalServerMsgEvent) (cmp int, comparable bool)
}

func ParseActivityLogEventRegionalServerMsgEvent_FieldPathValue(pathStr, valueStr string) (ActivityLogEventRegionalServerMsgEvent_FieldPathValue, error) {
	fp, err := ParseActivityLogEventRegionalServerMsgEvent_FieldPath(pathStr)
	if err != nil {
		return nil, err
	}
	fpv, err := gotenobject.ParseFieldPathValue(fp, valueStr)
	if err != nil {
		return nil, status.Errorf(codes.InvalidArgument, "error parsing RegionalServerMsgEvent field path value from %s: %v", valueStr, err)
	}
	return fpv.(ActivityLogEventRegionalServerMsgEvent_FieldPathValue), nil
}

func MustParseActivityLogEventRegionalServerMsgEvent_FieldPathValue(pathStr, valueStr string) ActivityLogEventRegionalServerMsgEvent_FieldPathValue {
	fpv, err := ParseActivityLogEventRegionalServerMsgEvent_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type ActivityLogEventRegionalServerMsgEvent_FieldTerminalPathValue struct {
	ActivityLogEventRegionalServerMsgEvent_FieldTerminalPath
	value interface{}
}

var _ ActivityLogEventRegionalServerMsgEvent_FieldPathValue = (*ActivityLogEventRegionalServerMsgEvent_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'RegionalServerMsgEvent' as interface{}
func (fpv *ActivityLogEventRegionalServerMsgEvent_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *ActivityLogEventRegionalServerMsgEvent_FieldTerminalPathValue) AsDataValue() (*anypb.Any, bool) {
	res, ok := fpv.value.(*anypb.Any)
	return res, ok
}
func (fpv *ActivityLogEventRegionalServerMsgEvent_FieldTerminalPathValue) AsTimeValue() (*timestamppb.Timestamp, bool) {
	res, ok := fpv.value.(*timestamppb.Timestamp)
	return res, ok
}
func (fpv *ActivityLogEventRegionalServerMsgEvent_FieldTerminalPathValue) AsRegionIdValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}

// SetTo stores value for selected field for object RegionalServerMsgEvent
func (fpv *ActivityLogEventRegionalServerMsgEvent_FieldTerminalPathValue) SetTo(target **ActivityLog_Event_RegionalServerMsgEvent) {
	if *target == nil {
		*target = new(ActivityLog_Event_RegionalServerMsgEvent)
	}
	switch fpv.selector {
	case ActivityLogEventRegionalServerMsgEvent_FieldPathSelectorData:
		(*target).Data = fpv.value.(*anypb.Any)
	case ActivityLogEventRegionalServerMsgEvent_FieldPathSelectorTime:
		(*target).Time = fpv.value.(*timestamppb.Timestamp)
	case ActivityLogEventRegionalServerMsgEvent_FieldPathSelectorRegionId:
		(*target).RegionId = fpv.value.(string)
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_Event_RegionalServerMsgEvent: %d", fpv.selector))
	}
}

func (fpv *ActivityLogEventRegionalServerMsgEvent_FieldTerminalPathValue) SetToRaw(target proto.Message) {
	typedObject := target.(*ActivityLog_Event_RegionalServerMsgEvent)
	fpv.SetTo(&typedObject)
}

// CompareWith compares value in the 'ActivityLogEventRegionalServerMsgEvent_FieldTerminalPathValue' with the value under path in 'ActivityLog_Event_RegionalServerMsgEvent'.
func (fpv *ActivityLogEventRegionalServerMsgEvent_FieldTerminalPathValue) CompareWith(source *ActivityLog_Event_RegionalServerMsgEvent) (int, bool) {
	switch fpv.selector {
	case ActivityLogEventRegionalServerMsgEvent_FieldPathSelectorData:
		return 0, false
	case ActivityLogEventRegionalServerMsgEvent_FieldPathSelectorTime:
		leftValue := fpv.value.(*timestamppb.Timestamp)
		rightValue := source.GetTime()
		if leftValue == nil {
			if rightValue != nil {
				return -1, true
			}
			return 0, true
		}
		if rightValue == nil {
			return 1, true
		}
		if leftValue.AsTime().Equal(rightValue.AsTime()) {
			return 0, true
		} else if leftValue.AsTime().Before(rightValue.AsTime()) {
			return -1, true
		} else {
			return 1, true
		}
	case ActivityLogEventRegionalServerMsgEvent_FieldPathSelectorRegionId:
		leftValue := fpv.value.(string)
		rightValue := source.GetRegionId()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_Event_RegionalServerMsgEvent: %d", fpv.selector))
	}
}

func (fpv *ActivityLogEventRegionalServerMsgEvent_FieldTerminalPathValue) CompareWithRaw(source proto.Message) (int, bool) {
	return fpv.CompareWith(source.(*ActivityLog_Event_RegionalServerMsgEvent))
}

// ActivityLogEventRegionalServerMsgEvent_FieldPathArrayItemValue allows storing single item in Path-specific values for RegionalServerMsgEvent according to their type
// Present only for array (repeated) types.
type ActivityLogEventRegionalServerMsgEvent_FieldPathArrayItemValue interface {
	gotenobject.FieldPathArrayItemValue
	ActivityLogEventRegionalServerMsgEvent_FieldPath
	ContainsValue(*ActivityLog_Event_RegionalServerMsgEvent) bool
}

// ParseActivityLogEventRegionalServerMsgEvent_FieldPathArrayItemValue parses string and JSON-encoded value to its Value
func ParseActivityLogEventRegionalServerMsgEvent_FieldPathArrayItemValue(pathStr, valueStr string) (ActivityLogEventRegionalServerMsgEvent_FieldPathArrayItemValue, error) {
	fp, err := ParseActivityLogEventRegionalServerMsgEvent_FieldPath(pathStr)
	if err != nil {
		return nil, err
	}
	fpaiv, err := gotenobject.ParseFieldPathArrayItemValue(fp, valueStr)
	if err != nil {
		return nil, status.Errorf(codes.InvalidArgument, "error parsing RegionalServerMsgEvent field path array item value from %s: %v", valueStr, err)
	}
	return fpaiv.(ActivityLogEventRegionalServerMsgEvent_FieldPathArrayItemValue), nil
}

func MustParseActivityLogEventRegionalServerMsgEvent_FieldPathArrayItemValue(pathStr, valueStr string) ActivityLogEventRegionalServerMsgEvent_FieldPathArrayItemValue {
	fpaiv, err := ParseActivityLogEventRegionalServerMsgEvent_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type ActivityLogEventRegionalServerMsgEvent_FieldTerminalPathArrayItemValue struct {
	ActivityLogEventRegionalServerMsgEvent_FieldTerminalPath
	value interface{}
}

var _ ActivityLogEventRegionalServerMsgEvent_FieldPathArrayItemValue = (*ActivityLogEventRegionalServerMsgEvent_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object ActivityLog_Event_RegionalServerMsgEvent as interface{}
func (fpaiv *ActivityLogEventRegionalServerMsgEvent_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}

func (fpaiv *ActivityLogEventRegionalServerMsgEvent_FieldTerminalPathArrayItemValue) GetSingle(source *ActivityLog_Event_RegionalServerMsgEvent) (interface{}, bool) {
	return nil, false
}

func (fpaiv *ActivityLogEventRegionalServerMsgEvent_FieldTerminalPathArrayItemValue) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fpaiv.GetSingle(source.(*ActivityLog_Event_RegionalServerMsgEvent))
}

// Contains returns a boolean indicating if value that is being held is present in given 'RegionalServerMsgEvent'
func (fpaiv *ActivityLogEventRegionalServerMsgEvent_FieldTerminalPathArrayItemValue) ContainsValue(source *ActivityLog_Event_RegionalServerMsgEvent) bool {
	slice := fpaiv.ActivityLogEventRegionalServerMsgEvent_FieldTerminalPath.Get(source)
	for _, v := range slice {
		if asProtoMsg, ok := fpaiv.value.(proto.Message); ok {
			if proto.Equal(asProtoMsg, v.(proto.Message)) {
				return true
			}
		} else if reflect.DeepEqual(v, fpaiv.value) {
			return true
		}
	}
	return false
}

// ActivityLogEventRegionalServerMsgEvent_FieldPathArrayOfValues allows storing slice of values for RegionalServerMsgEvent fields according to their type
type ActivityLogEventRegionalServerMsgEvent_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	ActivityLogEventRegionalServerMsgEvent_FieldPath
}

func ParseActivityLogEventRegionalServerMsgEvent_FieldPathArrayOfValues(pathStr, valuesStr string) (ActivityLogEventRegionalServerMsgEvent_FieldPathArrayOfValues, error) {
	fp, err := ParseActivityLogEventRegionalServerMsgEvent_FieldPath(pathStr)
	if err != nil {
		return nil, err
	}
	fpaov, err := gotenobject.ParseFieldPathArrayOfValues(fp, valuesStr)
	if err != nil {
		return nil, status.Errorf(codes.InvalidArgument, "error parsing RegionalServerMsgEvent field path array of values from %s: %v", valuesStr, err)
	}
	return fpaov.(ActivityLogEventRegionalServerMsgEvent_FieldPathArrayOfValues), nil
}

func MustParseActivityLogEventRegionalServerMsgEvent_FieldPathArrayOfValues(pathStr, valuesStr string) ActivityLogEventRegionalServerMsgEvent_FieldPathArrayOfValues {
	fpaov, err := ParseActivityLogEventRegionalServerMsgEvent_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type ActivityLogEventRegionalServerMsgEvent_FieldTerminalPathArrayOfValues struct {
	ActivityLogEventRegionalServerMsgEvent_FieldTerminalPath
	values interface{}
}

var _ ActivityLogEventRegionalServerMsgEvent_FieldPathArrayOfValues = (*ActivityLogEventRegionalServerMsgEvent_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *ActivityLogEventRegionalServerMsgEvent_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case ActivityLogEventRegionalServerMsgEvent_FieldPathSelectorData:
		for _, v := range fpaov.values.([]*anypb.Any) {
			values = append(values, v)
		}
	case ActivityLogEventRegionalServerMsgEvent_FieldPathSelectorTime:
		for _, v := range fpaov.values.([]*timestamppb.Timestamp) {
			values = append(values, v)
		}
	case ActivityLogEventRegionalServerMsgEvent_FieldPathSelectorRegionId:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *ActivityLogEventRegionalServerMsgEvent_FieldTerminalPathArrayOfValues) AsDataArrayOfValues() ([]*anypb.Any, bool) {
	res, ok := fpaov.values.([]*anypb.Any)
	return res, ok
}
func (fpaov *ActivityLogEventRegionalServerMsgEvent_FieldTerminalPathArrayOfValues) AsTimeArrayOfValues() ([]*timestamppb.Timestamp, bool) {
	res, ok := fpaov.values.([]*timestamppb.Timestamp)
	return res, ok
}
func (fpaov *ActivityLogEventRegionalServerMsgEvent_FieldTerminalPathArrayOfValues) AsRegionIdArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}

// FieldPath provides implementation to handle
// https://github.com/protocolbuffers/protobuf/blob/master/src/google/protobuf/field_mask.proto
type ActivityLogEventServerMsgEvent_FieldPath interface {
	gotenobject.FieldPath
	Selector() ActivityLogEventServerMsgEvent_FieldPathSelector
	Get(source *ActivityLog_Event_ServerMsgEvent) []interface{}
	GetSingle(source *ActivityLog_Event_ServerMsgEvent) (interface{}, bool)
	ClearValue(item *ActivityLog_Event_ServerMsgEvent)

	// Those methods build corresponding ActivityLogEventServerMsgEvent_FieldPathValue
	// (or array of values) and holds passed value. Panics if injected type is incorrect.
	WithIValue(value interface{}) ActivityLogEventServerMsgEvent_FieldPathValue
	WithIArrayOfValues(values interface{}) ActivityLogEventServerMsgEvent_FieldPathArrayOfValues
	WithIArrayItemValue(value interface{}) ActivityLogEventServerMsgEvent_FieldPathArrayItemValue
}

type ActivityLogEventServerMsgEvent_FieldPathSelector int32

const (
	ActivityLogEventServerMsgEvent_FieldPathSelectorData ActivityLogEventServerMsgEvent_FieldPathSelector = 0
	ActivityLogEventServerMsgEvent_FieldPathSelectorTime ActivityLogEventServerMsgEvent_FieldPathSelector = 1
)

func (s ActivityLogEventServerMsgEvent_FieldPathSelector) String() string {
	switch s {
	case ActivityLogEventServerMsgEvent_FieldPathSelectorData:
		return "data"
	case ActivityLogEventServerMsgEvent_FieldPathSelectorTime:
		return "time"
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_Event_ServerMsgEvent: %d", s))
	}
}

func BuildActivityLogEventServerMsgEvent_FieldPath(fp gotenobject.RawFieldPath) (ActivityLogEventServerMsgEvent_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object ActivityLog_Event_ServerMsgEvent")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "data":
			return &ActivityLogEventServerMsgEvent_FieldTerminalPath{selector: ActivityLogEventServerMsgEvent_FieldPathSelectorData}, nil
		case "time":
			return &ActivityLogEventServerMsgEvent_FieldTerminalPath{selector: ActivityLogEventServerMsgEvent_FieldPathSelectorTime}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object ActivityLog_Event_ServerMsgEvent", fp)
}

func ParseActivityLogEventServerMsgEvent_FieldPath(rawField string) (ActivityLogEventServerMsgEvent_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildActivityLogEventServerMsgEvent_FieldPath(fp)
}

func MustParseActivityLogEventServerMsgEvent_FieldPath(rawField string) ActivityLogEventServerMsgEvent_FieldPath {
	fp, err := ParseActivityLogEventServerMsgEvent_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type ActivityLogEventServerMsgEvent_FieldTerminalPath struct {
	selector ActivityLogEventServerMsgEvent_FieldPathSelector
}

var _ ActivityLogEventServerMsgEvent_FieldPath = (*ActivityLogEventServerMsgEvent_FieldTerminalPath)(nil)

func (fp *ActivityLogEventServerMsgEvent_FieldTerminalPath) Selector() ActivityLogEventServerMsgEvent_FieldPathSelector {
	return fp.selector
}

// String returns path representation in proto convention
func (fp *ActivityLogEventServerMsgEvent_FieldTerminalPath) String() string {
	return fp.selector.String()
}

// JSONString returns path representation is JSON convention
func (fp *ActivityLogEventServerMsgEvent_FieldTerminalPath) JSONString() string {
	return strcase.ToLowerCamel(fp.String())
}

// Get returns all values pointed by specific field from source ActivityLog_Event_ServerMsgEvent
func (fp *ActivityLogEventServerMsgEvent_FieldTerminalPath) Get(source *ActivityLog_Event_ServerMsgEvent) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case ActivityLogEventServerMsgEvent_FieldPathSelectorData:
			if source.Data != nil {
				values = append(values, source.Data)
			}
		case ActivityLogEventServerMsgEvent_FieldPathSelectorTime:
			if source.Time != nil {
				values = append(values, source.Time)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for ActivityLog_Event_ServerMsgEvent: %d", fp.selector))
		}
	}
	return
}

func (fp *ActivityLogEventServerMsgEvent_FieldTerminalPath) GetRaw(source proto.Message) []interface{} {
	return fp.Get(source.(*ActivityLog_Event_ServerMsgEvent))
}

// GetSingle returns value pointed by specific field of from source ActivityLog_Event_ServerMsgEvent
func (fp *ActivityLogEventServerMsgEvent_FieldTerminalPath) GetSingle(source *ActivityLog_Event_ServerMsgEvent) (interface{}, bool) {
	switch fp.selector {
	case ActivityLogEventServerMsgEvent_FieldPathSelectorData:
		res := source.GetData()
		return res, res != nil
	case ActivityLogEventServerMsgEvent_FieldPathSelectorTime:
		res := source.GetTime()
		return res, res != nil
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_Event_ServerMsgEvent: %d", fp.selector))
	}
}

func (fp *ActivityLogEventServerMsgEvent_FieldTerminalPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fp.GetSingle(source.(*ActivityLog_Event_ServerMsgEvent))
}

// GetDefault returns a default value of the field type
func (fp *ActivityLogEventServerMsgEvent_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case ActivityLogEventServerMsgEvent_FieldPathSelectorData:
		return (*anypb.Any)(nil)
	case ActivityLogEventServerMsgEvent_FieldPathSelectorTime:
		return (*timestamppb.Timestamp)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_Event_ServerMsgEvent: %d", fp.selector))
	}
}

func (fp *ActivityLogEventServerMsgEvent_FieldTerminalPath) ClearValue(item *ActivityLog_Event_ServerMsgEvent) {
	if item != nil {
		switch fp.selector {
		case ActivityLogEventServerMsgEvent_FieldPathSelectorData:
			item.Data = nil
		case ActivityLogEventServerMsgEvent_FieldPathSelectorTime:
			item.Time = nil
		default:
			panic(fmt.Sprintf("Invalid selector for ActivityLog_Event_ServerMsgEvent: %d", fp.selector))
		}
	}
}

func (fp *ActivityLogEventServerMsgEvent_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*ActivityLog_Event_ServerMsgEvent))
}

// IsLeaf - whether field path is holds simple value
func (fp *ActivityLogEventServerMsgEvent_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == ActivityLogEventServerMsgEvent_FieldPathSelectorData ||
		fp.selector == ActivityLogEventServerMsgEvent_FieldPathSelectorTime
}

func (fp *ActivityLogEventServerMsgEvent_FieldTerminalPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
	return []gotenobject.FieldPath{fp}
}

func (fp *ActivityLogEventServerMsgEvent_FieldTerminalPath) WithIValue(value interface{}) ActivityLogEventServerMsgEvent_FieldPathValue {
	switch fp.selector {
	case ActivityLogEventServerMsgEvent_FieldPathSelectorData:
		return &ActivityLogEventServerMsgEvent_FieldTerminalPathValue{ActivityLogEventServerMsgEvent_FieldTerminalPath: *fp, value: value.(*anypb.Any)}
	case ActivityLogEventServerMsgEvent_FieldPathSelectorTime:
		return &ActivityLogEventServerMsgEvent_FieldTerminalPathValue{ActivityLogEventServerMsgEvent_FieldTerminalPath: *fp, value: value.(*timestamppb.Timestamp)}
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_Event_ServerMsgEvent: %d", fp.selector))
	}
}

func (fp *ActivityLogEventServerMsgEvent_FieldTerminalPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
	return fp.WithIValue(value)
}

func (fp *ActivityLogEventServerMsgEvent_FieldTerminalPath) WithIArrayOfValues(values interface{}) ActivityLogEventServerMsgEvent_FieldPathArrayOfValues {
	fpaov := &ActivityLogEventServerMsgEvent_FieldTerminalPathArrayOfValues{ActivityLogEventServerMsgEvent_FieldTerminalPath: *fp}
	switch fp.selector {
	case ActivityLogEventServerMsgEvent_FieldPathSelectorData:
		return &ActivityLogEventServerMsgEvent_FieldTerminalPathArrayOfValues{ActivityLogEventServerMsgEvent_FieldTerminalPath: *fp, values: values.([]*anypb.Any)}
	case ActivityLogEventServerMsgEvent_FieldPathSelectorTime:
		return &ActivityLogEventServerMsgEvent_FieldTerminalPathArrayOfValues{ActivityLogEventServerMsgEvent_FieldTerminalPath: *fp, values: values.([]*timestamppb.Timestamp)}
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_Event_ServerMsgEvent: %d", fp.selector))
	}
	return fpaov
}

func (fp *ActivityLogEventServerMsgEvent_FieldTerminalPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
	return fp.WithIArrayOfValues(values)
}

func (fp *ActivityLogEventServerMsgEvent_FieldTerminalPath) WithIArrayItemValue(value interface{}) ActivityLogEventServerMsgEvent_FieldPathArrayItemValue {
	switch fp.selector {
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_Event_ServerMsgEvent: %d", fp.selector))
	}
}

func (fp *ActivityLogEventServerMsgEvent_FieldTerminalPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
	return fp.WithIArrayItemValue(value)
}

// ActivityLogEventServerMsgEvent_FieldPathValue allows storing values for ServerMsgEvent fields according to their type
type ActivityLogEventServerMsgEvent_FieldPathValue interface {
	ActivityLogEventServerMsgEvent_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **ActivityLog_Event_ServerMsgEvent)
	CompareWith(*ActivityLog_Event_ServerMsgEvent) (cmp int, comparable bool)
}

func ParseActivityLogEventServerMsgEvent_FieldPathValue(pathStr, valueStr string) (ActivityLogEventServerMsgEvent_FieldPathValue, error) {
	fp, err := ParseActivityLogEventServerMsgEvent_FieldPath(pathStr)
	if err != nil {
		return nil, err
	}
	fpv, err := gotenobject.ParseFieldPathValue(fp, valueStr)
	if err != nil {
		return nil, status.Errorf(codes.InvalidArgument, "error parsing ServerMsgEvent field path value from %s: %v", valueStr, err)
	}
	return fpv.(ActivityLogEventServerMsgEvent_FieldPathValue), nil
}

func MustParseActivityLogEventServerMsgEvent_FieldPathValue(pathStr, valueStr string) ActivityLogEventServerMsgEvent_FieldPathValue {
	fpv, err := ParseActivityLogEventServerMsgEvent_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type ActivityLogEventServerMsgEvent_FieldTerminalPathValue struct {
	ActivityLogEventServerMsgEvent_FieldTerminalPath
	value interface{}
}

var _ ActivityLogEventServerMsgEvent_FieldPathValue = (*ActivityLogEventServerMsgEvent_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'ServerMsgEvent' as interface{}
func (fpv *ActivityLogEventServerMsgEvent_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *ActivityLogEventServerMsgEvent_FieldTerminalPathValue) AsDataValue() (*anypb.Any, bool) {
	res, ok := fpv.value.(*anypb.Any)
	return res, ok
}
func (fpv *ActivityLogEventServerMsgEvent_FieldTerminalPathValue) AsTimeValue() (*timestamppb.Timestamp, bool) {
	res, ok := fpv.value.(*timestamppb.Timestamp)
	return res, ok
}

// SetTo stores value for selected field for object ServerMsgEvent
func (fpv *ActivityLogEventServerMsgEvent_FieldTerminalPathValue) SetTo(target **ActivityLog_Event_ServerMsgEvent) {
	if *target == nil {
		*target = new(ActivityLog_Event_ServerMsgEvent)
	}
	switch fpv.selector {
	case ActivityLogEventServerMsgEvent_FieldPathSelectorData:
		(*target).Data = fpv.value.(*anypb.Any)
	case ActivityLogEventServerMsgEvent_FieldPathSelectorTime:
		(*target).Time = fpv.value.(*timestamppb.Timestamp)
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_Event_ServerMsgEvent: %d", fpv.selector))
	}
}

func (fpv *ActivityLogEventServerMsgEvent_FieldTerminalPathValue) SetToRaw(target proto.Message) {
	typedObject := target.(*ActivityLog_Event_ServerMsgEvent)
	fpv.SetTo(&typedObject)
}

// CompareWith compares value in the 'ActivityLogEventServerMsgEvent_FieldTerminalPathValue' with the value under path in 'ActivityLog_Event_ServerMsgEvent'.
func (fpv *ActivityLogEventServerMsgEvent_FieldTerminalPathValue) CompareWith(source *ActivityLog_Event_ServerMsgEvent) (int, bool) {
	switch fpv.selector {
	case ActivityLogEventServerMsgEvent_FieldPathSelectorData:
		return 0, false
	case ActivityLogEventServerMsgEvent_FieldPathSelectorTime:
		leftValue := fpv.value.(*timestamppb.Timestamp)
		rightValue := source.GetTime()
		if leftValue == nil {
			if rightValue != nil {
				return -1, true
			}
			return 0, true
		}
		if rightValue == nil {
			return 1, true
		}
		if leftValue.AsTime().Equal(rightValue.AsTime()) {
			return 0, true
		} else if leftValue.AsTime().Before(rightValue.AsTime()) {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_Event_ServerMsgEvent: %d", fpv.selector))
	}
}

func (fpv *ActivityLogEventServerMsgEvent_FieldTerminalPathValue) CompareWithRaw(source proto.Message) (int, bool) {
	return fpv.CompareWith(source.(*ActivityLog_Event_ServerMsgEvent))
}

// ActivityLogEventServerMsgEvent_FieldPathArrayItemValue allows storing single item in Path-specific values for ServerMsgEvent according to their type
// Present only for array (repeated) types.
type ActivityLogEventServerMsgEvent_FieldPathArrayItemValue interface {
	gotenobject.FieldPathArrayItemValue
	ActivityLogEventServerMsgEvent_FieldPath
	ContainsValue(*ActivityLog_Event_ServerMsgEvent) bool
}

// ParseActivityLogEventServerMsgEvent_FieldPathArrayItemValue parses string and JSON-encoded value to its Value
func ParseActivityLogEventServerMsgEvent_FieldPathArrayItemValue(pathStr, valueStr string) (ActivityLogEventServerMsgEvent_FieldPathArrayItemValue, error) {
	fp, err := ParseActivityLogEventServerMsgEvent_FieldPath(pathStr)
	if err != nil {
		return nil, err
	}
	fpaiv, err := gotenobject.ParseFieldPathArrayItemValue(fp, valueStr)
	if err != nil {
		return nil, status.Errorf(codes.InvalidArgument, "error parsing ServerMsgEvent field path array item value from %s: %v", valueStr, err)
	}
	return fpaiv.(ActivityLogEventServerMsgEvent_FieldPathArrayItemValue), nil
}

func MustParseActivityLogEventServerMsgEvent_FieldPathArrayItemValue(pathStr, valueStr string) ActivityLogEventServerMsgEvent_FieldPathArrayItemValue {
	fpaiv, err := ParseActivityLogEventServerMsgEvent_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type ActivityLogEventServerMsgEvent_FieldTerminalPathArrayItemValue struct {
	ActivityLogEventServerMsgEvent_FieldTerminalPath
	value interface{}
}

var _ ActivityLogEventServerMsgEvent_FieldPathArrayItemValue = (*ActivityLogEventServerMsgEvent_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object ActivityLog_Event_ServerMsgEvent as interface{}
func (fpaiv *ActivityLogEventServerMsgEvent_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}

func (fpaiv *ActivityLogEventServerMsgEvent_FieldTerminalPathArrayItemValue) GetSingle(source *ActivityLog_Event_ServerMsgEvent) (interface{}, bool) {
	return nil, false
}

func (fpaiv *ActivityLogEventServerMsgEvent_FieldTerminalPathArrayItemValue) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fpaiv.GetSingle(source.(*ActivityLog_Event_ServerMsgEvent))
}

// Contains returns a boolean indicating if value that is being held is present in given 'ServerMsgEvent'
func (fpaiv *ActivityLogEventServerMsgEvent_FieldTerminalPathArrayItemValue) ContainsValue(source *ActivityLog_Event_ServerMsgEvent) bool {
	slice := fpaiv.ActivityLogEventServerMsgEvent_FieldTerminalPath.Get(source)
	for _, v := range slice {
		if asProtoMsg, ok := fpaiv.value.(proto.Message); ok {
			if proto.Equal(asProtoMsg, v.(proto.Message)) {
				return true
			}
		} else if reflect.DeepEqual(v, fpaiv.value) {
			return true
		}
	}
	return false
}

// ActivityLogEventServerMsgEvent_FieldPathArrayOfValues allows storing slice of values for ServerMsgEvent fields according to their type
type ActivityLogEventServerMsgEvent_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	ActivityLogEventServerMsgEvent_FieldPath
}

func ParseActivityLogEventServerMsgEvent_FieldPathArrayOfValues(pathStr, valuesStr string) (ActivityLogEventServerMsgEvent_FieldPathArrayOfValues, error) {
	fp, err := ParseActivityLogEventServerMsgEvent_FieldPath(pathStr)
	if err != nil {
		return nil, err
	}
	fpaov, err := gotenobject.ParseFieldPathArrayOfValues(fp, valuesStr)
	if err != nil {
		return nil, status.Errorf(codes.InvalidArgument, "error parsing ServerMsgEvent field path array of values from %s: %v", valuesStr, err)
	}
	return fpaov.(ActivityLogEventServerMsgEvent_FieldPathArrayOfValues), nil
}

func MustParseActivityLogEventServerMsgEvent_FieldPathArrayOfValues(pathStr, valuesStr string) ActivityLogEventServerMsgEvent_FieldPathArrayOfValues {
	fpaov, err := ParseActivityLogEventServerMsgEvent_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type ActivityLogEventServerMsgEvent_FieldTerminalPathArrayOfValues struct {
	ActivityLogEventServerMsgEvent_FieldTerminalPath
	values interface{}
}

var _ ActivityLogEventServerMsgEvent_FieldPathArrayOfValues = (*ActivityLogEventServerMsgEvent_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *ActivityLogEventServerMsgEvent_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case ActivityLogEventServerMsgEvent_FieldPathSelectorData:
		for _, v := range fpaov.values.([]*anypb.Any) {
			values = append(values, v)
		}
	case ActivityLogEventServerMsgEvent_FieldPathSelectorTime:
		for _, v := range fpaov.values.([]*timestamppb.Timestamp) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *ActivityLogEventServerMsgEvent_FieldTerminalPathArrayOfValues) AsDataArrayOfValues() ([]*anypb.Any, bool) {
	res, ok := fpaov.values.([]*anypb.Any)
	return res, ok
}
func (fpaov *ActivityLogEventServerMsgEvent_FieldTerminalPathArrayOfValues) AsTimeArrayOfValues() ([]*timestamppb.Timestamp, bool) {
	res, ok := fpaov.values.([]*timestamppb.Timestamp)
	return res, ok
}

// FieldPath provides implementation to handle
// https://github.com/protocolbuffers/protobuf/blob/master/src/google/protobuf/field_mask.proto
type ActivityLogEventRegionalExitEvent_FieldPath interface {
	gotenobject.FieldPath
	Selector() ActivityLogEventRegionalExitEvent_FieldPathSelector
	Get(source *ActivityLog_Event_RegionalExitEvent) []interface{}
	GetSingle(source *ActivityLog_Event_RegionalExitEvent) (interface{}, bool)
	ClearValue(item *ActivityLog_Event_RegionalExitEvent)

	// Those methods build corresponding ActivityLogEventRegionalExitEvent_FieldPathValue
	// (or array of values) and holds passed value. Panics if injected type is incorrect.
	WithIValue(value interface{}) ActivityLogEventRegionalExitEvent_FieldPathValue
	WithIArrayOfValues(values interface{}) ActivityLogEventRegionalExitEvent_FieldPathArrayOfValues
	WithIArrayItemValue(value interface{}) ActivityLogEventRegionalExitEvent_FieldPathArrayItemValue
}

type ActivityLogEventRegionalExitEvent_FieldPathSelector int32

const (
	ActivityLogEventRegionalExitEvent_FieldPathSelectorStatus   ActivityLogEventRegionalExitEvent_FieldPathSelector = 0
	ActivityLogEventRegionalExitEvent_FieldPathSelectorTime     ActivityLogEventRegionalExitEvent_FieldPathSelector = 1
	ActivityLogEventRegionalExitEvent_FieldPathSelectorRegionId ActivityLogEventRegionalExitEvent_FieldPathSelector = 2
)

func (s ActivityLogEventRegionalExitEvent_FieldPathSelector) String() string {
	switch s {
	case ActivityLogEventRegionalExitEvent_FieldPathSelectorStatus:
		return "status"
	case ActivityLogEventRegionalExitEvent_FieldPathSelectorTime:
		return "time"
	case ActivityLogEventRegionalExitEvent_FieldPathSelectorRegionId:
		return "region_id"
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_Event_RegionalExitEvent: %d", s))
	}
}

func BuildActivityLogEventRegionalExitEvent_FieldPath(fp gotenobject.RawFieldPath) (ActivityLogEventRegionalExitEvent_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object ActivityLog_Event_RegionalExitEvent")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "status":
			return &ActivityLogEventRegionalExitEvent_FieldTerminalPath{selector: ActivityLogEventRegionalExitEvent_FieldPathSelectorStatus}, nil
		case "time":
			return &ActivityLogEventRegionalExitEvent_FieldTerminalPath{selector: ActivityLogEventRegionalExitEvent_FieldPathSelectorTime}, nil
		case "region_id", "regionId", "region-id":
			return &ActivityLogEventRegionalExitEvent_FieldTerminalPath{selector: ActivityLogEventRegionalExitEvent_FieldPathSelectorRegionId}, nil
		}
	} else {
		switch fp[0] {
		case "status":
			if subpath, err := rpc.BuildStatus_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &ActivityLogEventRegionalExitEvent_FieldSubPath{selector: ActivityLogEventRegionalExitEvent_FieldPathSelectorStatus, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object ActivityLog_Event_RegionalExitEvent", fp)
}

func ParseActivityLogEventRegionalExitEvent_FieldPath(rawField string) (ActivityLogEventRegionalExitEvent_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildActivityLogEventRegionalExitEvent_FieldPath(fp)
}

func MustParseActivityLogEventRegionalExitEvent_FieldPath(rawField string) ActivityLogEventRegionalExitEvent_FieldPath {
	fp, err := ParseActivityLogEventRegionalExitEvent_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type ActivityLogEventRegionalExitEvent_FieldTerminalPath struct {
	selector ActivityLogEventRegionalExitEvent_FieldPathSelector
}

var _ ActivityLogEventRegionalExitEvent_FieldPath = (*ActivityLogEventRegionalExitEvent_FieldTerminalPath)(nil)

func (fp *ActivityLogEventRegionalExitEvent_FieldTerminalPath) Selector() ActivityLogEventRegionalExitEvent_FieldPathSelector {
	return fp.selector
}

// String returns path representation in proto convention
func (fp *ActivityLogEventRegionalExitEvent_FieldTerminalPath) String() string {
	return fp.selector.String()
}

// JSONString returns path representation is JSON convention
func (fp *ActivityLogEventRegionalExitEvent_FieldTerminalPath) JSONString() string {
	return strcase.ToLowerCamel(fp.String())
}

// Get returns all values pointed by specific field from source ActivityLog_Event_RegionalExitEvent
func (fp *ActivityLogEventRegionalExitEvent_FieldTerminalPath) Get(source *ActivityLog_Event_RegionalExitEvent) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case ActivityLogEventRegionalExitEvent_FieldPathSelectorStatus:
			if source.Status != nil {
				values = append(values, source.Status)
			}
		case ActivityLogEventRegionalExitEvent_FieldPathSelectorTime:
			if source.Time != nil {
				values = append(values, source.Time)
			}
		case ActivityLogEventRegionalExitEvent_FieldPathSelectorRegionId:
			values = append(values, source.RegionId)
		default:
			panic(fmt.Sprintf("Invalid selector for ActivityLog_Event_RegionalExitEvent: %d", fp.selector))
		}
	}
	return
}

func (fp *ActivityLogEventRegionalExitEvent_FieldTerminalPath) GetRaw(source proto.Message) []interface{} {
	return fp.Get(source.(*ActivityLog_Event_RegionalExitEvent))
}

// GetSingle returns value pointed by specific field of from source ActivityLog_Event_RegionalExitEvent
func (fp *ActivityLogEventRegionalExitEvent_FieldTerminalPath) GetSingle(source *ActivityLog_Event_RegionalExitEvent) (interface{}, bool) {
	switch fp.selector {
	case ActivityLogEventRegionalExitEvent_FieldPathSelectorStatus:
		res := source.GetStatus()
		return res, res != nil
	case ActivityLogEventRegionalExitEvent_FieldPathSelectorTime:
		res := source.GetTime()
		return res, res != nil
	case ActivityLogEventRegionalExitEvent_FieldPathSelectorRegionId:
		return source.GetRegionId(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_Event_RegionalExitEvent: %d", fp.selector))
	}
}

func (fp *ActivityLogEventRegionalExitEvent_FieldTerminalPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fp.GetSingle(source.(*ActivityLog_Event_RegionalExitEvent))
}

// GetDefault returns a default value of the field type
func (fp *ActivityLogEventRegionalExitEvent_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case ActivityLogEventRegionalExitEvent_FieldPathSelectorStatus:
		return (*rpc.Status)(nil)
	case ActivityLogEventRegionalExitEvent_FieldPathSelectorTime:
		return (*timestamppb.Timestamp)(nil)
	case ActivityLogEventRegionalExitEvent_FieldPathSelectorRegionId:
		return ""
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_Event_RegionalExitEvent: %d", fp.selector))
	}
}

func (fp *ActivityLogEventRegionalExitEvent_FieldTerminalPath) ClearValue(item *ActivityLog_Event_RegionalExitEvent) {
	if item != nil {
		switch fp.selector {
		case ActivityLogEventRegionalExitEvent_FieldPathSelectorStatus:
			item.Status = nil
		case ActivityLogEventRegionalExitEvent_FieldPathSelectorTime:
			item.Time = nil
		case ActivityLogEventRegionalExitEvent_FieldPathSelectorRegionId:
			item.RegionId = ""
		default:
			panic(fmt.Sprintf("Invalid selector for ActivityLog_Event_RegionalExitEvent: %d", fp.selector))
		}
	}
}

func (fp *ActivityLogEventRegionalExitEvent_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*ActivityLog_Event_RegionalExitEvent))
}

// IsLeaf - whether field path is holds simple value
func (fp *ActivityLogEventRegionalExitEvent_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == ActivityLogEventRegionalExitEvent_FieldPathSelectorTime ||
		fp.selector == ActivityLogEventRegionalExitEvent_FieldPathSelectorRegionId
}

func (fp *ActivityLogEventRegionalExitEvent_FieldTerminalPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
	return []gotenobject.FieldPath{fp}
}

func (fp *ActivityLogEventRegionalExitEvent_FieldTerminalPath) WithIValue(value interface{}) ActivityLogEventRegionalExitEvent_FieldPathValue {
	switch fp.selector {
	case ActivityLogEventRegionalExitEvent_FieldPathSelectorStatus:
		return &ActivityLogEventRegionalExitEvent_FieldTerminalPathValue{ActivityLogEventRegionalExitEvent_FieldTerminalPath: *fp, value: value.(*rpc.Status)}
	case ActivityLogEventRegionalExitEvent_FieldPathSelectorTime:
		return &ActivityLogEventRegionalExitEvent_FieldTerminalPathValue{ActivityLogEventRegionalExitEvent_FieldTerminalPath: *fp, value: value.(*timestamppb.Timestamp)}
	case ActivityLogEventRegionalExitEvent_FieldPathSelectorRegionId:
		return &ActivityLogEventRegionalExitEvent_FieldTerminalPathValue{ActivityLogEventRegionalExitEvent_FieldTerminalPath: *fp, value: value.(string)}
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_Event_RegionalExitEvent: %d", fp.selector))
	}
}

func (fp *ActivityLogEventRegionalExitEvent_FieldTerminalPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
	return fp.WithIValue(value)
}

func (fp *ActivityLogEventRegionalExitEvent_FieldTerminalPath) WithIArrayOfValues(values interface{}) ActivityLogEventRegionalExitEvent_FieldPathArrayOfValues {
	fpaov := &ActivityLogEventRegionalExitEvent_FieldTerminalPathArrayOfValues{ActivityLogEventRegionalExitEvent_FieldTerminalPath: *fp}
	switch fp.selector {
	case ActivityLogEventRegionalExitEvent_FieldPathSelectorStatus:
		return &ActivityLogEventRegionalExitEvent_FieldTerminalPathArrayOfValues{ActivityLogEventRegionalExitEvent_FieldTerminalPath: *fp, values: values.([]*rpc.Status)}
	case ActivityLogEventRegionalExitEvent_FieldPathSelectorTime:
		return &ActivityLogEventRegionalExitEvent_FieldTerminalPathArrayOfValues{ActivityLogEventRegionalExitEvent_FieldTerminalPath: *fp, values: values.([]*timestamppb.Timestamp)}
	case ActivityLogEventRegionalExitEvent_FieldPathSelectorRegionId:
		return &ActivityLogEventRegionalExitEvent_FieldTerminalPathArrayOfValues{ActivityLogEventRegionalExitEvent_FieldTerminalPath: *fp, values: values.([]string)}
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_Event_RegionalExitEvent: %d", fp.selector))
	}
	return fpaov
}

func (fp *ActivityLogEventRegionalExitEvent_FieldTerminalPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
	return fp.WithIArrayOfValues(values)
}

func (fp *ActivityLogEventRegionalExitEvent_FieldTerminalPath) WithIArrayItemValue(value interface{}) ActivityLogEventRegionalExitEvent_FieldPathArrayItemValue {
	switch fp.selector {
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_Event_RegionalExitEvent: %d", fp.selector))
	}
}

func (fp *ActivityLogEventRegionalExitEvent_FieldTerminalPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
	return fp.WithIArrayItemValue(value)
}

type ActivityLogEventRegionalExitEvent_FieldSubPath struct {
	selector ActivityLogEventRegionalExitEvent_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ ActivityLogEventRegionalExitEvent_FieldPath = (*ActivityLogEventRegionalExitEvent_FieldSubPath)(nil)

func (fps *ActivityLogEventRegionalExitEvent_FieldSubPath) Selector() ActivityLogEventRegionalExitEvent_FieldPathSelector {
	return fps.selector
}
func (fps *ActivityLogEventRegionalExitEvent_FieldSubPath) AsStatusSubPath() (rpc.Status_FieldPath, bool) {
	res, ok := fps.subPath.(rpc.Status_FieldPath)
	return res, ok
}

// String returns path representation in proto convention
func (fps *ActivityLogEventRegionalExitEvent_FieldSubPath) String() string {
	return fps.selector.String() + "." + fps.subPath.String()
}

// JSONString returns path representation is JSON convention
func (fps *ActivityLogEventRegionalExitEvent_FieldSubPath) JSONString() string {
	return strcase.ToLowerCamel(fps.selector.String()) + "." + fps.subPath.JSONString()
}

// Get returns all values pointed by selected field from source ActivityLog_Event_RegionalExitEvent
func (fps *ActivityLogEventRegionalExitEvent_FieldSubPath) Get(source *ActivityLog_Event_RegionalExitEvent) (values []interface{}) {
	switch fps.selector {
	case ActivityLogEventRegionalExitEvent_FieldPathSelectorStatus:
		values = append(values, fps.subPath.GetRaw(source.GetStatus())...)
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_Event_RegionalExitEvent: %d", fps.selector))
	}
	return
}

func (fps *ActivityLogEventRegionalExitEvent_FieldSubPath) GetRaw(source proto.Message) []interface{} {
	return fps.Get(source.(*ActivityLog_Event_RegionalExitEvent))
}

// GetSingle returns value of selected field from source ActivityLog_Event_RegionalExitEvent
func (fps *ActivityLogEventRegionalExitEvent_FieldSubPath) GetSingle(source *ActivityLog_Event_RegionalExitEvent) (interface{}, bool) {
	switch fps.selector {
	case ActivityLogEventRegionalExitEvent_FieldPathSelectorStatus:
		if source.GetStatus() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetStatus())
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_Event_RegionalExitEvent: %d", fps.selector))
	}
}

func (fps *ActivityLogEventRegionalExitEvent_FieldSubPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fps.GetSingle(source.(*ActivityLog_Event_RegionalExitEvent))
}

// GetDefault returns a default value of the field type
func (fps *ActivityLogEventRegionalExitEvent_FieldSubPath) GetDefault() interface{} {
	return fps.subPath.GetDefault()
}

func (fps *ActivityLogEventRegionalExitEvent_FieldSubPath) ClearValue(item *ActivityLog_Event_RegionalExitEvent) {
	if item != nil {
		switch fps.selector {
		case ActivityLogEventRegionalExitEvent_FieldPathSelectorStatus:
			fps.subPath.ClearValueRaw(item.Status)
		default:
			panic(fmt.Sprintf("Invalid selector for ActivityLog_Event_RegionalExitEvent: %d", fps.selector))
		}
	}
}

func (fps *ActivityLogEventRegionalExitEvent_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*ActivityLog_Event_RegionalExitEvent))
}

// IsLeaf - whether field path is holds simple value
func (fps *ActivityLogEventRegionalExitEvent_FieldSubPath) IsLeaf() bool {
	return fps.subPath.IsLeaf()
}

func (fps *ActivityLogEventRegionalExitEvent_FieldSubPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
	iPaths := []gotenobject.FieldPath{&ActivityLogEventRegionalExitEvent_FieldTerminalPath{selector: fps.selector}}
	iPaths = append(iPaths, fps.subPath.SplitIntoTerminalIPaths()...)
	return iPaths
}

func (fps *ActivityLogEventRegionalExitEvent_FieldSubPath) WithIValue(value interface{}) ActivityLogEventRegionalExitEvent_FieldPathValue {
	return &ActivityLogEventRegionalExitEvent_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

func (fps *ActivityLogEventRegionalExitEvent_FieldSubPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
	return fps.WithIValue(value)
}

func (fps *ActivityLogEventRegionalExitEvent_FieldSubPath) WithIArrayOfValues(values interface{}) ActivityLogEventRegionalExitEvent_FieldPathArrayOfValues {
	return &ActivityLogEventRegionalExitEvent_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

func (fps *ActivityLogEventRegionalExitEvent_FieldSubPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
	return fps.WithIArrayOfValues(values)
}

func (fps *ActivityLogEventRegionalExitEvent_FieldSubPath) WithIArrayItemValue(value interface{}) ActivityLogEventRegionalExitEvent_FieldPathArrayItemValue {
	return &ActivityLogEventRegionalExitEvent_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

func (fps *ActivityLogEventRegionalExitEvent_FieldSubPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
	return fps.WithIArrayItemValue(value)
}

// ActivityLogEventRegionalExitEvent_FieldPathValue allows storing values for RegionalExitEvent fields according to their type
type ActivityLogEventRegionalExitEvent_FieldPathValue interface {
	ActivityLogEventRegionalExitEvent_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **ActivityLog_Event_RegionalExitEvent)
	CompareWith(*ActivityLog_Event_RegionalExitEvent) (cmp int, comparable bool)
}

func ParseActivityLogEventRegionalExitEvent_FieldPathValue(pathStr, valueStr string) (ActivityLogEventRegionalExitEvent_FieldPathValue, error) {
	fp, err := ParseActivityLogEventRegionalExitEvent_FieldPath(pathStr)
	if err != nil {
		return nil, err
	}
	fpv, err := gotenobject.ParseFieldPathValue(fp, valueStr)
	if err != nil {
		return nil, status.Errorf(codes.InvalidArgument, "error parsing RegionalExitEvent field path value from %s: %v", valueStr, err)
	}
	return fpv.(ActivityLogEventRegionalExitEvent_FieldPathValue), nil
}

func MustParseActivityLogEventRegionalExitEvent_FieldPathValue(pathStr, valueStr string) ActivityLogEventRegionalExitEvent_FieldPathValue {
	fpv, err := ParseActivityLogEventRegionalExitEvent_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type ActivityLogEventRegionalExitEvent_FieldTerminalPathValue struct {
	ActivityLogEventRegionalExitEvent_FieldTerminalPath
	value interface{}
}

var _ ActivityLogEventRegionalExitEvent_FieldPathValue = (*ActivityLogEventRegionalExitEvent_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'RegionalExitEvent' as interface{}
func (fpv *ActivityLogEventRegionalExitEvent_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *ActivityLogEventRegionalExitEvent_FieldTerminalPathValue) AsStatusValue() (*rpc.Status, bool) {
	res, ok := fpv.value.(*rpc.Status)
	return res, ok
}
func (fpv *ActivityLogEventRegionalExitEvent_FieldTerminalPathValue) AsTimeValue() (*timestamppb.Timestamp, bool) {
	res, ok := fpv.value.(*timestamppb.Timestamp)
	return res, ok
}
func (fpv *ActivityLogEventRegionalExitEvent_FieldTerminalPathValue) AsRegionIdValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}

// SetTo stores value for selected field for object RegionalExitEvent
func (fpv *ActivityLogEventRegionalExitEvent_FieldTerminalPathValue) SetTo(target **ActivityLog_Event_RegionalExitEvent) {
	if *target == nil {
		*target = new(ActivityLog_Event_RegionalExitEvent)
	}
	switch fpv.selector {
	case ActivityLogEventRegionalExitEvent_FieldPathSelectorStatus:
		(*target).Status = fpv.value.(*rpc.Status)
	case ActivityLogEventRegionalExitEvent_FieldPathSelectorTime:
		(*target).Time = fpv.value.(*timestamppb.Timestamp)
	case ActivityLogEventRegionalExitEvent_FieldPathSelectorRegionId:
		(*target).RegionId = fpv.value.(string)
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_Event_RegionalExitEvent: %d", fpv.selector))
	}
}

func (fpv *ActivityLogEventRegionalExitEvent_FieldTerminalPathValue) SetToRaw(target proto.Message) {
	typedObject := target.(*ActivityLog_Event_RegionalExitEvent)
	fpv.SetTo(&typedObject)
}

// CompareWith compares value in the 'ActivityLogEventRegionalExitEvent_FieldTerminalPathValue' with the value under path in 'ActivityLog_Event_RegionalExitEvent'.
func (fpv *ActivityLogEventRegionalExitEvent_FieldTerminalPathValue) CompareWith(source *ActivityLog_Event_RegionalExitEvent) (int, bool) {
	switch fpv.selector {
	case ActivityLogEventRegionalExitEvent_FieldPathSelectorStatus:
		return 0, false
	case ActivityLogEventRegionalExitEvent_FieldPathSelectorTime:
		leftValue := fpv.value.(*timestamppb.Timestamp)
		rightValue := source.GetTime()
		if leftValue == nil {
			if rightValue != nil {
				return -1, true
			}
			return 0, true
		}
		if rightValue == nil {
			return 1, true
		}
		if leftValue.AsTime().Equal(rightValue.AsTime()) {
			return 0, true
		} else if leftValue.AsTime().Before(rightValue.AsTime()) {
			return -1, true
		} else {
			return 1, true
		}
	case ActivityLogEventRegionalExitEvent_FieldPathSelectorRegionId:
		leftValue := fpv.value.(string)
		rightValue := source.GetRegionId()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_Event_RegionalExitEvent: %d", fpv.selector))
	}
}

func (fpv *ActivityLogEventRegionalExitEvent_FieldTerminalPathValue) CompareWithRaw(source proto.Message) (int, bool) {
	return fpv.CompareWith(source.(*ActivityLog_Event_RegionalExitEvent))
}

type ActivityLogEventRegionalExitEvent_FieldSubPathValue struct {
	ActivityLogEventRegionalExitEvent_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ ActivityLogEventRegionalExitEvent_FieldPathValue = (*ActivityLogEventRegionalExitEvent_FieldSubPathValue)(nil)

func (fpvs *ActivityLogEventRegionalExitEvent_FieldSubPathValue) AsStatusPathValue() (rpc.Status_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(rpc.Status_FieldPathValue)
	return res, ok
}

func (fpvs *ActivityLogEventRegionalExitEvent_FieldSubPathValue) SetTo(target **ActivityLog_Event_RegionalExitEvent) {
	if *target == nil {
		*target = new(ActivityLog_Event_RegionalExitEvent)
	}
	switch fpvs.Selector() {
	case ActivityLogEventRegionalExitEvent_FieldPathSelectorStatus:
		fpvs.subPathValue.(rpc.Status_FieldPathValue).SetTo(&(*target).Status)
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_Event_RegionalExitEvent: %d", fpvs.Selector()))
	}
}

func (fpvs *ActivityLogEventRegionalExitEvent_FieldSubPathValue) SetToRaw(target proto.Message) {
	typedObject := target.(*ActivityLog_Event_RegionalExitEvent)
	fpvs.SetTo(&typedObject)
}

func (fpvs *ActivityLogEventRegionalExitEvent_FieldSubPathValue) GetRawValue() interface{} {
	return fpvs.subPathValue.GetRawValue()
}

func (fpvs *ActivityLogEventRegionalExitEvent_FieldSubPathValue) CompareWith(source *ActivityLog_Event_RegionalExitEvent) (int, bool) {
	switch fpvs.Selector() {
	case ActivityLogEventRegionalExitEvent_FieldPathSelectorStatus:
		return fpvs.subPathValue.(rpc.Status_FieldPathValue).CompareWith(source.GetStatus())
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_Event_RegionalExitEvent: %d", fpvs.Selector()))
	}
}

func (fpvs *ActivityLogEventRegionalExitEvent_FieldSubPathValue) CompareWithRaw(source proto.Message) (int, bool) {
	return fpvs.CompareWith(source.(*ActivityLog_Event_RegionalExitEvent))
}

// ActivityLogEventRegionalExitEvent_FieldPathArrayItemValue allows storing single item in Path-specific values for RegionalExitEvent according to their type
// Present only for array (repeated) types.
type ActivityLogEventRegionalExitEvent_FieldPathArrayItemValue interface {
	gotenobject.FieldPathArrayItemValue
	ActivityLogEventRegionalExitEvent_FieldPath
	ContainsValue(*ActivityLog_Event_RegionalExitEvent) bool
}

// ParseActivityLogEventRegionalExitEvent_FieldPathArrayItemValue parses string and JSON-encoded value to its Value
func ParseActivityLogEventRegionalExitEvent_FieldPathArrayItemValue(pathStr, valueStr string) (ActivityLogEventRegionalExitEvent_FieldPathArrayItemValue, error) {
	fp, err := ParseActivityLogEventRegionalExitEvent_FieldPath(pathStr)
	if err != nil {
		return nil, err
	}
	fpaiv, err := gotenobject.ParseFieldPathArrayItemValue(fp, valueStr)
	if err != nil {
		return nil, status.Errorf(codes.InvalidArgument, "error parsing RegionalExitEvent field path array item value from %s: %v", valueStr, err)
	}
	return fpaiv.(ActivityLogEventRegionalExitEvent_FieldPathArrayItemValue), nil
}

func MustParseActivityLogEventRegionalExitEvent_FieldPathArrayItemValue(pathStr, valueStr string) ActivityLogEventRegionalExitEvent_FieldPathArrayItemValue {
	fpaiv, err := ParseActivityLogEventRegionalExitEvent_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type ActivityLogEventRegionalExitEvent_FieldTerminalPathArrayItemValue struct {
	ActivityLogEventRegionalExitEvent_FieldTerminalPath
	value interface{}
}

var _ ActivityLogEventRegionalExitEvent_FieldPathArrayItemValue = (*ActivityLogEventRegionalExitEvent_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object ActivityLog_Event_RegionalExitEvent as interface{}
func (fpaiv *ActivityLogEventRegionalExitEvent_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}

func (fpaiv *ActivityLogEventRegionalExitEvent_FieldTerminalPathArrayItemValue) GetSingle(source *ActivityLog_Event_RegionalExitEvent) (interface{}, bool) {
	return nil, false
}

func (fpaiv *ActivityLogEventRegionalExitEvent_FieldTerminalPathArrayItemValue) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fpaiv.GetSingle(source.(*ActivityLog_Event_RegionalExitEvent))
}

// Contains returns a boolean indicating if value that is being held is present in given 'RegionalExitEvent'
func (fpaiv *ActivityLogEventRegionalExitEvent_FieldTerminalPathArrayItemValue) ContainsValue(source *ActivityLog_Event_RegionalExitEvent) bool {
	slice := fpaiv.ActivityLogEventRegionalExitEvent_FieldTerminalPath.Get(source)
	for _, v := range slice {
		if asProtoMsg, ok := fpaiv.value.(proto.Message); ok {
			if proto.Equal(asProtoMsg, v.(proto.Message)) {
				return true
			}
		} else if reflect.DeepEqual(v, fpaiv.value) {
			return true
		}
	}
	return false
}

type ActivityLogEventRegionalExitEvent_FieldSubPathArrayItemValue struct {
	ActivityLogEventRegionalExitEvent_FieldPath
	subPathItemValue gotenobject.FieldPathArrayItemValue
}

// GetRawValue returns stored array item value
func (fpaivs *ActivityLogEventRegionalExitEvent_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *ActivityLogEventRegionalExitEvent_FieldSubPathArrayItemValue) AsStatusPathItemValue() (rpc.Status_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(rpc.Status_FieldPathArrayItemValue)
	return res, ok
}

// Contains returns a boolean indicating if value that is being held is present in given 'RegionalExitEvent'
func (fpaivs *ActivityLogEventRegionalExitEvent_FieldSubPathArrayItemValue) ContainsValue(source *ActivityLog_Event_RegionalExitEvent) bool {
	switch fpaivs.Selector() {
	case ActivityLogEventRegionalExitEvent_FieldPathSelectorStatus:
		return fpaivs.subPathItemValue.(rpc.Status_FieldPathArrayItemValue).ContainsValue(source.GetStatus())
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_Event_RegionalExitEvent: %d", fpaivs.Selector()))
	}
}

// ActivityLogEventRegionalExitEvent_FieldPathArrayOfValues allows storing slice of values for RegionalExitEvent fields according to their type
type ActivityLogEventRegionalExitEvent_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	ActivityLogEventRegionalExitEvent_FieldPath
}

func ParseActivityLogEventRegionalExitEvent_FieldPathArrayOfValues(pathStr, valuesStr string) (ActivityLogEventRegionalExitEvent_FieldPathArrayOfValues, error) {
	fp, err := ParseActivityLogEventRegionalExitEvent_FieldPath(pathStr)
	if err != nil {
		return nil, err
	}
	fpaov, err := gotenobject.ParseFieldPathArrayOfValues(fp, valuesStr)
	if err != nil {
		return nil, status.Errorf(codes.InvalidArgument, "error parsing RegionalExitEvent field path array of values from %s: %v", valuesStr, err)
	}
	return fpaov.(ActivityLogEventRegionalExitEvent_FieldPathArrayOfValues), nil
}

func MustParseActivityLogEventRegionalExitEvent_FieldPathArrayOfValues(pathStr, valuesStr string) ActivityLogEventRegionalExitEvent_FieldPathArrayOfValues {
	fpaov, err := ParseActivityLogEventRegionalExitEvent_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type ActivityLogEventRegionalExitEvent_FieldTerminalPathArrayOfValues struct {
	ActivityLogEventRegionalExitEvent_FieldTerminalPath
	values interface{}
}

var _ ActivityLogEventRegionalExitEvent_FieldPathArrayOfValues = (*ActivityLogEventRegionalExitEvent_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *ActivityLogEventRegionalExitEvent_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case ActivityLogEventRegionalExitEvent_FieldPathSelectorStatus:
		for _, v := range fpaov.values.([]*rpc.Status) {
			values = append(values, v)
		}
	case ActivityLogEventRegionalExitEvent_FieldPathSelectorTime:
		for _, v := range fpaov.values.([]*timestamppb.Timestamp) {
			values = append(values, v)
		}
	case ActivityLogEventRegionalExitEvent_FieldPathSelectorRegionId:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *ActivityLogEventRegionalExitEvent_FieldTerminalPathArrayOfValues) AsStatusArrayOfValues() ([]*rpc.Status, bool) {
	res, ok := fpaov.values.([]*rpc.Status)
	return res, ok
}
func (fpaov *ActivityLogEventRegionalExitEvent_FieldTerminalPathArrayOfValues) AsTimeArrayOfValues() ([]*timestamppb.Timestamp, bool) {
	res, ok := fpaov.values.([]*timestamppb.Timestamp)
	return res, ok
}
func (fpaov *ActivityLogEventRegionalExitEvent_FieldTerminalPathArrayOfValues) AsRegionIdArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}

type ActivityLogEventRegionalExitEvent_FieldSubPathArrayOfValues struct {
	ActivityLogEventRegionalExitEvent_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ ActivityLogEventRegionalExitEvent_FieldPathArrayOfValues = (*ActivityLogEventRegionalExitEvent_FieldSubPathArrayOfValues)(nil)

func (fpsaov *ActivityLogEventRegionalExitEvent_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *ActivityLogEventRegionalExitEvent_FieldSubPathArrayOfValues) AsStatusPathArrayOfValues() (rpc.Status_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(rpc.Status_FieldPathArrayOfValues)
	return res, ok
}

// FieldPath provides implementation to handle
// https://github.com/protocolbuffers/protobuf/blob/master/src/google/protobuf/field_mask.proto
type ActivityLogEventExitEvent_FieldPath interface {
	gotenobject.FieldPath
	Selector() ActivityLogEventExitEvent_FieldPathSelector
	Get(source *ActivityLog_Event_ExitEvent) []interface{}
	GetSingle(source *ActivityLog_Event_ExitEvent) (interface{}, bool)
	ClearValue(item *ActivityLog_Event_ExitEvent)

	// Those methods build corresponding ActivityLogEventExitEvent_FieldPathValue
	// (or array of values) and holds passed value. Panics if injected type is incorrect.
	WithIValue(value interface{}) ActivityLogEventExitEvent_FieldPathValue
	WithIArrayOfValues(values interface{}) ActivityLogEventExitEvent_FieldPathArrayOfValues
	WithIArrayItemValue(value interface{}) ActivityLogEventExitEvent_FieldPathArrayItemValue
}

type ActivityLogEventExitEvent_FieldPathSelector int32

const (
	ActivityLogEventExitEvent_FieldPathSelectorStatus ActivityLogEventExitEvent_FieldPathSelector = 0
	ActivityLogEventExitEvent_FieldPathSelectorTime   ActivityLogEventExitEvent_FieldPathSelector = 1
)

func (s ActivityLogEventExitEvent_FieldPathSelector) String() string {
	switch s {
	case ActivityLogEventExitEvent_FieldPathSelectorStatus:
		return "status"
	case ActivityLogEventExitEvent_FieldPathSelectorTime:
		return "time"
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_Event_ExitEvent: %d", s))
	}
}

func BuildActivityLogEventExitEvent_FieldPath(fp gotenobject.RawFieldPath) (ActivityLogEventExitEvent_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object ActivityLog_Event_ExitEvent")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "status":
			return &ActivityLogEventExitEvent_FieldTerminalPath{selector: ActivityLogEventExitEvent_FieldPathSelectorStatus}, nil
		case "time":
			return &ActivityLogEventExitEvent_FieldTerminalPath{selector: ActivityLogEventExitEvent_FieldPathSelectorTime}, nil
		}
	} else {
		switch fp[0] {
		case "status":
			if subpath, err := rpc.BuildStatus_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &ActivityLogEventExitEvent_FieldSubPath{selector: ActivityLogEventExitEvent_FieldPathSelectorStatus, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object ActivityLog_Event_ExitEvent", fp)
}

func ParseActivityLogEventExitEvent_FieldPath(rawField string) (ActivityLogEventExitEvent_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildActivityLogEventExitEvent_FieldPath(fp)
}

func MustParseActivityLogEventExitEvent_FieldPath(rawField string) ActivityLogEventExitEvent_FieldPath {
	fp, err := ParseActivityLogEventExitEvent_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type ActivityLogEventExitEvent_FieldTerminalPath struct {
	selector ActivityLogEventExitEvent_FieldPathSelector
}

var _ ActivityLogEventExitEvent_FieldPath = (*ActivityLogEventExitEvent_FieldTerminalPath)(nil)

func (fp *ActivityLogEventExitEvent_FieldTerminalPath) Selector() ActivityLogEventExitEvent_FieldPathSelector {
	return fp.selector
}

// String returns path representation in proto convention
func (fp *ActivityLogEventExitEvent_FieldTerminalPath) String() string {
	return fp.selector.String()
}

// JSONString returns path representation is JSON convention
func (fp *ActivityLogEventExitEvent_FieldTerminalPath) JSONString() string {
	return strcase.ToLowerCamel(fp.String())
}

// Get returns all values pointed by specific field from source ActivityLog_Event_ExitEvent
func (fp *ActivityLogEventExitEvent_FieldTerminalPath) Get(source *ActivityLog_Event_ExitEvent) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case ActivityLogEventExitEvent_FieldPathSelectorStatus:
			if source.Status != nil {
				values = append(values, source.Status)
			}
		case ActivityLogEventExitEvent_FieldPathSelectorTime:
			if source.Time != nil {
				values = append(values, source.Time)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for ActivityLog_Event_ExitEvent: %d", fp.selector))
		}
	}
	return
}

func (fp *ActivityLogEventExitEvent_FieldTerminalPath) GetRaw(source proto.Message) []interface{} {
	return fp.Get(source.(*ActivityLog_Event_ExitEvent))
}

// GetSingle returns value pointed by specific field of from source ActivityLog_Event_ExitEvent
func (fp *ActivityLogEventExitEvent_FieldTerminalPath) GetSingle(source *ActivityLog_Event_ExitEvent) (interface{}, bool) {
	switch fp.selector {
	case ActivityLogEventExitEvent_FieldPathSelectorStatus:
		res := source.GetStatus()
		return res, res != nil
	case ActivityLogEventExitEvent_FieldPathSelectorTime:
		res := source.GetTime()
		return res, res != nil
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_Event_ExitEvent: %d", fp.selector))
	}
}

func (fp *ActivityLogEventExitEvent_FieldTerminalPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fp.GetSingle(source.(*ActivityLog_Event_ExitEvent))
}

// GetDefault returns a default value of the field type
func (fp *ActivityLogEventExitEvent_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case ActivityLogEventExitEvent_FieldPathSelectorStatus:
		return (*rpc.Status)(nil)
	case ActivityLogEventExitEvent_FieldPathSelectorTime:
		return (*timestamppb.Timestamp)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_Event_ExitEvent: %d", fp.selector))
	}
}

func (fp *ActivityLogEventExitEvent_FieldTerminalPath) ClearValue(item *ActivityLog_Event_ExitEvent) {
	if item != nil {
		switch fp.selector {
		case ActivityLogEventExitEvent_FieldPathSelectorStatus:
			item.Status = nil
		case ActivityLogEventExitEvent_FieldPathSelectorTime:
			item.Time = nil
		default:
			panic(fmt.Sprintf("Invalid selector for ActivityLog_Event_ExitEvent: %d", fp.selector))
		}
	}
}

func (fp *ActivityLogEventExitEvent_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*ActivityLog_Event_ExitEvent))
}

// IsLeaf - whether field path is holds simple value
func (fp *ActivityLogEventExitEvent_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == ActivityLogEventExitEvent_FieldPathSelectorTime
}

func (fp *ActivityLogEventExitEvent_FieldTerminalPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
	return []gotenobject.FieldPath{fp}
}

func (fp *ActivityLogEventExitEvent_FieldTerminalPath) WithIValue(value interface{}) ActivityLogEventExitEvent_FieldPathValue {
	switch fp.selector {
	case ActivityLogEventExitEvent_FieldPathSelectorStatus:
		return &ActivityLogEventExitEvent_FieldTerminalPathValue{ActivityLogEventExitEvent_FieldTerminalPath: *fp, value: value.(*rpc.Status)}
	case ActivityLogEventExitEvent_FieldPathSelectorTime:
		return &ActivityLogEventExitEvent_FieldTerminalPathValue{ActivityLogEventExitEvent_FieldTerminalPath: *fp, value: value.(*timestamppb.Timestamp)}
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_Event_ExitEvent: %d", fp.selector))
	}
}

func (fp *ActivityLogEventExitEvent_FieldTerminalPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
	return fp.WithIValue(value)
}

func (fp *ActivityLogEventExitEvent_FieldTerminalPath) WithIArrayOfValues(values interface{}) ActivityLogEventExitEvent_FieldPathArrayOfValues {
	fpaov := &ActivityLogEventExitEvent_FieldTerminalPathArrayOfValues{ActivityLogEventExitEvent_FieldTerminalPath: *fp}
	switch fp.selector {
	case ActivityLogEventExitEvent_FieldPathSelectorStatus:
		return &ActivityLogEventExitEvent_FieldTerminalPathArrayOfValues{ActivityLogEventExitEvent_FieldTerminalPath: *fp, values: values.([]*rpc.Status)}
	case ActivityLogEventExitEvent_FieldPathSelectorTime:
		return &ActivityLogEventExitEvent_FieldTerminalPathArrayOfValues{ActivityLogEventExitEvent_FieldTerminalPath: *fp, values: values.([]*timestamppb.Timestamp)}
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_Event_ExitEvent: %d", fp.selector))
	}
	return fpaov
}

func (fp *ActivityLogEventExitEvent_FieldTerminalPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
	return fp.WithIArrayOfValues(values)
}

func (fp *ActivityLogEventExitEvent_FieldTerminalPath) WithIArrayItemValue(value interface{}) ActivityLogEventExitEvent_FieldPathArrayItemValue {
	switch fp.selector {
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_Event_ExitEvent: %d", fp.selector))
	}
}

func (fp *ActivityLogEventExitEvent_FieldTerminalPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
	return fp.WithIArrayItemValue(value)
}

type ActivityLogEventExitEvent_FieldSubPath struct {
	selector ActivityLogEventExitEvent_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ ActivityLogEventExitEvent_FieldPath = (*ActivityLogEventExitEvent_FieldSubPath)(nil)

func (fps *ActivityLogEventExitEvent_FieldSubPath) Selector() ActivityLogEventExitEvent_FieldPathSelector {
	return fps.selector
}
func (fps *ActivityLogEventExitEvent_FieldSubPath) AsStatusSubPath() (rpc.Status_FieldPath, bool) {
	res, ok := fps.subPath.(rpc.Status_FieldPath)
	return res, ok
}

// String returns path representation in proto convention
func (fps *ActivityLogEventExitEvent_FieldSubPath) String() string {
	return fps.selector.String() + "." + fps.subPath.String()
}

// JSONString returns path representation is JSON convention
func (fps *ActivityLogEventExitEvent_FieldSubPath) JSONString() string {
	return strcase.ToLowerCamel(fps.selector.String()) + "." + fps.subPath.JSONString()
}

// Get returns all values pointed by selected field from source ActivityLog_Event_ExitEvent
func (fps *ActivityLogEventExitEvent_FieldSubPath) Get(source *ActivityLog_Event_ExitEvent) (values []interface{}) {
	switch fps.selector {
	case ActivityLogEventExitEvent_FieldPathSelectorStatus:
		values = append(values, fps.subPath.GetRaw(source.GetStatus())...)
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_Event_ExitEvent: %d", fps.selector))
	}
	return
}

func (fps *ActivityLogEventExitEvent_FieldSubPath) GetRaw(source proto.Message) []interface{} {
	return fps.Get(source.(*ActivityLog_Event_ExitEvent))
}

// GetSingle returns value of selected field from source ActivityLog_Event_ExitEvent
func (fps *ActivityLogEventExitEvent_FieldSubPath) GetSingle(source *ActivityLog_Event_ExitEvent) (interface{}, bool) {
	switch fps.selector {
	case ActivityLogEventExitEvent_FieldPathSelectorStatus:
		if source.GetStatus() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetStatus())
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_Event_ExitEvent: %d", fps.selector))
	}
}

func (fps *ActivityLogEventExitEvent_FieldSubPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fps.GetSingle(source.(*ActivityLog_Event_ExitEvent))
}

// GetDefault returns a default value of the field type
func (fps *ActivityLogEventExitEvent_FieldSubPath) GetDefault() interface{} {
	return fps.subPath.GetDefault()
}

func (fps *ActivityLogEventExitEvent_FieldSubPath) ClearValue(item *ActivityLog_Event_ExitEvent) {
	if item != nil {
		switch fps.selector {
		case ActivityLogEventExitEvent_FieldPathSelectorStatus:
			fps.subPath.ClearValueRaw(item.Status)
		default:
			panic(fmt.Sprintf("Invalid selector for ActivityLog_Event_ExitEvent: %d", fps.selector))
		}
	}
}

func (fps *ActivityLogEventExitEvent_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*ActivityLog_Event_ExitEvent))
}

// IsLeaf - whether field path is holds simple value
func (fps *ActivityLogEventExitEvent_FieldSubPath) IsLeaf() bool {
	return fps.subPath.IsLeaf()
}

func (fps *ActivityLogEventExitEvent_FieldSubPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
	iPaths := []gotenobject.FieldPath{&ActivityLogEventExitEvent_FieldTerminalPath{selector: fps.selector}}
	iPaths = append(iPaths, fps.subPath.SplitIntoTerminalIPaths()...)
	return iPaths
}

func (fps *ActivityLogEventExitEvent_FieldSubPath) WithIValue(value interface{}) ActivityLogEventExitEvent_FieldPathValue {
	return &ActivityLogEventExitEvent_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

func (fps *ActivityLogEventExitEvent_FieldSubPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
	return fps.WithIValue(value)
}

func (fps *ActivityLogEventExitEvent_FieldSubPath) WithIArrayOfValues(values interface{}) ActivityLogEventExitEvent_FieldPathArrayOfValues {
	return &ActivityLogEventExitEvent_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

func (fps *ActivityLogEventExitEvent_FieldSubPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
	return fps.WithIArrayOfValues(values)
}

func (fps *ActivityLogEventExitEvent_FieldSubPath) WithIArrayItemValue(value interface{}) ActivityLogEventExitEvent_FieldPathArrayItemValue {
	return &ActivityLogEventExitEvent_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

func (fps *ActivityLogEventExitEvent_FieldSubPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
	return fps.WithIArrayItemValue(value)
}

// ActivityLogEventExitEvent_FieldPathValue allows storing values for ExitEvent fields according to their type
type ActivityLogEventExitEvent_FieldPathValue interface {
	ActivityLogEventExitEvent_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **ActivityLog_Event_ExitEvent)
	CompareWith(*ActivityLog_Event_ExitEvent) (cmp int, comparable bool)
}

func ParseActivityLogEventExitEvent_FieldPathValue(pathStr, valueStr string) (ActivityLogEventExitEvent_FieldPathValue, error) {
	fp, err := ParseActivityLogEventExitEvent_FieldPath(pathStr)
	if err != nil {
		return nil, err
	}
	fpv, err := gotenobject.ParseFieldPathValue(fp, valueStr)
	if err != nil {
		return nil, status.Errorf(codes.InvalidArgument, "error parsing ExitEvent field path value from %s: %v", valueStr, err)
	}
	return fpv.(ActivityLogEventExitEvent_FieldPathValue), nil
}

func MustParseActivityLogEventExitEvent_FieldPathValue(pathStr, valueStr string) ActivityLogEventExitEvent_FieldPathValue {
	fpv, err := ParseActivityLogEventExitEvent_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type ActivityLogEventExitEvent_FieldTerminalPathValue struct {
	ActivityLogEventExitEvent_FieldTerminalPath
	value interface{}
}

var _ ActivityLogEventExitEvent_FieldPathValue = (*ActivityLogEventExitEvent_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'ExitEvent' as interface{}
func (fpv *ActivityLogEventExitEvent_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *ActivityLogEventExitEvent_FieldTerminalPathValue) AsStatusValue() (*rpc.Status, bool) {
	res, ok := fpv.value.(*rpc.Status)
	return res, ok
}
func (fpv *ActivityLogEventExitEvent_FieldTerminalPathValue) AsTimeValue() (*timestamppb.Timestamp, bool) {
	res, ok := fpv.value.(*timestamppb.Timestamp)
	return res, ok
}

// SetTo stores value for selected field for object ExitEvent
func (fpv *ActivityLogEventExitEvent_FieldTerminalPathValue) SetTo(target **ActivityLog_Event_ExitEvent) {
	if *target == nil {
		*target = new(ActivityLog_Event_ExitEvent)
	}
	switch fpv.selector {
	case ActivityLogEventExitEvent_FieldPathSelectorStatus:
		(*target).Status = fpv.value.(*rpc.Status)
	case ActivityLogEventExitEvent_FieldPathSelectorTime:
		(*target).Time = fpv.value.(*timestamppb.Timestamp)
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_Event_ExitEvent: %d", fpv.selector))
	}
}

func (fpv *ActivityLogEventExitEvent_FieldTerminalPathValue) SetToRaw(target proto.Message) {
	typedObject := target.(*ActivityLog_Event_ExitEvent)
	fpv.SetTo(&typedObject)
}

// CompareWith compares value in the 'ActivityLogEventExitEvent_FieldTerminalPathValue' with the value under path in 'ActivityLog_Event_ExitEvent'.
func (fpv *ActivityLogEventExitEvent_FieldTerminalPathValue) CompareWith(source *ActivityLog_Event_ExitEvent) (int, bool) {
	switch fpv.selector {
	case ActivityLogEventExitEvent_FieldPathSelectorStatus:
		return 0, false
	case ActivityLogEventExitEvent_FieldPathSelectorTime:
		leftValue := fpv.value.(*timestamppb.Timestamp)
		rightValue := source.GetTime()
		if leftValue == nil {
			if rightValue != nil {
				return -1, true
			}
			return 0, true
		}
		if rightValue == nil {
			return 1, true
		}
		if leftValue.AsTime().Equal(rightValue.AsTime()) {
			return 0, true
		} else if leftValue.AsTime().Before(rightValue.AsTime()) {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_Event_ExitEvent: %d", fpv.selector))
	}
}

func (fpv *ActivityLogEventExitEvent_FieldTerminalPathValue) CompareWithRaw(source proto.Message) (int, bool) {
	return fpv.CompareWith(source.(*ActivityLog_Event_ExitEvent))
}

type ActivityLogEventExitEvent_FieldSubPathValue struct {
	ActivityLogEventExitEvent_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ ActivityLogEventExitEvent_FieldPathValue = (*ActivityLogEventExitEvent_FieldSubPathValue)(nil)

func (fpvs *ActivityLogEventExitEvent_FieldSubPathValue) AsStatusPathValue() (rpc.Status_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(rpc.Status_FieldPathValue)
	return res, ok
}

func (fpvs *ActivityLogEventExitEvent_FieldSubPathValue) SetTo(target **ActivityLog_Event_ExitEvent) {
	if *target == nil {
		*target = new(ActivityLog_Event_ExitEvent)
	}
	switch fpvs.Selector() {
	case ActivityLogEventExitEvent_FieldPathSelectorStatus:
		fpvs.subPathValue.(rpc.Status_FieldPathValue).SetTo(&(*target).Status)
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_Event_ExitEvent: %d", fpvs.Selector()))
	}
}

func (fpvs *ActivityLogEventExitEvent_FieldSubPathValue) SetToRaw(target proto.Message) {
	typedObject := target.(*ActivityLog_Event_ExitEvent)
	fpvs.SetTo(&typedObject)
}

func (fpvs *ActivityLogEventExitEvent_FieldSubPathValue) GetRawValue() interface{} {
	return fpvs.subPathValue.GetRawValue()
}

func (fpvs *ActivityLogEventExitEvent_FieldSubPathValue) CompareWith(source *ActivityLog_Event_ExitEvent) (int, bool) {
	switch fpvs.Selector() {
	case ActivityLogEventExitEvent_FieldPathSelectorStatus:
		return fpvs.subPathValue.(rpc.Status_FieldPathValue).CompareWith(source.GetStatus())
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_Event_ExitEvent: %d", fpvs.Selector()))
	}
}

func (fpvs *ActivityLogEventExitEvent_FieldSubPathValue) CompareWithRaw(source proto.Message) (int, bool) {
	return fpvs.CompareWith(source.(*ActivityLog_Event_ExitEvent))
}

// ActivityLogEventExitEvent_FieldPathArrayItemValue allows storing single item in Path-specific values for ExitEvent according to their type
// Present only for array (repeated) types.
type ActivityLogEventExitEvent_FieldPathArrayItemValue interface {
	gotenobject.FieldPathArrayItemValue
	ActivityLogEventExitEvent_FieldPath
	ContainsValue(*ActivityLog_Event_ExitEvent) bool
}

// ParseActivityLogEventExitEvent_FieldPathArrayItemValue parses string and JSON-encoded value to its Value
func ParseActivityLogEventExitEvent_FieldPathArrayItemValue(pathStr, valueStr string) (ActivityLogEventExitEvent_FieldPathArrayItemValue, error) {
	fp, err := ParseActivityLogEventExitEvent_FieldPath(pathStr)
	if err != nil {
		return nil, err
	}
	fpaiv, err := gotenobject.ParseFieldPathArrayItemValue(fp, valueStr)
	if err != nil {
		return nil, status.Errorf(codes.InvalidArgument, "error parsing ExitEvent field path array item value from %s: %v", valueStr, err)
	}
	return fpaiv.(ActivityLogEventExitEvent_FieldPathArrayItemValue), nil
}

func MustParseActivityLogEventExitEvent_FieldPathArrayItemValue(pathStr, valueStr string) ActivityLogEventExitEvent_FieldPathArrayItemValue {
	fpaiv, err := ParseActivityLogEventExitEvent_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type ActivityLogEventExitEvent_FieldTerminalPathArrayItemValue struct {
	ActivityLogEventExitEvent_FieldTerminalPath
	value interface{}
}

var _ ActivityLogEventExitEvent_FieldPathArrayItemValue = (*ActivityLogEventExitEvent_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object ActivityLog_Event_ExitEvent as interface{}
func (fpaiv *ActivityLogEventExitEvent_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}

func (fpaiv *ActivityLogEventExitEvent_FieldTerminalPathArrayItemValue) GetSingle(source *ActivityLog_Event_ExitEvent) (interface{}, bool) {
	return nil, false
}

func (fpaiv *ActivityLogEventExitEvent_FieldTerminalPathArrayItemValue) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fpaiv.GetSingle(source.(*ActivityLog_Event_ExitEvent))
}

// Contains returns a boolean indicating if value that is being held is present in given 'ExitEvent'
func (fpaiv *ActivityLogEventExitEvent_FieldTerminalPathArrayItemValue) ContainsValue(source *ActivityLog_Event_ExitEvent) bool {
	slice := fpaiv.ActivityLogEventExitEvent_FieldTerminalPath.Get(source)
	for _, v := range slice {
		if asProtoMsg, ok := fpaiv.value.(proto.Message); ok {
			if proto.Equal(asProtoMsg, v.(proto.Message)) {
				return true
			}
		} else if reflect.DeepEqual(v, fpaiv.value) {
			return true
		}
	}
	return false
}

type ActivityLogEventExitEvent_FieldSubPathArrayItemValue struct {
	ActivityLogEventExitEvent_FieldPath
	subPathItemValue gotenobject.FieldPathArrayItemValue
}

// GetRawValue returns stored array item value
func (fpaivs *ActivityLogEventExitEvent_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *ActivityLogEventExitEvent_FieldSubPathArrayItemValue) AsStatusPathItemValue() (rpc.Status_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(rpc.Status_FieldPathArrayItemValue)
	return res, ok
}

// Contains returns a boolean indicating if value that is being held is present in given 'ExitEvent'
func (fpaivs *ActivityLogEventExitEvent_FieldSubPathArrayItemValue) ContainsValue(source *ActivityLog_Event_ExitEvent) bool {
	switch fpaivs.Selector() {
	case ActivityLogEventExitEvent_FieldPathSelectorStatus:
		return fpaivs.subPathItemValue.(rpc.Status_FieldPathArrayItemValue).ContainsValue(source.GetStatus())
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_Event_ExitEvent: %d", fpaivs.Selector()))
	}
}

// ActivityLogEventExitEvent_FieldPathArrayOfValues allows storing slice of values for ExitEvent fields according to their type
type ActivityLogEventExitEvent_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	ActivityLogEventExitEvent_FieldPath
}

func ParseActivityLogEventExitEvent_FieldPathArrayOfValues(pathStr, valuesStr string) (ActivityLogEventExitEvent_FieldPathArrayOfValues, error) {
	fp, err := ParseActivityLogEventExitEvent_FieldPath(pathStr)
	if err != nil {
		return nil, err
	}
	fpaov, err := gotenobject.ParseFieldPathArrayOfValues(fp, valuesStr)
	if err != nil {
		return nil, status.Errorf(codes.InvalidArgument, "error parsing ExitEvent field path array of values from %s: %v", valuesStr, err)
	}
	return fpaov.(ActivityLogEventExitEvent_FieldPathArrayOfValues), nil
}

func MustParseActivityLogEventExitEvent_FieldPathArrayOfValues(pathStr, valuesStr string) ActivityLogEventExitEvent_FieldPathArrayOfValues {
	fpaov, err := ParseActivityLogEventExitEvent_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type ActivityLogEventExitEvent_FieldTerminalPathArrayOfValues struct {
	ActivityLogEventExitEvent_FieldTerminalPath
	values interface{}
}

var _ ActivityLogEventExitEvent_FieldPathArrayOfValues = (*ActivityLogEventExitEvent_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *ActivityLogEventExitEvent_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case ActivityLogEventExitEvent_FieldPathSelectorStatus:
		for _, v := range fpaov.values.([]*rpc.Status) {
			values = append(values, v)
		}
	case ActivityLogEventExitEvent_FieldPathSelectorTime:
		for _, v := range fpaov.values.([]*timestamppb.Timestamp) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *ActivityLogEventExitEvent_FieldTerminalPathArrayOfValues) AsStatusArrayOfValues() ([]*rpc.Status, bool) {
	res, ok := fpaov.values.([]*rpc.Status)
	return res, ok
}
func (fpaov *ActivityLogEventExitEvent_FieldTerminalPathArrayOfValues) AsTimeArrayOfValues() ([]*timestamppb.Timestamp, bool) {
	res, ok := fpaov.values.([]*timestamppb.Timestamp)
	return res, ok
}

type ActivityLogEventExitEvent_FieldSubPathArrayOfValues struct {
	ActivityLogEventExitEvent_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ ActivityLogEventExitEvent_FieldPathArrayOfValues = (*ActivityLogEventExitEvent_FieldSubPathArrayOfValues)(nil)

func (fpsaov *ActivityLogEventExitEvent_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *ActivityLogEventExitEvent_FieldSubPathArrayOfValues) AsStatusPathArrayOfValues() (rpc.Status_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(rpc.Status_FieldPathArrayOfValues)
	return res, ok
}

// FieldPath provides implementation to handle
// https://github.com/protocolbuffers/protobuf/blob/master/src/google/protobuf/field_mask.proto
type ActivityLogResourceDifference_FieldPath interface {
	gotenobject.FieldPath
	Selector() ActivityLogResourceDifference_FieldPathSelector
	Get(source *ActivityLog_Resource_Difference) []interface{}
	GetSingle(source *ActivityLog_Resource_Difference) (interface{}, bool)
	ClearValue(item *ActivityLog_Resource_Difference)

	// Those methods build corresponding ActivityLogResourceDifference_FieldPathValue
	// (or array of values) and holds passed value. Panics if injected type is incorrect.
	WithIValue(value interface{}) ActivityLogResourceDifference_FieldPathValue
	WithIArrayOfValues(values interface{}) ActivityLogResourceDifference_FieldPathArrayOfValues
	WithIArrayItemValue(value interface{}) ActivityLogResourceDifference_FieldPathArrayItemValue
}

type ActivityLogResourceDifference_FieldPathSelector int32

const (
	ActivityLogResourceDifference_FieldPathSelectorFields ActivityLogResourceDifference_FieldPathSelector = 0
	ActivityLogResourceDifference_FieldPathSelectorBefore ActivityLogResourceDifference_FieldPathSelector = 1
	ActivityLogResourceDifference_FieldPathSelectorAfter  ActivityLogResourceDifference_FieldPathSelector = 2
)

func (s ActivityLogResourceDifference_FieldPathSelector) String() string {
	switch s {
	case ActivityLogResourceDifference_FieldPathSelectorFields:
		return "fields"
	case ActivityLogResourceDifference_FieldPathSelectorBefore:
		return "before"
	case ActivityLogResourceDifference_FieldPathSelectorAfter:
		return "after"
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_Resource_Difference: %d", s))
	}
}

func BuildActivityLogResourceDifference_FieldPath(fp gotenobject.RawFieldPath) (ActivityLogResourceDifference_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object ActivityLog_Resource_Difference")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "fields":
			return &ActivityLogResourceDifference_FieldTerminalPath{selector: ActivityLogResourceDifference_FieldPathSelectorFields}, nil
		case "before":
			return &ActivityLogResourceDifference_FieldTerminalPath{selector: ActivityLogResourceDifference_FieldPathSelectorBefore}, nil
		case "after":
			return &ActivityLogResourceDifference_FieldTerminalPath{selector: ActivityLogResourceDifference_FieldPathSelectorAfter}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object ActivityLog_Resource_Difference", fp)
}

func ParseActivityLogResourceDifference_FieldPath(rawField string) (ActivityLogResourceDifference_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildActivityLogResourceDifference_FieldPath(fp)
}

func MustParseActivityLogResourceDifference_FieldPath(rawField string) ActivityLogResourceDifference_FieldPath {
	fp, err := ParseActivityLogResourceDifference_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type ActivityLogResourceDifference_FieldTerminalPath struct {
	selector ActivityLogResourceDifference_FieldPathSelector
}

var _ ActivityLogResourceDifference_FieldPath = (*ActivityLogResourceDifference_FieldTerminalPath)(nil)

func (fp *ActivityLogResourceDifference_FieldTerminalPath) Selector() ActivityLogResourceDifference_FieldPathSelector {
	return fp.selector
}

// String returns path representation in proto convention
func (fp *ActivityLogResourceDifference_FieldTerminalPath) String() string {
	return fp.selector.String()
}

// JSONString returns path representation is JSON convention
func (fp *ActivityLogResourceDifference_FieldTerminalPath) JSONString() string {
	return strcase.ToLowerCamel(fp.String())
}

// Get returns all values pointed by specific field from source ActivityLog_Resource_Difference
func (fp *ActivityLogResourceDifference_FieldTerminalPath) Get(source *ActivityLog_Resource_Difference) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case ActivityLogResourceDifference_FieldPathSelectorFields:
			if source.Fields != nil {
				values = append(values, source.Fields)
			}
		case ActivityLogResourceDifference_FieldPathSelectorBefore:
			if source.Before != nil {
				values = append(values, source.Before)
			}
		case ActivityLogResourceDifference_FieldPathSelectorAfter:
			if source.After != nil {
				values = append(values, source.After)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for ActivityLog_Resource_Difference: %d", fp.selector))
		}
	}
	return
}

func (fp *ActivityLogResourceDifference_FieldTerminalPath) GetRaw(source proto.Message) []interface{} {
	return fp.Get(source.(*ActivityLog_Resource_Difference))
}

// GetSingle returns value pointed by specific field of from source ActivityLog_Resource_Difference
func (fp *ActivityLogResourceDifference_FieldTerminalPath) GetSingle(source *ActivityLog_Resource_Difference) (interface{}, bool) {
	switch fp.selector {
	case ActivityLogResourceDifference_FieldPathSelectorFields:
		res := source.GetFields()
		return res, res != nil
	case ActivityLogResourceDifference_FieldPathSelectorBefore:
		res := source.GetBefore()
		return res, res != nil
	case ActivityLogResourceDifference_FieldPathSelectorAfter:
		res := source.GetAfter()
		return res, res != nil
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_Resource_Difference: %d", fp.selector))
	}
}

func (fp *ActivityLogResourceDifference_FieldTerminalPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fp.GetSingle(source.(*ActivityLog_Resource_Difference))
}

// GetDefault returns a default value of the field type
func (fp *ActivityLogResourceDifference_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case ActivityLogResourceDifference_FieldPathSelectorFields:
		return (*fieldmaskpb.FieldMask)(nil)
	case ActivityLogResourceDifference_FieldPathSelectorBefore:
		return (*anypb.Any)(nil)
	case ActivityLogResourceDifference_FieldPathSelectorAfter:
		return (*anypb.Any)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_Resource_Difference: %d", fp.selector))
	}
}

func (fp *ActivityLogResourceDifference_FieldTerminalPath) ClearValue(item *ActivityLog_Resource_Difference) {
	if item != nil {
		switch fp.selector {
		case ActivityLogResourceDifference_FieldPathSelectorFields:
			item.Fields = nil
		case ActivityLogResourceDifference_FieldPathSelectorBefore:
			item.Before = nil
		case ActivityLogResourceDifference_FieldPathSelectorAfter:
			item.After = nil
		default:
			panic(fmt.Sprintf("Invalid selector for ActivityLog_Resource_Difference: %d", fp.selector))
		}
	}
}

func (fp *ActivityLogResourceDifference_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*ActivityLog_Resource_Difference))
}

// IsLeaf - whether field path is holds simple value
func (fp *ActivityLogResourceDifference_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == ActivityLogResourceDifference_FieldPathSelectorFields ||
		fp.selector == ActivityLogResourceDifference_FieldPathSelectorBefore ||
		fp.selector == ActivityLogResourceDifference_FieldPathSelectorAfter
}

func (fp *ActivityLogResourceDifference_FieldTerminalPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
	return []gotenobject.FieldPath{fp}
}

func (fp *ActivityLogResourceDifference_FieldTerminalPath) WithIValue(value interface{}) ActivityLogResourceDifference_FieldPathValue {
	switch fp.selector {
	case ActivityLogResourceDifference_FieldPathSelectorFields:
		return &ActivityLogResourceDifference_FieldTerminalPathValue{ActivityLogResourceDifference_FieldTerminalPath: *fp, value: value.(*fieldmaskpb.FieldMask)}
	case ActivityLogResourceDifference_FieldPathSelectorBefore:
		return &ActivityLogResourceDifference_FieldTerminalPathValue{ActivityLogResourceDifference_FieldTerminalPath: *fp, value: value.(*anypb.Any)}
	case ActivityLogResourceDifference_FieldPathSelectorAfter:
		return &ActivityLogResourceDifference_FieldTerminalPathValue{ActivityLogResourceDifference_FieldTerminalPath: *fp, value: value.(*anypb.Any)}
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_Resource_Difference: %d", fp.selector))
	}
}

func (fp *ActivityLogResourceDifference_FieldTerminalPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
	return fp.WithIValue(value)
}

func (fp *ActivityLogResourceDifference_FieldTerminalPath) WithIArrayOfValues(values interface{}) ActivityLogResourceDifference_FieldPathArrayOfValues {
	fpaov := &ActivityLogResourceDifference_FieldTerminalPathArrayOfValues{ActivityLogResourceDifference_FieldTerminalPath: *fp}
	switch fp.selector {
	case ActivityLogResourceDifference_FieldPathSelectorFields:
		return &ActivityLogResourceDifference_FieldTerminalPathArrayOfValues{ActivityLogResourceDifference_FieldTerminalPath: *fp, values: values.([]*fieldmaskpb.FieldMask)}
	case ActivityLogResourceDifference_FieldPathSelectorBefore:
		return &ActivityLogResourceDifference_FieldTerminalPathArrayOfValues{ActivityLogResourceDifference_FieldTerminalPath: *fp, values: values.([]*anypb.Any)}
	case ActivityLogResourceDifference_FieldPathSelectorAfter:
		return &ActivityLogResourceDifference_FieldTerminalPathArrayOfValues{ActivityLogResourceDifference_FieldTerminalPath: *fp, values: values.([]*anypb.Any)}
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_Resource_Difference: %d", fp.selector))
	}
	return fpaov
}

func (fp *ActivityLogResourceDifference_FieldTerminalPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
	return fp.WithIArrayOfValues(values)
}

func (fp *ActivityLogResourceDifference_FieldTerminalPath) WithIArrayItemValue(value interface{}) ActivityLogResourceDifference_FieldPathArrayItemValue {
	switch fp.selector {
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_Resource_Difference: %d", fp.selector))
	}
}

func (fp *ActivityLogResourceDifference_FieldTerminalPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
	return fp.WithIArrayItemValue(value)
}

// ActivityLogResourceDifference_FieldPathValue allows storing values for Difference fields according to their type
type ActivityLogResourceDifference_FieldPathValue interface {
	ActivityLogResourceDifference_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **ActivityLog_Resource_Difference)
	CompareWith(*ActivityLog_Resource_Difference) (cmp int, comparable bool)
}

func ParseActivityLogResourceDifference_FieldPathValue(pathStr, valueStr string) (ActivityLogResourceDifference_FieldPathValue, error) {
	fp, err := ParseActivityLogResourceDifference_FieldPath(pathStr)
	if err != nil {
		return nil, err
	}
	fpv, err := gotenobject.ParseFieldPathValue(fp, valueStr)
	if err != nil {
		return nil, status.Errorf(codes.InvalidArgument, "error parsing Difference field path value from %s: %v", valueStr, err)
	}
	return fpv.(ActivityLogResourceDifference_FieldPathValue), nil
}

func MustParseActivityLogResourceDifference_FieldPathValue(pathStr, valueStr string) ActivityLogResourceDifference_FieldPathValue {
	fpv, err := ParseActivityLogResourceDifference_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type ActivityLogResourceDifference_FieldTerminalPathValue struct {
	ActivityLogResourceDifference_FieldTerminalPath
	value interface{}
}

var _ ActivityLogResourceDifference_FieldPathValue = (*ActivityLogResourceDifference_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'Difference' as interface{}
func (fpv *ActivityLogResourceDifference_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *ActivityLogResourceDifference_FieldTerminalPathValue) AsFieldsValue() (*fieldmaskpb.FieldMask, bool) {
	res, ok := fpv.value.(*fieldmaskpb.FieldMask)
	return res, ok
}
func (fpv *ActivityLogResourceDifference_FieldTerminalPathValue) AsBeforeValue() (*anypb.Any, bool) {
	res, ok := fpv.value.(*anypb.Any)
	return res, ok
}
func (fpv *ActivityLogResourceDifference_FieldTerminalPathValue) AsAfterValue() (*anypb.Any, bool) {
	res, ok := fpv.value.(*anypb.Any)
	return res, ok
}

// SetTo stores value for selected field for object Difference
func (fpv *ActivityLogResourceDifference_FieldTerminalPathValue) SetTo(target **ActivityLog_Resource_Difference) {
	if *target == nil {
		*target = new(ActivityLog_Resource_Difference)
	}
	switch fpv.selector {
	case ActivityLogResourceDifference_FieldPathSelectorFields:
		(*target).Fields = fpv.value.(*fieldmaskpb.FieldMask)
	case ActivityLogResourceDifference_FieldPathSelectorBefore:
		(*target).Before = fpv.value.(*anypb.Any)
	case ActivityLogResourceDifference_FieldPathSelectorAfter:
		(*target).After = fpv.value.(*anypb.Any)
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_Resource_Difference: %d", fpv.selector))
	}
}

func (fpv *ActivityLogResourceDifference_FieldTerminalPathValue) SetToRaw(target proto.Message) {
	typedObject := target.(*ActivityLog_Resource_Difference)
	fpv.SetTo(&typedObject)
}

// CompareWith compares value in the 'ActivityLogResourceDifference_FieldTerminalPathValue' with the value under path in 'ActivityLog_Resource_Difference'.
func (fpv *ActivityLogResourceDifference_FieldTerminalPathValue) CompareWith(source *ActivityLog_Resource_Difference) (int, bool) {
	switch fpv.selector {
	case ActivityLogResourceDifference_FieldPathSelectorFields:
		return 0, false
	case ActivityLogResourceDifference_FieldPathSelectorBefore:
		return 0, false
	case ActivityLogResourceDifference_FieldPathSelectorAfter:
		return 0, false
	default:
		panic(fmt.Sprintf("Invalid selector for ActivityLog_Resource_Difference: %d", fpv.selector))
	}
}

func (fpv *ActivityLogResourceDifference_FieldTerminalPathValue) CompareWithRaw(source proto.Message) (int, bool) {
	return fpv.CompareWith(source.(*ActivityLog_Resource_Difference))
}

// ActivityLogResourceDifference_FieldPathArrayItemValue allows storing single item in Path-specific values for Difference according to their type
// Present only for array (repeated) types.
type ActivityLogResourceDifference_FieldPathArrayItemValue interface {
	gotenobject.FieldPathArrayItemValue
	ActivityLogResourceDifference_FieldPath
	ContainsValue(*ActivityLog_Resource_Difference) bool
}

// ParseActivityLogResourceDifference_FieldPathArrayItemValue parses string and JSON-encoded value to its Value
func ParseActivityLogResourceDifference_FieldPathArrayItemValue(pathStr, valueStr string) (ActivityLogResourceDifference_FieldPathArrayItemValue, error) {
	fp, err := ParseActivityLogResourceDifference_FieldPath(pathStr)
	if err != nil {
		return nil, err
	}
	fpaiv, err := gotenobject.ParseFieldPathArrayItemValue(fp, valueStr)
	if err != nil {
		return nil, status.Errorf(codes.InvalidArgument, "error parsing Difference field path array item value from %s: %v", valueStr, err)
	}
	return fpaiv.(ActivityLogResourceDifference_FieldPathArrayItemValue), nil
}

func MustParseActivityLogResourceDifference_FieldPathArrayItemValue(pathStr, valueStr string) ActivityLogResourceDifference_FieldPathArrayItemValue {
	fpaiv, err := ParseActivityLogResourceDifference_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type ActivityLogResourceDifference_FieldTerminalPathArrayItemValue struct {
	ActivityLogResourceDifference_FieldTerminalPath
	value interface{}
}

var _ ActivityLogResourceDifference_FieldPathArrayItemValue = (*ActivityLogResourceDifference_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object ActivityLog_Resource_Difference as interface{}
func (fpaiv *ActivityLogResourceDifference_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}

func (fpaiv *ActivityLogResourceDifference_FieldTerminalPathArrayItemValue) GetSingle(source *ActivityLog_Resource_Difference) (interface{}, bool) {
	return nil, false
}

func (fpaiv *ActivityLogResourceDifference_FieldTerminalPathArrayItemValue) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fpaiv.GetSingle(source.(*ActivityLog_Resource_Difference))
}

// Contains returns a boolean indicating if value that is being held is present in given 'Difference'
func (fpaiv *ActivityLogResourceDifference_FieldTerminalPathArrayItemValue) ContainsValue(source *ActivityLog_Resource_Difference) bool {
	slice := fpaiv.ActivityLogResourceDifference_FieldTerminalPath.Get(source)
	for _, v := range slice {
		if asProtoMsg, ok := fpaiv.value.(proto.Message); ok {
			if proto.Equal(asProtoMsg, v.(proto.Message)) {
				return true
			}
		} else if reflect.DeepEqual(v, fpaiv.value) {
			return true
		}
	}
	return false
}

// ActivityLogResourceDifference_FieldPathArrayOfValues allows storing slice of values for Difference fields according to their type
type ActivityLogResourceDifference_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	ActivityLogResourceDifference_FieldPath
}

func ParseActivityLogResourceDifference_FieldPathArrayOfValues(pathStr, valuesStr string) (ActivityLogResourceDifference_FieldPathArrayOfValues, error) {
	fp, err := ParseActivityLogResourceDifference_FieldPath(pathStr)
	if err != nil {
		return nil, err
	}
	fpaov, err := gotenobject.ParseFieldPathArrayOfValues(fp, valuesStr)
	if err != nil {
		return nil, status.Errorf(codes.InvalidArgument, "error parsing Difference field path array of values from %s: %v", valuesStr, err)
	}
	return fpaov.(ActivityLogResourceDifference_FieldPathArrayOfValues), nil
}

func MustParseActivityLogResourceDifference_FieldPathArrayOfValues(pathStr, valuesStr string) ActivityLogResourceDifference_FieldPathArrayOfValues {
	fpaov, err := ParseActivityLogResourceDifference_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type ActivityLogResourceDifference_FieldTerminalPathArrayOfValues struct {
	ActivityLogResourceDifference_FieldTerminalPath
	values interface{}
}

var _ ActivityLogResourceDifference_FieldPathArrayOfValues = (*ActivityLogResourceDifference_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *ActivityLogResourceDifference_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case ActivityLogResourceDifference_FieldPathSelectorFields:
		for _, v := range fpaov.values.([]*fieldmaskpb.FieldMask) {
			values = append(values, v)
		}
	case ActivityLogResourceDifference_FieldPathSelectorBefore:
		for _, v := range fpaov.values.([]*anypb.Any) {
			values = append(values, v)
		}
	case ActivityLogResourceDifference_FieldPathSelectorAfter:
		for _, v := range fpaov.values.([]*anypb.Any) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *ActivityLogResourceDifference_FieldTerminalPathArrayOfValues) AsFieldsArrayOfValues() ([]*fieldmaskpb.FieldMask, bool) {
	res, ok := fpaov.values.([]*fieldmaskpb.FieldMask)
	return res, ok
}
func (fpaov *ActivityLogResourceDifference_FieldTerminalPathArrayOfValues) AsBeforeArrayOfValues() ([]*anypb.Any, bool) {
	res, ok := fpaov.values.([]*anypb.Any)
	return res, ok
}
func (fpaov *ActivityLogResourceDifference_FieldTerminalPathArrayOfValues) AsAfterArrayOfValues() ([]*anypb.Any, bool) {
	res, ok := fpaov.values.([]*anypb.Any)
	return res, ok
}