github.com/cloudwan/edgelq-sdk@v1.15.4/audit/resources/v1alpha2/resource_change_log/resource_change_log.pb.fieldpath.go

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

package resource_change_log

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

	"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"
	"github.com/cloudwan/goten-sdk/runtime/strcase"
)

// proto imports
import (
	common "github.com/cloudwan/edgelq-sdk/audit/resources/v1alpha2/common"
	iam_organization "github.com/cloudwan/edgelq-sdk/iam/resources/v1alpha2/organization"
	iam_project "github.com/cloudwan/edgelq-sdk/iam/resources/v1alpha2/project"
	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{}
	_ = &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 ResourceChangeLog_FieldPath interface {
	gotenobject.FieldPath
	Selector() ResourceChangeLog_FieldPathSelector
	Get(source *ResourceChangeLog) []interface{}
	GetSingle(source *ResourceChangeLog) (interface{}, bool)
	ClearValue(item *ResourceChangeLog)

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

type ResourceChangeLog_FieldPathSelector int32

const (
	ResourceChangeLog_FieldPathSelectorName           ResourceChangeLog_FieldPathSelector = 0
	ResourceChangeLog_FieldPathSelectorScope          ResourceChangeLog_FieldPathSelector = 1
	ResourceChangeLog_FieldPathSelectorRequestId      ResourceChangeLog_FieldPathSelector = 2
	ResourceChangeLog_FieldPathSelectorTimestamp      ResourceChangeLog_FieldPathSelector = 3
	ResourceChangeLog_FieldPathSelectorAuthentication ResourceChangeLog_FieldPathSelector = 4
	ResourceChangeLog_FieldPathSelectorService        ResourceChangeLog_FieldPathSelector = 5
	ResourceChangeLog_FieldPathSelectorResource       ResourceChangeLog_FieldPathSelector = 6
	ResourceChangeLog_FieldPathSelectorTransaction    ResourceChangeLog_FieldPathSelector = 7
)

func (s ResourceChangeLog_FieldPathSelector) String() string {
	switch s {
	case ResourceChangeLog_FieldPathSelectorName:
		return "name"
	case ResourceChangeLog_FieldPathSelectorScope:
		return "scope"
	case ResourceChangeLog_FieldPathSelectorRequestId:
		return "request_id"
	case ResourceChangeLog_FieldPathSelectorTimestamp:
		return "timestamp"
	case ResourceChangeLog_FieldPathSelectorAuthentication:
		return "authentication"
	case ResourceChangeLog_FieldPathSelectorService:
		return "service"
	case ResourceChangeLog_FieldPathSelectorResource:
		return "resource"
	case ResourceChangeLog_FieldPathSelectorTransaction:
		return "transaction"
	default:
		panic(fmt.Sprintf("Invalid selector for ResourceChangeLog: %d", s))
	}
}

func BuildResourceChangeLog_FieldPath(fp gotenobject.RawFieldPath) (ResourceChangeLog_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object ResourceChangeLog")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "name":
			return &ResourceChangeLog_FieldTerminalPath{selector: ResourceChangeLog_FieldPathSelectorName}, nil
		case "scope":
			return &ResourceChangeLog_FieldTerminalPath{selector: ResourceChangeLog_FieldPathSelectorScope}, nil
		case "request_id", "requestId", "request-id":
			return &ResourceChangeLog_FieldTerminalPath{selector: ResourceChangeLog_FieldPathSelectorRequestId}, nil
		case "timestamp":
			return &ResourceChangeLog_FieldTerminalPath{selector: ResourceChangeLog_FieldPathSelectorTimestamp}, nil
		case "authentication":
			return &ResourceChangeLog_FieldTerminalPath{selector: ResourceChangeLog_FieldPathSelectorAuthentication}, nil
		case "service":
			return &ResourceChangeLog_FieldTerminalPath{selector: ResourceChangeLog_FieldPathSelectorService}, nil
		case "resource":
			return &ResourceChangeLog_FieldTerminalPath{selector: ResourceChangeLog_FieldPathSelectorResource}, nil
		case "transaction":
			return &ResourceChangeLog_FieldTerminalPath{selector: ResourceChangeLog_FieldPathSelectorTransaction}, nil
		}
	} else {
		switch fp[0] {
		case "authentication":
			if subpath, err := common.BuildAuthentication_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &ResourceChangeLog_FieldSubPath{selector: ResourceChangeLog_FieldPathSelectorAuthentication, subPath: subpath}, nil
			}
		case "service":
			if subpath, err := common.BuildServiceData_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &ResourceChangeLog_FieldSubPath{selector: ResourceChangeLog_FieldPathSelectorService, subPath: subpath}, nil
			}
		case "resource":
			if subpath, err := BuildResourceChangeLogResourceChange_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &ResourceChangeLog_FieldSubPath{selector: ResourceChangeLog_FieldPathSelectorResource, subPath: subpath}, nil
			}
		case "transaction":
			if subpath, err := BuildResourceChangeLogTransactionInfo_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &ResourceChangeLog_FieldSubPath{selector: ResourceChangeLog_FieldPathSelectorTransaction, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object ResourceChangeLog", fp)
}

func ParseResourceChangeLog_FieldPath(rawField string) (ResourceChangeLog_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildResourceChangeLog_FieldPath(fp)
}

func MustParseResourceChangeLog_FieldPath(rawField string) ResourceChangeLog_FieldPath {
	fp, err := ParseResourceChangeLog_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type ResourceChangeLog_FieldTerminalPath struct {
	selector ResourceChangeLog_FieldPathSelector
}

var _ ResourceChangeLog_FieldPath = (*ResourceChangeLog_FieldTerminalPath)(nil)

func (fp *ResourceChangeLog_FieldTerminalPath) Selector() ResourceChangeLog_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source ResourceChangeLog
func (fp *ResourceChangeLog_FieldTerminalPath) Get(source *ResourceChangeLog) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case ResourceChangeLog_FieldPathSelectorName:
			if source.Name != nil {
				values = append(values, source.Name)
			}
		case ResourceChangeLog_FieldPathSelectorScope:
			values = append(values, source.Scope)
		case ResourceChangeLog_FieldPathSelectorRequestId:
			values = append(values, source.RequestId)
		case ResourceChangeLog_FieldPathSelectorTimestamp:
			if source.Timestamp != nil {
				values = append(values, source.Timestamp)
			}
		case ResourceChangeLog_FieldPathSelectorAuthentication:
			if source.Authentication != nil {
				values = append(values, source.Authentication)
			}
		case ResourceChangeLog_FieldPathSelectorService:
			if source.Service != nil {
				values = append(values, source.Service)
			}
		case ResourceChangeLog_FieldPathSelectorResource:
			if source.Resource != nil {
				values = append(values, source.Resource)
			}
		case ResourceChangeLog_FieldPathSelectorTransaction:
			if source.Transaction != nil {
				values = append(values, source.Transaction)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for ResourceChangeLog: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source ResourceChangeLog
func (fp *ResourceChangeLog_FieldTerminalPath) GetSingle(source *ResourceChangeLog) (interface{}, bool) {
	switch fp.selector {
	case ResourceChangeLog_FieldPathSelectorName:
		res := source.GetName()
		return res, res != nil
	case ResourceChangeLog_FieldPathSelectorScope:
		return source.GetScope(), source != nil
	case ResourceChangeLog_FieldPathSelectorRequestId:
		return source.GetRequestId(), source != nil
	case ResourceChangeLog_FieldPathSelectorTimestamp:
		res := source.GetTimestamp()
		return res, res != nil
	case ResourceChangeLog_FieldPathSelectorAuthentication:
		res := source.GetAuthentication()
		return res, res != nil
	case ResourceChangeLog_FieldPathSelectorService:
		res := source.GetService()
		return res, res != nil
	case ResourceChangeLog_FieldPathSelectorResource:
		res := source.GetResource()
		return res, res != nil
	case ResourceChangeLog_FieldPathSelectorTransaction:
		res := source.GetTransaction()
		return res, res != nil
	default:
		panic(fmt.Sprintf("Invalid selector for ResourceChangeLog: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *ResourceChangeLog_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case ResourceChangeLog_FieldPathSelectorName:
		return (*Name)(nil)
	case ResourceChangeLog_FieldPathSelectorScope:
		return ""
	case ResourceChangeLog_FieldPathSelectorRequestId:
		return uint64(0)
	case ResourceChangeLog_FieldPathSelectorTimestamp:
		return (*timestamppb.Timestamp)(nil)
	case ResourceChangeLog_FieldPathSelectorAuthentication:
		return (*common.Authentication)(nil)
	case ResourceChangeLog_FieldPathSelectorService:
		return (*common.ServiceData)(nil)
	case ResourceChangeLog_FieldPathSelectorResource:
		return (*ResourceChangeLog_ResourceChange)(nil)
	case ResourceChangeLog_FieldPathSelectorTransaction:
		return (*ResourceChangeLog_TransactionInfo)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for ResourceChangeLog: %d", fp.selector))
	}
}

func (fp *ResourceChangeLog_FieldTerminalPath) ClearValue(item *ResourceChangeLog) {
	if item != nil {
		switch fp.selector {
		case ResourceChangeLog_FieldPathSelectorName:
			item.Name = nil
		case ResourceChangeLog_FieldPathSelectorScope:
			item.Scope = ""
		case ResourceChangeLog_FieldPathSelectorRequestId:
			item.RequestId = uint64(0)
		case ResourceChangeLog_FieldPathSelectorTimestamp:
			item.Timestamp = nil
		case ResourceChangeLog_FieldPathSelectorAuthentication:
			item.Authentication = nil
		case ResourceChangeLog_FieldPathSelectorService:
			item.Service = nil
		case ResourceChangeLog_FieldPathSelectorResource:
			item.Resource = nil
		case ResourceChangeLog_FieldPathSelectorTransaction:
			item.Transaction = nil
		default:
			panic(fmt.Sprintf("Invalid selector for ResourceChangeLog: %d", fp.selector))
		}
	}
}

func (fp *ResourceChangeLog_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*ResourceChangeLog))
}

// IsLeaf - whether field path is holds simple value
func (fp *ResourceChangeLog_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == ResourceChangeLog_FieldPathSelectorName ||
		fp.selector == ResourceChangeLog_FieldPathSelectorScope ||
		fp.selector == ResourceChangeLog_FieldPathSelectorRequestId ||
		fp.selector == ResourceChangeLog_FieldPathSelectorTimestamp
}

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

func (fp *ResourceChangeLog_FieldTerminalPath) WithIValue(value interface{}) ResourceChangeLog_FieldPathValue {
	switch fp.selector {
	case ResourceChangeLog_FieldPathSelectorName:
		return &ResourceChangeLog_FieldTerminalPathValue{ResourceChangeLog_FieldTerminalPath: *fp, value: value.(*Name)}
	case ResourceChangeLog_FieldPathSelectorScope:
		return &ResourceChangeLog_FieldTerminalPathValue{ResourceChangeLog_FieldTerminalPath: *fp, value: value.(string)}
	case ResourceChangeLog_FieldPathSelectorRequestId:
		return &ResourceChangeLog_FieldTerminalPathValue{ResourceChangeLog_FieldTerminalPath: *fp, value: value.(uint64)}
	case ResourceChangeLog_FieldPathSelectorTimestamp:
		return &ResourceChangeLog_FieldTerminalPathValue{ResourceChangeLog_FieldTerminalPath: *fp, value: value.(*timestamppb.Timestamp)}
	case ResourceChangeLog_FieldPathSelectorAuthentication:
		return &ResourceChangeLog_FieldTerminalPathValue{ResourceChangeLog_FieldTerminalPath: *fp, value: value.(*common.Authentication)}
	case ResourceChangeLog_FieldPathSelectorService:
		return &ResourceChangeLog_FieldTerminalPathValue{ResourceChangeLog_FieldTerminalPath: *fp, value: value.(*common.ServiceData)}
	case ResourceChangeLog_FieldPathSelectorResource:
		return &ResourceChangeLog_FieldTerminalPathValue{ResourceChangeLog_FieldTerminalPath: *fp, value: value.(*ResourceChangeLog_ResourceChange)}
	case ResourceChangeLog_FieldPathSelectorTransaction:
		return &ResourceChangeLog_FieldTerminalPathValue{ResourceChangeLog_FieldTerminalPath: *fp, value: value.(*ResourceChangeLog_TransactionInfo)}
	default:
		panic(fmt.Sprintf("Invalid selector for ResourceChangeLog: %d", fp.selector))
	}
}

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

func (fp *ResourceChangeLog_FieldTerminalPath) WithIArrayOfValues(values interface{}) ResourceChangeLog_FieldPathArrayOfValues {
	fpaov := &ResourceChangeLog_FieldTerminalPathArrayOfValues{ResourceChangeLog_FieldTerminalPath: *fp}
	switch fp.selector {
	case ResourceChangeLog_FieldPathSelectorName:
		return &ResourceChangeLog_FieldTerminalPathArrayOfValues{ResourceChangeLog_FieldTerminalPath: *fp, values: values.([]*Name)}
	case ResourceChangeLog_FieldPathSelectorScope:
		return &ResourceChangeLog_FieldTerminalPathArrayOfValues{ResourceChangeLog_FieldTerminalPath: *fp, values: values.([]string)}
	case ResourceChangeLog_FieldPathSelectorRequestId:
		return &ResourceChangeLog_FieldTerminalPathArrayOfValues{ResourceChangeLog_FieldTerminalPath: *fp, values: values.([]uint64)}
	case ResourceChangeLog_FieldPathSelectorTimestamp:
		return &ResourceChangeLog_FieldTerminalPathArrayOfValues{ResourceChangeLog_FieldTerminalPath: *fp, values: values.([]*timestamppb.Timestamp)}
	case ResourceChangeLog_FieldPathSelectorAuthentication:
		return &ResourceChangeLog_FieldTerminalPathArrayOfValues{ResourceChangeLog_FieldTerminalPath: *fp, values: values.([]*common.Authentication)}
	case ResourceChangeLog_FieldPathSelectorService:
		return &ResourceChangeLog_FieldTerminalPathArrayOfValues{ResourceChangeLog_FieldTerminalPath: *fp, values: values.([]*common.ServiceData)}
	case ResourceChangeLog_FieldPathSelectorResource:
		return &ResourceChangeLog_FieldTerminalPathArrayOfValues{ResourceChangeLog_FieldTerminalPath: *fp, values: values.([]*ResourceChangeLog_ResourceChange)}
	case ResourceChangeLog_FieldPathSelectorTransaction:
		return &ResourceChangeLog_FieldTerminalPathArrayOfValues{ResourceChangeLog_FieldTerminalPath: *fp, values: values.([]*ResourceChangeLog_TransactionInfo)}
	default:
		panic(fmt.Sprintf("Invalid selector for ResourceChangeLog: %d", fp.selector))
	}
	return fpaov
}

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

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

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

type ResourceChangeLog_FieldSubPath struct {
	selector ResourceChangeLog_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ ResourceChangeLog_FieldPath = (*ResourceChangeLog_FieldSubPath)(nil)

func (fps *ResourceChangeLog_FieldSubPath) Selector() ResourceChangeLog_FieldPathSelector {
	return fps.selector
}
func (fps *ResourceChangeLog_FieldSubPath) AsAuthenticationSubPath() (common.Authentication_FieldPath, bool) {
	res, ok := fps.subPath.(common.Authentication_FieldPath)
	return res, ok
}
func (fps *ResourceChangeLog_FieldSubPath) AsServiceSubPath() (common.ServiceData_FieldPath, bool) {
	res, ok := fps.subPath.(common.ServiceData_FieldPath)
	return res, ok
}
func (fps *ResourceChangeLog_FieldSubPath) AsResourceSubPath() (ResourceChangeLogResourceChange_FieldPath, bool) {
	res, ok := fps.subPath.(ResourceChangeLogResourceChange_FieldPath)
	return res, ok
}
func (fps *ResourceChangeLog_FieldSubPath) AsTransactionSubPath() (ResourceChangeLogTransactionInfo_FieldPath, bool) {
	res, ok := fps.subPath.(ResourceChangeLogTransactionInfo_FieldPath)
	return res, ok
}

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

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

// Get returns all values pointed by selected field from source ResourceChangeLog
func (fps *ResourceChangeLog_FieldSubPath) Get(source *ResourceChangeLog) (values []interface{}) {
	switch fps.selector {
	case ResourceChangeLog_FieldPathSelectorAuthentication:
		values = append(values, fps.subPath.GetRaw(source.GetAuthentication())...)
	case ResourceChangeLog_FieldPathSelectorService:
		values = append(values, fps.subPath.GetRaw(source.GetService())...)
	case ResourceChangeLog_FieldPathSelectorResource:
		values = append(values, fps.subPath.GetRaw(source.GetResource())...)
	case ResourceChangeLog_FieldPathSelectorTransaction:
		values = append(values, fps.subPath.GetRaw(source.GetTransaction())...)
	default:
		panic(fmt.Sprintf("Invalid selector for ResourceChangeLog: %d", fps.selector))
	}
	return
}

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

// GetSingle returns value of selected field from source ResourceChangeLog
func (fps *ResourceChangeLog_FieldSubPath) GetSingle(source *ResourceChangeLog) (interface{}, bool) {
	switch fps.selector {
	case ResourceChangeLog_FieldPathSelectorAuthentication:
		if source.GetAuthentication() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetAuthentication())
	case ResourceChangeLog_FieldPathSelectorService:
		if source.GetService() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetService())
	case ResourceChangeLog_FieldPathSelectorResource:
		if source.GetResource() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetResource())
	case ResourceChangeLog_FieldPathSelectorTransaction:
		if source.GetTransaction() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetTransaction())
	default:
		panic(fmt.Sprintf("Invalid selector for ResourceChangeLog: %d", fps.selector))
	}
}

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

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

func (fps *ResourceChangeLog_FieldSubPath) ClearValue(item *ResourceChangeLog) {
	if item != nil {
		switch fps.selector {
		case ResourceChangeLog_FieldPathSelectorAuthentication:
			fps.subPath.ClearValueRaw(item.Authentication)
		case ResourceChangeLog_FieldPathSelectorService:
			fps.subPath.ClearValueRaw(item.Service)
		case ResourceChangeLog_FieldPathSelectorResource:
			fps.subPath.ClearValueRaw(item.Resource)
		case ResourceChangeLog_FieldPathSelectorTransaction:
			fps.subPath.ClearValueRaw(item.Transaction)
		default:
			panic(fmt.Sprintf("Invalid selector for ResourceChangeLog: %d", fps.selector))
		}
	}
}

func (fps *ResourceChangeLog_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*ResourceChangeLog))
}

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

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

func (fps *ResourceChangeLog_FieldSubPath) WithIValue(value interface{}) ResourceChangeLog_FieldPathValue {
	return &ResourceChangeLog_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *ResourceChangeLog_FieldSubPath) WithIArrayOfValues(values interface{}) ResourceChangeLog_FieldPathArrayOfValues {
	return &ResourceChangeLog_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *ResourceChangeLog_FieldSubPath) WithIArrayItemValue(value interface{}) ResourceChangeLog_FieldPathArrayItemValue {
	return &ResourceChangeLog_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

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

func ParseResourceChangeLog_FieldPathValue(pathStr, valueStr string) (ResourceChangeLog_FieldPathValue, error) {
	fp, err := ParseResourceChangeLog_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 ResourceChangeLog field path value from %s: %v", valueStr, err)
	}
	return fpv.(ResourceChangeLog_FieldPathValue), nil
}

func MustParseResourceChangeLog_FieldPathValue(pathStr, valueStr string) ResourceChangeLog_FieldPathValue {
	fpv, err := ParseResourceChangeLog_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type ResourceChangeLog_FieldTerminalPathValue struct {
	ResourceChangeLog_FieldTerminalPath
	value interface{}
}

var _ ResourceChangeLog_FieldPathValue = (*ResourceChangeLog_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'ResourceChangeLog' as interface{}
func (fpv *ResourceChangeLog_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *ResourceChangeLog_FieldTerminalPathValue) AsNameValue() (*Name, bool) {
	res, ok := fpv.value.(*Name)
	return res, ok
}
func (fpv *ResourceChangeLog_FieldTerminalPathValue) AsScopeValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *ResourceChangeLog_FieldTerminalPathValue) AsRequestIdValue() (uint64, bool) {
	res, ok := fpv.value.(uint64)
	return res, ok
}
func (fpv *ResourceChangeLog_FieldTerminalPathValue) AsTimestampValue() (*timestamppb.Timestamp, bool) {
	res, ok := fpv.value.(*timestamppb.Timestamp)
	return res, ok
}
func (fpv *ResourceChangeLog_FieldTerminalPathValue) AsAuthenticationValue() (*common.Authentication, bool) {
	res, ok := fpv.value.(*common.Authentication)
	return res, ok
}
func (fpv *ResourceChangeLog_FieldTerminalPathValue) AsServiceValue() (*common.ServiceData, bool) {
	res, ok := fpv.value.(*common.ServiceData)
	return res, ok
}
func (fpv *ResourceChangeLog_FieldTerminalPathValue) AsResourceValue() (*ResourceChangeLog_ResourceChange, bool) {
	res, ok := fpv.value.(*ResourceChangeLog_ResourceChange)
	return res, ok
}
func (fpv *ResourceChangeLog_FieldTerminalPathValue) AsTransactionValue() (*ResourceChangeLog_TransactionInfo, bool) {
	res, ok := fpv.value.(*ResourceChangeLog_TransactionInfo)
	return res, ok
}

// SetTo stores value for selected field for object ResourceChangeLog
func (fpv *ResourceChangeLog_FieldTerminalPathValue) SetTo(target **ResourceChangeLog) {
	if *target == nil {
		*target = new(ResourceChangeLog)
	}
	switch fpv.selector {
	case ResourceChangeLog_FieldPathSelectorName:
		(*target).Name = fpv.value.(*Name)
	case ResourceChangeLog_FieldPathSelectorScope:
		(*target).Scope = fpv.value.(string)
	case ResourceChangeLog_FieldPathSelectorRequestId:
		(*target).RequestId = fpv.value.(uint64)
	case ResourceChangeLog_FieldPathSelectorTimestamp:
		(*target).Timestamp = fpv.value.(*timestamppb.Timestamp)
	case ResourceChangeLog_FieldPathSelectorAuthentication:
		(*target).Authentication = fpv.value.(*common.Authentication)
	case ResourceChangeLog_FieldPathSelectorService:
		(*target).Service = fpv.value.(*common.ServiceData)
	case ResourceChangeLog_FieldPathSelectorResource:
		(*target).Resource = fpv.value.(*ResourceChangeLog_ResourceChange)
	case ResourceChangeLog_FieldPathSelectorTransaction:
		(*target).Transaction = fpv.value.(*ResourceChangeLog_TransactionInfo)
	default:
		panic(fmt.Sprintf("Invalid selector for ResourceChangeLog: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'ResourceChangeLog_FieldTerminalPathValue' with the value under path in 'ResourceChangeLog'.
func (fpv *ResourceChangeLog_FieldTerminalPathValue) CompareWith(source *ResourceChangeLog) (int, bool) {
	switch fpv.selector {
	case ResourceChangeLog_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 ResourceChangeLog_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 ResourceChangeLog_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 ResourceChangeLog_FieldPathSelectorTimestamp:
		leftValue := fpv.value.(*timestamppb.Timestamp)
		rightValue := source.GetTimestamp()
		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 ResourceChangeLog_FieldPathSelectorAuthentication:
		return 0, false
	case ResourceChangeLog_FieldPathSelectorService:
		return 0, false
	case ResourceChangeLog_FieldPathSelectorResource:
		return 0, false
	case ResourceChangeLog_FieldPathSelectorTransaction:
		return 0, false
	default:
		panic(fmt.Sprintf("Invalid selector for ResourceChangeLog: %d", fpv.selector))
	}
}

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

type ResourceChangeLog_FieldSubPathValue struct {
	ResourceChangeLog_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ ResourceChangeLog_FieldPathValue = (*ResourceChangeLog_FieldSubPathValue)(nil)

func (fpvs *ResourceChangeLog_FieldSubPathValue) AsAuthenticationPathValue() (common.Authentication_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(common.Authentication_FieldPathValue)
	return res, ok
}
func (fpvs *ResourceChangeLog_FieldSubPathValue) AsServicePathValue() (common.ServiceData_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(common.ServiceData_FieldPathValue)
	return res, ok
}
func (fpvs *ResourceChangeLog_FieldSubPathValue) AsResourcePathValue() (ResourceChangeLogResourceChange_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(ResourceChangeLogResourceChange_FieldPathValue)
	return res, ok
}
func (fpvs *ResourceChangeLog_FieldSubPathValue) AsTransactionPathValue() (ResourceChangeLogTransactionInfo_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(ResourceChangeLogTransactionInfo_FieldPathValue)
	return res, ok
}

func (fpvs *ResourceChangeLog_FieldSubPathValue) SetTo(target **ResourceChangeLog) {
	if *target == nil {
		*target = new(ResourceChangeLog)
	}
	switch fpvs.Selector() {
	case ResourceChangeLog_FieldPathSelectorAuthentication:
		fpvs.subPathValue.(common.Authentication_FieldPathValue).SetTo(&(*target).Authentication)
	case ResourceChangeLog_FieldPathSelectorService:
		fpvs.subPathValue.(common.ServiceData_FieldPathValue).SetTo(&(*target).Service)
	case ResourceChangeLog_FieldPathSelectorResource:
		fpvs.subPathValue.(ResourceChangeLogResourceChange_FieldPathValue).SetTo(&(*target).Resource)
	case ResourceChangeLog_FieldPathSelectorTransaction:
		fpvs.subPathValue.(ResourceChangeLogTransactionInfo_FieldPathValue).SetTo(&(*target).Transaction)
	default:
		panic(fmt.Sprintf("Invalid selector for ResourceChangeLog: %d", fpvs.Selector()))
	}
}

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

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

func (fpvs *ResourceChangeLog_FieldSubPathValue) CompareWith(source *ResourceChangeLog) (int, bool) {
	switch fpvs.Selector() {
	case ResourceChangeLog_FieldPathSelectorAuthentication:
		return fpvs.subPathValue.(common.Authentication_FieldPathValue).CompareWith(source.GetAuthentication())
	case ResourceChangeLog_FieldPathSelectorService:
		return fpvs.subPathValue.(common.ServiceData_FieldPathValue).CompareWith(source.GetService())
	case ResourceChangeLog_FieldPathSelectorResource:
		return fpvs.subPathValue.(ResourceChangeLogResourceChange_FieldPathValue).CompareWith(source.GetResource())
	case ResourceChangeLog_FieldPathSelectorTransaction:
		return fpvs.subPathValue.(ResourceChangeLogTransactionInfo_FieldPathValue).CompareWith(source.GetTransaction())
	default:
		panic(fmt.Sprintf("Invalid selector for ResourceChangeLog: %d", fpvs.Selector()))
	}
}

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

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

// ParseResourceChangeLog_FieldPathArrayItemValue parses string and JSON-encoded value to its Value
func ParseResourceChangeLog_FieldPathArrayItemValue(pathStr, valueStr string) (ResourceChangeLog_FieldPathArrayItemValue, error) {
	fp, err := ParseResourceChangeLog_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 ResourceChangeLog field path array item value from %s: %v", valueStr, err)
	}
	return fpaiv.(ResourceChangeLog_FieldPathArrayItemValue), nil
}

func MustParseResourceChangeLog_FieldPathArrayItemValue(pathStr, valueStr string) ResourceChangeLog_FieldPathArrayItemValue {
	fpaiv, err := ParseResourceChangeLog_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type ResourceChangeLog_FieldTerminalPathArrayItemValue struct {
	ResourceChangeLog_FieldTerminalPath
	value interface{}
}

var _ ResourceChangeLog_FieldPathArrayItemValue = (*ResourceChangeLog_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *ResourceChangeLog_FieldTerminalPathArrayItemValue) GetSingle(source *ResourceChangeLog) (interface{}, bool) {
	return nil, false
}

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

// Contains returns a boolean indicating if value that is being held is present in given 'ResourceChangeLog'
func (fpaiv *ResourceChangeLog_FieldTerminalPathArrayItemValue) ContainsValue(source *ResourceChangeLog) bool {
	slice := fpaiv.ResourceChangeLog_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 ResourceChangeLog_FieldSubPathArrayItemValue struct {
	ResourceChangeLog_FieldPath
	subPathItemValue gotenobject.FieldPathArrayItemValue
}

// GetRawValue returns stored array item value
func (fpaivs *ResourceChangeLog_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *ResourceChangeLog_FieldSubPathArrayItemValue) AsAuthenticationPathItemValue() (common.Authentication_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(common.Authentication_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *ResourceChangeLog_FieldSubPathArrayItemValue) AsServicePathItemValue() (common.ServiceData_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(common.ServiceData_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *ResourceChangeLog_FieldSubPathArrayItemValue) AsResourcePathItemValue() (ResourceChangeLogResourceChange_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(ResourceChangeLogResourceChange_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *ResourceChangeLog_FieldSubPathArrayItemValue) AsTransactionPathItemValue() (ResourceChangeLogTransactionInfo_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(ResourceChangeLogTransactionInfo_FieldPathArrayItemValue)
	return res, ok
}

// Contains returns a boolean indicating if value that is being held is present in given 'ResourceChangeLog'
func (fpaivs *ResourceChangeLog_FieldSubPathArrayItemValue) ContainsValue(source *ResourceChangeLog) bool {
	switch fpaivs.Selector() {
	case ResourceChangeLog_FieldPathSelectorAuthentication:
		return fpaivs.subPathItemValue.(common.Authentication_FieldPathArrayItemValue).ContainsValue(source.GetAuthentication())
	case ResourceChangeLog_FieldPathSelectorService:
		return fpaivs.subPathItemValue.(common.ServiceData_FieldPathArrayItemValue).ContainsValue(source.GetService())
	case ResourceChangeLog_FieldPathSelectorResource:
		return fpaivs.subPathItemValue.(ResourceChangeLogResourceChange_FieldPathArrayItemValue).ContainsValue(source.GetResource())
	case ResourceChangeLog_FieldPathSelectorTransaction:
		return fpaivs.subPathItemValue.(ResourceChangeLogTransactionInfo_FieldPathArrayItemValue).ContainsValue(source.GetTransaction())
	default:
		panic(fmt.Sprintf("Invalid selector for ResourceChangeLog: %d", fpaivs.Selector()))
	}
}

// ResourceChangeLog_FieldPathArrayOfValues allows storing slice of values for ResourceChangeLog fields according to their type
type ResourceChangeLog_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	ResourceChangeLog_FieldPath
}

func ParseResourceChangeLog_FieldPathArrayOfValues(pathStr, valuesStr string) (ResourceChangeLog_FieldPathArrayOfValues, error) {
	fp, err := ParseResourceChangeLog_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 ResourceChangeLog field path array of values from %s: %v", valuesStr, err)
	}
	return fpaov.(ResourceChangeLog_FieldPathArrayOfValues), nil
}

func MustParseResourceChangeLog_FieldPathArrayOfValues(pathStr, valuesStr string) ResourceChangeLog_FieldPathArrayOfValues {
	fpaov, err := ParseResourceChangeLog_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type ResourceChangeLog_FieldTerminalPathArrayOfValues struct {
	ResourceChangeLog_FieldTerminalPath
	values interface{}
}

var _ ResourceChangeLog_FieldPathArrayOfValues = (*ResourceChangeLog_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *ResourceChangeLog_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case ResourceChangeLog_FieldPathSelectorName:
		for _, v := range fpaov.values.([]*Name) {
			values = append(values, v)
		}
	case ResourceChangeLog_FieldPathSelectorScope:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case ResourceChangeLog_FieldPathSelectorRequestId:
		for _, v := range fpaov.values.([]uint64) {
			values = append(values, v)
		}
	case ResourceChangeLog_FieldPathSelectorTimestamp:
		for _, v := range fpaov.values.([]*timestamppb.Timestamp) {
			values = append(values, v)
		}
	case ResourceChangeLog_FieldPathSelectorAuthentication:
		for _, v := range fpaov.values.([]*common.Authentication) {
			values = append(values, v)
		}
	case ResourceChangeLog_FieldPathSelectorService:
		for _, v := range fpaov.values.([]*common.ServiceData) {
			values = append(values, v)
		}
	case ResourceChangeLog_FieldPathSelectorResource:
		for _, v := range fpaov.values.([]*ResourceChangeLog_ResourceChange) {
			values = append(values, v)
		}
	case ResourceChangeLog_FieldPathSelectorTransaction:
		for _, v := range fpaov.values.([]*ResourceChangeLog_TransactionInfo) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *ResourceChangeLog_FieldTerminalPathArrayOfValues) AsNameArrayOfValues() ([]*Name, bool) {
	res, ok := fpaov.values.([]*Name)
	return res, ok
}
func (fpaov *ResourceChangeLog_FieldTerminalPathArrayOfValues) AsScopeArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *ResourceChangeLog_FieldTerminalPathArrayOfValues) AsRequestIdArrayOfValues() ([]uint64, bool) {
	res, ok := fpaov.values.([]uint64)
	return res, ok
}
func (fpaov *ResourceChangeLog_FieldTerminalPathArrayOfValues) AsTimestampArrayOfValues() ([]*timestamppb.Timestamp, bool) {
	res, ok := fpaov.values.([]*timestamppb.Timestamp)
	return res, ok
}
func (fpaov *ResourceChangeLog_FieldTerminalPathArrayOfValues) AsAuthenticationArrayOfValues() ([]*common.Authentication, bool) {
	res, ok := fpaov.values.([]*common.Authentication)
	return res, ok
}
func (fpaov *ResourceChangeLog_FieldTerminalPathArrayOfValues) AsServiceArrayOfValues() ([]*common.ServiceData, bool) {
	res, ok := fpaov.values.([]*common.ServiceData)
	return res, ok
}
func (fpaov *ResourceChangeLog_FieldTerminalPathArrayOfValues) AsResourceArrayOfValues() ([]*ResourceChangeLog_ResourceChange, bool) {
	res, ok := fpaov.values.([]*ResourceChangeLog_ResourceChange)
	return res, ok
}
func (fpaov *ResourceChangeLog_FieldTerminalPathArrayOfValues) AsTransactionArrayOfValues() ([]*ResourceChangeLog_TransactionInfo, bool) {
	res, ok := fpaov.values.([]*ResourceChangeLog_TransactionInfo)
	return res, ok
}

type ResourceChangeLog_FieldSubPathArrayOfValues struct {
	ResourceChangeLog_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ ResourceChangeLog_FieldPathArrayOfValues = (*ResourceChangeLog_FieldSubPathArrayOfValues)(nil)

func (fpsaov *ResourceChangeLog_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *ResourceChangeLog_FieldSubPathArrayOfValues) AsAuthenticationPathArrayOfValues() (common.Authentication_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(common.Authentication_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *ResourceChangeLog_FieldSubPathArrayOfValues) AsServicePathArrayOfValues() (common.ServiceData_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(common.ServiceData_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *ResourceChangeLog_FieldSubPathArrayOfValues) AsResourcePathArrayOfValues() (ResourceChangeLogResourceChange_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(ResourceChangeLogResourceChange_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *ResourceChangeLog_FieldSubPathArrayOfValues) AsTransactionPathArrayOfValues() (ResourceChangeLogTransactionInfo_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(ResourceChangeLogTransactionInfo_FieldPathArrayOfValues)
	return res, ok
}

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

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

type ResourceChangeLogResourceChange_FieldPathSelector int32

const (
	ResourceChangeLogResourceChange_FieldPathSelectorName          ResourceChangeLogResourceChange_FieldPathSelector = 0
	ResourceChangeLogResourceChange_FieldPathSelectorType          ResourceChangeLogResourceChange_FieldPathSelector = 1
	ResourceChangeLogResourceChange_FieldPathSelectorAction        ResourceChangeLogResourceChange_FieldPathSelector = 2
	ResourceChangeLogResourceChange_FieldPathSelectorUpdatedFields ResourceChangeLogResourceChange_FieldPathSelector = 3
	ResourceChangeLogResourceChange_FieldPathSelectorPrevious      ResourceChangeLogResourceChange_FieldPathSelector = 4
	ResourceChangeLogResourceChange_FieldPathSelectorCurrent       ResourceChangeLogResourceChange_FieldPathSelector = 5
	ResourceChangeLogResourceChange_FieldPathSelectorLabels        ResourceChangeLogResourceChange_FieldPathSelector = 6
	ResourceChangeLogResourceChange_FieldPathSelectorPre           ResourceChangeLogResourceChange_FieldPathSelector = 7
	ResourceChangeLogResourceChange_FieldPathSelectorPost          ResourceChangeLogResourceChange_FieldPathSelector = 8
)

func (s ResourceChangeLogResourceChange_FieldPathSelector) String() string {
	switch s {
	case ResourceChangeLogResourceChange_FieldPathSelectorName:
		return "name"
	case ResourceChangeLogResourceChange_FieldPathSelectorType:
		return "type"
	case ResourceChangeLogResourceChange_FieldPathSelectorAction:
		return "action"
	case ResourceChangeLogResourceChange_FieldPathSelectorUpdatedFields:
		return "updated_fields"
	case ResourceChangeLogResourceChange_FieldPathSelectorPrevious:
		return "previous"
	case ResourceChangeLogResourceChange_FieldPathSelectorCurrent:
		return "current"
	case ResourceChangeLogResourceChange_FieldPathSelectorLabels:
		return "labels"
	case ResourceChangeLogResourceChange_FieldPathSelectorPre:
		return "pre"
	case ResourceChangeLogResourceChange_FieldPathSelectorPost:
		return "post"
	default:
		panic(fmt.Sprintf("Invalid selector for ResourceChangeLog_ResourceChange: %d", s))
	}
}

func BuildResourceChangeLogResourceChange_FieldPath(fp gotenobject.RawFieldPath) (ResourceChangeLogResourceChange_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object ResourceChangeLog_ResourceChange")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "name":
			return &ResourceChangeLogResourceChange_FieldTerminalPath{selector: ResourceChangeLogResourceChange_FieldPathSelectorName}, nil
		case "type":
			return &ResourceChangeLogResourceChange_FieldTerminalPath{selector: ResourceChangeLogResourceChange_FieldPathSelectorType}, nil
		case "action":
			return &ResourceChangeLogResourceChange_FieldTerminalPath{selector: ResourceChangeLogResourceChange_FieldPathSelectorAction}, nil
		case "updated_fields", "updatedFields", "updated-fields":
			return &ResourceChangeLogResourceChange_FieldTerminalPath{selector: ResourceChangeLogResourceChange_FieldPathSelectorUpdatedFields}, nil
		case "previous":
			return &ResourceChangeLogResourceChange_FieldTerminalPath{selector: ResourceChangeLogResourceChange_FieldPathSelectorPrevious}, nil
		case "current":
			return &ResourceChangeLogResourceChange_FieldTerminalPath{selector: ResourceChangeLogResourceChange_FieldPathSelectorCurrent}, nil
		case "labels":
			return &ResourceChangeLogResourceChange_FieldTerminalPath{selector: ResourceChangeLogResourceChange_FieldPathSelectorLabels}, nil
		case "pre":
			return &ResourceChangeLogResourceChange_FieldTerminalPath{selector: ResourceChangeLogResourceChange_FieldPathSelectorPre}, nil
		case "post":
			return &ResourceChangeLogResourceChange_FieldTerminalPath{selector: ResourceChangeLogResourceChange_FieldPathSelectorPost}, nil
		}
	} else {
		switch fp[0] {
		case "pre":
			if subpath, err := common.BuildObjectState_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &ResourceChangeLogResourceChange_FieldSubPath{selector: ResourceChangeLogResourceChange_FieldPathSelectorPre, subPath: subpath}, nil
			}
		case "post":
			if subpath, err := common.BuildObjectState_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &ResourceChangeLogResourceChange_FieldSubPath{selector: ResourceChangeLogResourceChange_FieldPathSelectorPost, subPath: subpath}, nil
			}
		case "labels":
			if len(fp) > 2 {
				return nil, status.Errorf(codes.InvalidArgument, "sub path for maps ('%s') are not supported (object ResourceChangeLog_ResourceChange)", fp)
			}
			return &ResourceChangeLogResourceChange_FieldPathMap{selector: ResourceChangeLogResourceChange_FieldPathSelectorLabels, key: fp[1]}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object ResourceChangeLog_ResourceChange", fp)
}

func ParseResourceChangeLogResourceChange_FieldPath(rawField string) (ResourceChangeLogResourceChange_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildResourceChangeLogResourceChange_FieldPath(fp)
}

func MustParseResourceChangeLogResourceChange_FieldPath(rawField string) ResourceChangeLogResourceChange_FieldPath {
	fp, err := ParseResourceChangeLogResourceChange_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type ResourceChangeLogResourceChange_FieldTerminalPath struct {
	selector ResourceChangeLogResourceChange_FieldPathSelector
}

var _ ResourceChangeLogResourceChange_FieldPath = (*ResourceChangeLogResourceChange_FieldTerminalPath)(nil)

func (fp *ResourceChangeLogResourceChange_FieldTerminalPath) Selector() ResourceChangeLogResourceChange_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source ResourceChangeLog_ResourceChange
func (fp *ResourceChangeLogResourceChange_FieldTerminalPath) Get(source *ResourceChangeLog_ResourceChange) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case ResourceChangeLogResourceChange_FieldPathSelectorName:
			values = append(values, source.Name)
		case ResourceChangeLogResourceChange_FieldPathSelectorType:
			values = append(values, source.Type)
		case ResourceChangeLogResourceChange_FieldPathSelectorAction:
			values = append(values, source.Action)
		case ResourceChangeLogResourceChange_FieldPathSelectorUpdatedFields:
			if source.UpdatedFields != nil {
				values = append(values, source.UpdatedFields)
			}
		case ResourceChangeLogResourceChange_FieldPathSelectorPrevious:
			if source.Previous != nil {
				values = append(values, source.Previous)
			}
		case ResourceChangeLogResourceChange_FieldPathSelectorCurrent:
			if source.Current != nil {
				values = append(values, source.Current)
			}
		case ResourceChangeLogResourceChange_FieldPathSelectorLabels:
			values = append(values, source.Labels)
		case ResourceChangeLogResourceChange_FieldPathSelectorPre:
			if source.Pre != nil {
				values = append(values, source.Pre)
			}
		case ResourceChangeLogResourceChange_FieldPathSelectorPost:
			if source.Post != nil {
				values = append(values, source.Post)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for ResourceChangeLog_ResourceChange: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source ResourceChangeLog_ResourceChange
func (fp *ResourceChangeLogResourceChange_FieldTerminalPath) GetSingle(source *ResourceChangeLog_ResourceChange) (interface{}, bool) {
	switch fp.selector {
	case ResourceChangeLogResourceChange_FieldPathSelectorName:
		return source.GetName(), source != nil
	case ResourceChangeLogResourceChange_FieldPathSelectorType:
		return source.GetType(), source != nil
	case ResourceChangeLogResourceChange_FieldPathSelectorAction:
		return source.GetAction(), source != nil
	case ResourceChangeLogResourceChange_FieldPathSelectorUpdatedFields:
		res := source.GetUpdatedFields()
		return res, res != nil
	case ResourceChangeLogResourceChange_FieldPathSelectorPrevious:
		res := source.GetPrevious()
		return res, res != nil
	case ResourceChangeLogResourceChange_FieldPathSelectorCurrent:
		res := source.GetCurrent()
		return res, res != nil
	case ResourceChangeLogResourceChange_FieldPathSelectorLabels:
		res := source.GetLabels()
		return res, res != nil
	case ResourceChangeLogResourceChange_FieldPathSelectorPre:
		res := source.GetPre()
		return res, res != nil
	case ResourceChangeLogResourceChange_FieldPathSelectorPost:
		res := source.GetPost()
		return res, res != nil
	default:
		panic(fmt.Sprintf("Invalid selector for ResourceChangeLog_ResourceChange: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *ResourceChangeLogResourceChange_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case ResourceChangeLogResourceChange_FieldPathSelectorName:
		return ""
	case ResourceChangeLogResourceChange_FieldPathSelectorType:
		return ""
	case ResourceChangeLogResourceChange_FieldPathSelectorAction:
		return ResourceChangeLog_ResourceChange_UNDEFINED
	case ResourceChangeLogResourceChange_FieldPathSelectorUpdatedFields:
		return (*fieldmaskpb.FieldMask)(nil)
	case ResourceChangeLogResourceChange_FieldPathSelectorPrevious:
		return (*anypb.Any)(nil)
	case ResourceChangeLogResourceChange_FieldPathSelectorCurrent:
		return (*anypb.Any)(nil)
	case ResourceChangeLogResourceChange_FieldPathSelectorLabels:
		return (map[string]string)(nil)
	case ResourceChangeLogResourceChange_FieldPathSelectorPre:
		return (*common.ObjectState)(nil)
	case ResourceChangeLogResourceChange_FieldPathSelectorPost:
		return (*common.ObjectState)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for ResourceChangeLog_ResourceChange: %d", fp.selector))
	}
}

func (fp *ResourceChangeLogResourceChange_FieldTerminalPath) ClearValue(item *ResourceChangeLog_ResourceChange) {
	if item != nil {
		switch fp.selector {
		case ResourceChangeLogResourceChange_FieldPathSelectorName:
			item.Name = ""
		case ResourceChangeLogResourceChange_FieldPathSelectorType:
			item.Type = ""
		case ResourceChangeLogResourceChange_FieldPathSelectorAction:
			item.Action = ResourceChangeLog_ResourceChange_UNDEFINED
		case ResourceChangeLogResourceChange_FieldPathSelectorUpdatedFields:
			item.UpdatedFields = nil
		case ResourceChangeLogResourceChange_FieldPathSelectorPrevious:
			item.Previous = nil
		case ResourceChangeLogResourceChange_FieldPathSelectorCurrent:
			item.Current = nil
		case ResourceChangeLogResourceChange_FieldPathSelectorLabels:
			item.Labels = nil
		case ResourceChangeLogResourceChange_FieldPathSelectorPre:
			item.Pre = nil
		case ResourceChangeLogResourceChange_FieldPathSelectorPost:
			item.Post = nil
		default:
			panic(fmt.Sprintf("Invalid selector for ResourceChangeLog_ResourceChange: %d", fp.selector))
		}
	}
}

func (fp *ResourceChangeLogResourceChange_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*ResourceChangeLog_ResourceChange))
}

// IsLeaf - whether field path is holds simple value
func (fp *ResourceChangeLogResourceChange_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == ResourceChangeLogResourceChange_FieldPathSelectorName ||
		fp.selector == ResourceChangeLogResourceChange_FieldPathSelectorType ||
		fp.selector == ResourceChangeLogResourceChange_FieldPathSelectorAction ||
		fp.selector == ResourceChangeLogResourceChange_FieldPathSelectorUpdatedFields ||
		fp.selector == ResourceChangeLogResourceChange_FieldPathSelectorPrevious ||
		fp.selector == ResourceChangeLogResourceChange_FieldPathSelectorCurrent ||
		fp.selector == ResourceChangeLogResourceChange_FieldPathSelectorLabels
}

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

func (fp *ResourceChangeLogResourceChange_FieldTerminalPath) WithIValue(value interface{}) ResourceChangeLogResourceChange_FieldPathValue {
	switch fp.selector {
	case ResourceChangeLogResourceChange_FieldPathSelectorName:
		return &ResourceChangeLogResourceChange_FieldTerminalPathValue{ResourceChangeLogResourceChange_FieldTerminalPath: *fp, value: value.(string)}
	case ResourceChangeLogResourceChange_FieldPathSelectorType:
		return &ResourceChangeLogResourceChange_FieldTerminalPathValue{ResourceChangeLogResourceChange_FieldTerminalPath: *fp, value: value.(string)}
	case ResourceChangeLogResourceChange_FieldPathSelectorAction:
		return &ResourceChangeLogResourceChange_FieldTerminalPathValue{ResourceChangeLogResourceChange_FieldTerminalPath: *fp, value: value.(ResourceChangeLog_ResourceChange_Action)}
	case ResourceChangeLogResourceChange_FieldPathSelectorUpdatedFields:
		return &ResourceChangeLogResourceChange_FieldTerminalPathValue{ResourceChangeLogResourceChange_FieldTerminalPath: *fp, value: value.(*fieldmaskpb.FieldMask)}
	case ResourceChangeLogResourceChange_FieldPathSelectorPrevious:
		return &ResourceChangeLogResourceChange_FieldTerminalPathValue{ResourceChangeLogResourceChange_FieldTerminalPath: *fp, value: value.(*anypb.Any)}
	case ResourceChangeLogResourceChange_FieldPathSelectorCurrent:
		return &ResourceChangeLogResourceChange_FieldTerminalPathValue{ResourceChangeLogResourceChange_FieldTerminalPath: *fp, value: value.(*anypb.Any)}
	case ResourceChangeLogResourceChange_FieldPathSelectorLabels:
		return &ResourceChangeLogResourceChange_FieldTerminalPathValue{ResourceChangeLogResourceChange_FieldTerminalPath: *fp, value: value.(map[string]string)}
	case ResourceChangeLogResourceChange_FieldPathSelectorPre:
		return &ResourceChangeLogResourceChange_FieldTerminalPathValue{ResourceChangeLogResourceChange_FieldTerminalPath: *fp, value: value.(*common.ObjectState)}
	case ResourceChangeLogResourceChange_FieldPathSelectorPost:
		return &ResourceChangeLogResourceChange_FieldTerminalPathValue{ResourceChangeLogResourceChange_FieldTerminalPath: *fp, value: value.(*common.ObjectState)}
	default:
		panic(fmt.Sprintf("Invalid selector for ResourceChangeLog_ResourceChange: %d", fp.selector))
	}
}

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

func (fp *ResourceChangeLogResourceChange_FieldTerminalPath) WithIArrayOfValues(values interface{}) ResourceChangeLogResourceChange_FieldPathArrayOfValues {
	fpaov := &ResourceChangeLogResourceChange_FieldTerminalPathArrayOfValues{ResourceChangeLogResourceChange_FieldTerminalPath: *fp}
	switch fp.selector {
	case ResourceChangeLogResourceChange_FieldPathSelectorName:
		return &ResourceChangeLogResourceChange_FieldTerminalPathArrayOfValues{ResourceChangeLogResourceChange_FieldTerminalPath: *fp, values: values.([]string)}
	case ResourceChangeLogResourceChange_FieldPathSelectorType:
		return &ResourceChangeLogResourceChange_FieldTerminalPathArrayOfValues{ResourceChangeLogResourceChange_FieldTerminalPath: *fp, values: values.([]string)}
	case ResourceChangeLogResourceChange_FieldPathSelectorAction:
		return &ResourceChangeLogResourceChange_FieldTerminalPathArrayOfValues{ResourceChangeLogResourceChange_FieldTerminalPath: *fp, values: values.([]ResourceChangeLog_ResourceChange_Action)}
	case ResourceChangeLogResourceChange_FieldPathSelectorUpdatedFields:
		return &ResourceChangeLogResourceChange_FieldTerminalPathArrayOfValues{ResourceChangeLogResourceChange_FieldTerminalPath: *fp, values: values.([]*fieldmaskpb.FieldMask)}
	case ResourceChangeLogResourceChange_FieldPathSelectorPrevious:
		return &ResourceChangeLogResourceChange_FieldTerminalPathArrayOfValues{ResourceChangeLogResourceChange_FieldTerminalPath: *fp, values: values.([]*anypb.Any)}
	case ResourceChangeLogResourceChange_FieldPathSelectorCurrent:
		return &ResourceChangeLogResourceChange_FieldTerminalPathArrayOfValues{ResourceChangeLogResourceChange_FieldTerminalPath: *fp, values: values.([]*anypb.Any)}
	case ResourceChangeLogResourceChange_FieldPathSelectorLabels:
		return &ResourceChangeLogResourceChange_FieldTerminalPathArrayOfValues{ResourceChangeLogResourceChange_FieldTerminalPath: *fp, values: values.([]map[string]string)}
	case ResourceChangeLogResourceChange_FieldPathSelectorPre:
		return &ResourceChangeLogResourceChange_FieldTerminalPathArrayOfValues{ResourceChangeLogResourceChange_FieldTerminalPath: *fp, values: values.([]*common.ObjectState)}
	case ResourceChangeLogResourceChange_FieldPathSelectorPost:
		return &ResourceChangeLogResourceChange_FieldTerminalPathArrayOfValues{ResourceChangeLogResourceChange_FieldTerminalPath: *fp, values: values.([]*common.ObjectState)}
	default:
		panic(fmt.Sprintf("Invalid selector for ResourceChangeLog_ResourceChange: %d", fp.selector))
	}
	return fpaov
}

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

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

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

// FieldPath for map type with additional Key information
type ResourceChangeLogResourceChange_FieldPathMap struct {
	key      string
	selector ResourceChangeLogResourceChange_FieldPathSelector
}

var _ ResourceChangeLogResourceChange_FieldPath = (*ResourceChangeLogResourceChange_FieldPathMap)(nil)

func (fpm *ResourceChangeLogResourceChange_FieldPathMap) Selector() ResourceChangeLogResourceChange_FieldPathSelector {
	return fpm.selector
}

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

// String returns path representation in proto convention
func (fpm *ResourceChangeLogResourceChange_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 *ResourceChangeLogResourceChange_FieldPathMap) JSONString() string {
	return strcase.ToLowerCamel(fpm.selector.String()) + "." + fpm.key
}

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

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

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

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

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

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

func (fpm *ResourceChangeLogResourceChange_FieldPathMap) ClearValueRaw(item proto.Message) {
	fpm.ClearValue(item.(*ResourceChangeLog_ResourceChange))
}

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

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

func (fpm *ResourceChangeLogResourceChange_FieldPathMap) WithIValue(value interface{}) ResourceChangeLogResourceChange_FieldPathValue {
	switch fpm.selector {
	case ResourceChangeLogResourceChange_FieldPathSelectorLabels:
		return &ResourceChangeLogResourceChange_FieldPathMapValue{ResourceChangeLogResourceChange_FieldPathMap: *fpm, value: value.(string)}
	default:
		panic(fmt.Sprintf("Invalid selector for ResourceChangeLog_ResourceChange: %d", fpm.selector))
	}
}

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

func (fpm *ResourceChangeLogResourceChange_FieldPathMap) WithIArrayOfValues(values interface{}) ResourceChangeLogResourceChange_FieldPathArrayOfValues {
	switch fpm.selector {
	case ResourceChangeLogResourceChange_FieldPathSelectorLabels:
		return &ResourceChangeLogResourceChange_FieldPathMapArrayOfValues{ResourceChangeLogResourceChange_FieldPathMap: *fpm, values: values.([]string)}
	default:
		panic(fmt.Sprintf("Invalid selector for ResourceChangeLog_ResourceChange: %d", fpm.selector))
	}
}

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

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

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

type ResourceChangeLogResourceChange_FieldSubPath struct {
	selector ResourceChangeLogResourceChange_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ ResourceChangeLogResourceChange_FieldPath = (*ResourceChangeLogResourceChange_FieldSubPath)(nil)

func (fps *ResourceChangeLogResourceChange_FieldSubPath) Selector() ResourceChangeLogResourceChange_FieldPathSelector {
	return fps.selector
}
func (fps *ResourceChangeLogResourceChange_FieldSubPath) AsPreSubPath() (common.ObjectState_FieldPath, bool) {
	res, ok := fps.subPath.(common.ObjectState_FieldPath)
	return res, ok
}
func (fps *ResourceChangeLogResourceChange_FieldSubPath) AsPostSubPath() (common.ObjectState_FieldPath, bool) {
	res, ok := fps.subPath.(common.ObjectState_FieldPath)
	return res, ok
}

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

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

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

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

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

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

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

func (fps *ResourceChangeLogResourceChange_FieldSubPath) ClearValue(item *ResourceChangeLog_ResourceChange) {
	if item != nil {
		switch fps.selector {
		case ResourceChangeLogResourceChange_FieldPathSelectorPre:
			fps.subPath.ClearValueRaw(item.Pre)
		case ResourceChangeLogResourceChange_FieldPathSelectorPost:
			fps.subPath.ClearValueRaw(item.Post)
		default:
			panic(fmt.Sprintf("Invalid selector for ResourceChangeLog_ResourceChange: %d", fps.selector))
		}
	}
}

func (fps *ResourceChangeLogResourceChange_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*ResourceChangeLog_ResourceChange))
}

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

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

func (fps *ResourceChangeLogResourceChange_FieldSubPath) WithIValue(value interface{}) ResourceChangeLogResourceChange_FieldPathValue {
	return &ResourceChangeLogResourceChange_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *ResourceChangeLogResourceChange_FieldSubPath) WithIArrayOfValues(values interface{}) ResourceChangeLogResourceChange_FieldPathArrayOfValues {
	return &ResourceChangeLogResourceChange_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *ResourceChangeLogResourceChange_FieldSubPath) WithIArrayItemValue(value interface{}) ResourceChangeLogResourceChange_FieldPathArrayItemValue {
	return &ResourceChangeLogResourceChange_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

// ResourceChangeLogResourceChange_FieldPathValue allows storing values for ResourceChange fields according to their type
type ResourceChangeLogResourceChange_FieldPathValue interface {
	ResourceChangeLogResourceChange_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **ResourceChangeLog_ResourceChange)
	CompareWith(*ResourceChangeLog_ResourceChange) (cmp int, comparable bool)
}

func ParseResourceChangeLogResourceChange_FieldPathValue(pathStr, valueStr string) (ResourceChangeLogResourceChange_FieldPathValue, error) {
	fp, err := ParseResourceChangeLogResourceChange_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 ResourceChange field path value from %s: %v", valueStr, err)
	}
	return fpv.(ResourceChangeLogResourceChange_FieldPathValue), nil
}

func MustParseResourceChangeLogResourceChange_FieldPathValue(pathStr, valueStr string) ResourceChangeLogResourceChange_FieldPathValue {
	fpv, err := ParseResourceChangeLogResourceChange_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type ResourceChangeLogResourceChange_FieldTerminalPathValue struct {
	ResourceChangeLogResourceChange_FieldTerminalPath
	value interface{}
}

var _ ResourceChangeLogResourceChange_FieldPathValue = (*ResourceChangeLogResourceChange_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'ResourceChange' as interface{}
func (fpv *ResourceChangeLogResourceChange_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *ResourceChangeLogResourceChange_FieldTerminalPathValue) AsNameValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *ResourceChangeLogResourceChange_FieldTerminalPathValue) AsTypeValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *ResourceChangeLogResourceChange_FieldTerminalPathValue) AsActionValue() (ResourceChangeLog_ResourceChange_Action, bool) {
	res, ok := fpv.value.(ResourceChangeLog_ResourceChange_Action)
	return res, ok
}
func (fpv *ResourceChangeLogResourceChange_FieldTerminalPathValue) AsUpdatedFieldsValue() (*fieldmaskpb.FieldMask, bool) {
	res, ok := fpv.value.(*fieldmaskpb.FieldMask)
	return res, ok
}
func (fpv *ResourceChangeLogResourceChange_FieldTerminalPathValue) AsPreviousValue() (*anypb.Any, bool) {
	res, ok := fpv.value.(*anypb.Any)
	return res, ok
}
func (fpv *ResourceChangeLogResourceChange_FieldTerminalPathValue) AsCurrentValue() (*anypb.Any, bool) {
	res, ok := fpv.value.(*anypb.Any)
	return res, ok
}
func (fpv *ResourceChangeLogResourceChange_FieldTerminalPathValue) AsLabelsValue() (map[string]string, bool) {
	res, ok := fpv.value.(map[string]string)
	return res, ok
}
func (fpv *ResourceChangeLogResourceChange_FieldTerminalPathValue) AsPreValue() (*common.ObjectState, bool) {
	res, ok := fpv.value.(*common.ObjectState)
	return res, ok
}
func (fpv *ResourceChangeLogResourceChange_FieldTerminalPathValue) AsPostValue() (*common.ObjectState, bool) {
	res, ok := fpv.value.(*common.ObjectState)
	return res, ok
}

// SetTo stores value for selected field for object ResourceChange
func (fpv *ResourceChangeLogResourceChange_FieldTerminalPathValue) SetTo(target **ResourceChangeLog_ResourceChange) {
	if *target == nil {
		*target = new(ResourceChangeLog_ResourceChange)
	}
	switch fpv.selector {
	case ResourceChangeLogResourceChange_FieldPathSelectorName:
		(*target).Name = fpv.value.(string)
	case ResourceChangeLogResourceChange_FieldPathSelectorType:
		(*target).Type = fpv.value.(string)
	case ResourceChangeLogResourceChange_FieldPathSelectorAction:
		(*target).Action = fpv.value.(ResourceChangeLog_ResourceChange_Action)
	case ResourceChangeLogResourceChange_FieldPathSelectorUpdatedFields:
		(*target).UpdatedFields = fpv.value.(*fieldmaskpb.FieldMask)
	case ResourceChangeLogResourceChange_FieldPathSelectorPrevious:
		(*target).Previous = fpv.value.(*anypb.Any)
	case ResourceChangeLogResourceChange_FieldPathSelectorCurrent:
		(*target).Current = fpv.value.(*anypb.Any)
	case ResourceChangeLogResourceChange_FieldPathSelectorLabels:
		(*target).Labels = fpv.value.(map[string]string)
	case ResourceChangeLogResourceChange_FieldPathSelectorPre:
		(*target).Pre = fpv.value.(*common.ObjectState)
	case ResourceChangeLogResourceChange_FieldPathSelectorPost:
		(*target).Post = fpv.value.(*common.ObjectState)
	default:
		panic(fmt.Sprintf("Invalid selector for ResourceChangeLog_ResourceChange: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'ResourceChangeLogResourceChange_FieldTerminalPathValue' with the value under path in 'ResourceChangeLog_ResourceChange'.
func (fpv *ResourceChangeLogResourceChange_FieldTerminalPathValue) CompareWith(source *ResourceChangeLog_ResourceChange) (int, bool) {
	switch fpv.selector {
	case ResourceChangeLogResourceChange_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 ResourceChangeLogResourceChange_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 ResourceChangeLogResourceChange_FieldPathSelectorAction:
		leftValue := fpv.value.(ResourceChangeLog_ResourceChange_Action)
		rightValue := source.GetAction()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case ResourceChangeLogResourceChange_FieldPathSelectorUpdatedFields:
		return 0, false
	case ResourceChangeLogResourceChange_FieldPathSelectorPrevious:
		return 0, false
	case ResourceChangeLogResourceChange_FieldPathSelectorCurrent:
		return 0, false
	case ResourceChangeLogResourceChange_FieldPathSelectorLabels:
		return 0, false
	case ResourceChangeLogResourceChange_FieldPathSelectorPre:
		return 0, false
	case ResourceChangeLogResourceChange_FieldPathSelectorPost:
		return 0, false
	default:
		panic(fmt.Sprintf("Invalid selector for ResourceChangeLog_ResourceChange: %d", fpv.selector))
	}
}

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

type ResourceChangeLogResourceChange_FieldPathMapValue struct {
	ResourceChangeLogResourceChange_FieldPathMap
	value interface{}
}

var _ ResourceChangeLogResourceChange_FieldPathValue = (*ResourceChangeLogResourceChange_FieldPathMapValue)(nil)

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

// SetTo stores value for selected field in ResourceChange
func (fpmv *ResourceChangeLogResourceChange_FieldPathMapValue) SetTo(target **ResourceChangeLog_ResourceChange) {
	if *target == nil {
		*target = new(ResourceChangeLog_ResourceChange)
	}
	switch fpmv.selector {
	case ResourceChangeLogResourceChange_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 ResourceChangeLog_ResourceChange: %d", fpmv.selector))
	}
}

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

// CompareWith compares value in the 'ResourceChangeLogResourceChange_FieldPathMapValue' with the value under path in 'ResourceChangeLog_ResourceChange'.
func (fpmv *ResourceChangeLogResourceChange_FieldPathMapValue) CompareWith(source *ResourceChangeLog_ResourceChange) (int, bool) {
	switch fpmv.selector {
	case ResourceChangeLogResourceChange_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 ResourceChangeLog_ResourceChange: %d", fpmv.selector))
	}
}

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

type ResourceChangeLogResourceChange_FieldSubPathValue struct {
	ResourceChangeLogResourceChange_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ ResourceChangeLogResourceChange_FieldPathValue = (*ResourceChangeLogResourceChange_FieldSubPathValue)(nil)

func (fpvs *ResourceChangeLogResourceChange_FieldSubPathValue) AsPrePathValue() (common.ObjectState_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(common.ObjectState_FieldPathValue)
	return res, ok
}
func (fpvs *ResourceChangeLogResourceChange_FieldSubPathValue) AsPostPathValue() (common.ObjectState_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(common.ObjectState_FieldPathValue)
	return res, ok
}

func (fpvs *ResourceChangeLogResourceChange_FieldSubPathValue) SetTo(target **ResourceChangeLog_ResourceChange) {
	if *target == nil {
		*target = new(ResourceChangeLog_ResourceChange)
	}
	switch fpvs.Selector() {
	case ResourceChangeLogResourceChange_FieldPathSelectorPre:
		fpvs.subPathValue.(common.ObjectState_FieldPathValue).SetTo(&(*target).Pre)
	case ResourceChangeLogResourceChange_FieldPathSelectorPost:
		fpvs.subPathValue.(common.ObjectState_FieldPathValue).SetTo(&(*target).Post)
	default:
		panic(fmt.Sprintf("Invalid selector for ResourceChangeLog_ResourceChange: %d", fpvs.Selector()))
	}
}

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

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

func (fpvs *ResourceChangeLogResourceChange_FieldSubPathValue) CompareWith(source *ResourceChangeLog_ResourceChange) (int, bool) {
	switch fpvs.Selector() {
	case ResourceChangeLogResourceChange_FieldPathSelectorPre:
		return fpvs.subPathValue.(common.ObjectState_FieldPathValue).CompareWith(source.GetPre())
	case ResourceChangeLogResourceChange_FieldPathSelectorPost:
		return fpvs.subPathValue.(common.ObjectState_FieldPathValue).CompareWith(source.GetPost())
	default:
		panic(fmt.Sprintf("Invalid selector for ResourceChangeLog_ResourceChange: %d", fpvs.Selector()))
	}
}

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

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

// ParseResourceChangeLogResourceChange_FieldPathArrayItemValue parses string and JSON-encoded value to its Value
func ParseResourceChangeLogResourceChange_FieldPathArrayItemValue(pathStr, valueStr string) (ResourceChangeLogResourceChange_FieldPathArrayItemValue, error) {
	fp, err := ParseResourceChangeLogResourceChange_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 ResourceChange field path array item value from %s: %v", valueStr, err)
	}
	return fpaiv.(ResourceChangeLogResourceChange_FieldPathArrayItemValue), nil
}

func MustParseResourceChangeLogResourceChange_FieldPathArrayItemValue(pathStr, valueStr string) ResourceChangeLogResourceChange_FieldPathArrayItemValue {
	fpaiv, err := ParseResourceChangeLogResourceChange_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type ResourceChangeLogResourceChange_FieldTerminalPathArrayItemValue struct {
	ResourceChangeLogResourceChange_FieldTerminalPath
	value interface{}
}

var _ ResourceChangeLogResourceChange_FieldPathArrayItemValue = (*ResourceChangeLogResourceChange_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *ResourceChangeLogResourceChange_FieldTerminalPathArrayItemValue) GetSingle(source *ResourceChangeLog_ResourceChange) (interface{}, bool) {
	return nil, false
}

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

// Contains returns a boolean indicating if value that is being held is present in given 'ResourceChange'
func (fpaiv *ResourceChangeLogResourceChange_FieldTerminalPathArrayItemValue) ContainsValue(source *ResourceChangeLog_ResourceChange) bool {
	slice := fpaiv.ResourceChangeLogResourceChange_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 ResourceChangeLogResourceChange_FieldSubPathArrayItemValue struct {
	ResourceChangeLogResourceChange_FieldPath
	subPathItemValue gotenobject.FieldPathArrayItemValue
}

// GetRawValue returns stored array item value
func (fpaivs *ResourceChangeLogResourceChange_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *ResourceChangeLogResourceChange_FieldSubPathArrayItemValue) AsPrePathItemValue() (common.ObjectState_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(common.ObjectState_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *ResourceChangeLogResourceChange_FieldSubPathArrayItemValue) AsPostPathItemValue() (common.ObjectState_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(common.ObjectState_FieldPathArrayItemValue)
	return res, ok
}

// Contains returns a boolean indicating if value that is being held is present in given 'ResourceChange'
func (fpaivs *ResourceChangeLogResourceChange_FieldSubPathArrayItemValue) ContainsValue(source *ResourceChangeLog_ResourceChange) bool {
	switch fpaivs.Selector() {
	case ResourceChangeLogResourceChange_FieldPathSelectorPre:
		return fpaivs.subPathItemValue.(common.ObjectState_FieldPathArrayItemValue).ContainsValue(source.GetPre())
	case ResourceChangeLogResourceChange_FieldPathSelectorPost:
		return fpaivs.subPathItemValue.(common.ObjectState_FieldPathArrayItemValue).ContainsValue(source.GetPost())
	default:
		panic(fmt.Sprintf("Invalid selector for ResourceChangeLog_ResourceChange: %d", fpaivs.Selector()))
	}
}

// ResourceChangeLogResourceChange_FieldPathArrayOfValues allows storing slice of values for ResourceChange fields according to their type
type ResourceChangeLogResourceChange_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	ResourceChangeLogResourceChange_FieldPath
}

func ParseResourceChangeLogResourceChange_FieldPathArrayOfValues(pathStr, valuesStr string) (ResourceChangeLogResourceChange_FieldPathArrayOfValues, error) {
	fp, err := ParseResourceChangeLogResourceChange_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 ResourceChange field path array of values from %s: %v", valuesStr, err)
	}
	return fpaov.(ResourceChangeLogResourceChange_FieldPathArrayOfValues), nil
}

func MustParseResourceChangeLogResourceChange_FieldPathArrayOfValues(pathStr, valuesStr string) ResourceChangeLogResourceChange_FieldPathArrayOfValues {
	fpaov, err := ParseResourceChangeLogResourceChange_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type ResourceChangeLogResourceChange_FieldTerminalPathArrayOfValues struct {
	ResourceChangeLogResourceChange_FieldTerminalPath
	values interface{}
}

var _ ResourceChangeLogResourceChange_FieldPathArrayOfValues = (*ResourceChangeLogResourceChange_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *ResourceChangeLogResourceChange_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case ResourceChangeLogResourceChange_FieldPathSelectorName:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case ResourceChangeLogResourceChange_FieldPathSelectorType:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case ResourceChangeLogResourceChange_FieldPathSelectorAction:
		for _, v := range fpaov.values.([]ResourceChangeLog_ResourceChange_Action) {
			values = append(values, v)
		}
	case ResourceChangeLogResourceChange_FieldPathSelectorUpdatedFields:
		for _, v := range fpaov.values.([]*fieldmaskpb.FieldMask) {
			values = append(values, v)
		}
	case ResourceChangeLogResourceChange_FieldPathSelectorPrevious:
		for _, v := range fpaov.values.([]*anypb.Any) {
			values = append(values, v)
		}
	case ResourceChangeLogResourceChange_FieldPathSelectorCurrent:
		for _, v := range fpaov.values.([]*anypb.Any) {
			values = append(values, v)
		}
	case ResourceChangeLogResourceChange_FieldPathSelectorLabels:
		for _, v := range fpaov.values.([]map[string]string) {
			values = append(values, v)
		}
	case ResourceChangeLogResourceChange_FieldPathSelectorPre:
		for _, v := range fpaov.values.([]*common.ObjectState) {
			values = append(values, v)
		}
	case ResourceChangeLogResourceChange_FieldPathSelectorPost:
		for _, v := range fpaov.values.([]*common.ObjectState) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *ResourceChangeLogResourceChange_FieldTerminalPathArrayOfValues) AsNameArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *ResourceChangeLogResourceChange_FieldTerminalPathArrayOfValues) AsTypeArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *ResourceChangeLogResourceChange_FieldTerminalPathArrayOfValues) AsActionArrayOfValues() ([]ResourceChangeLog_ResourceChange_Action, bool) {
	res, ok := fpaov.values.([]ResourceChangeLog_ResourceChange_Action)
	return res, ok
}
func (fpaov *ResourceChangeLogResourceChange_FieldTerminalPathArrayOfValues) AsUpdatedFieldsArrayOfValues() ([]*fieldmaskpb.FieldMask, bool) {
	res, ok := fpaov.values.([]*fieldmaskpb.FieldMask)
	return res, ok
}
func (fpaov *ResourceChangeLogResourceChange_FieldTerminalPathArrayOfValues) AsPreviousArrayOfValues() ([]*anypb.Any, bool) {
	res, ok := fpaov.values.([]*anypb.Any)
	return res, ok
}
func (fpaov *ResourceChangeLogResourceChange_FieldTerminalPathArrayOfValues) AsCurrentArrayOfValues() ([]*anypb.Any, bool) {
	res, ok := fpaov.values.([]*anypb.Any)
	return res, ok
}
func (fpaov *ResourceChangeLogResourceChange_FieldTerminalPathArrayOfValues) AsLabelsArrayOfValues() ([]map[string]string, bool) {
	res, ok := fpaov.values.([]map[string]string)
	return res, ok
}
func (fpaov *ResourceChangeLogResourceChange_FieldTerminalPathArrayOfValues) AsPreArrayOfValues() ([]*common.ObjectState, bool) {
	res, ok := fpaov.values.([]*common.ObjectState)
	return res, ok
}
func (fpaov *ResourceChangeLogResourceChange_FieldTerminalPathArrayOfValues) AsPostArrayOfValues() ([]*common.ObjectState, bool) {
	res, ok := fpaov.values.([]*common.ObjectState)
	return res, ok
}

type ResourceChangeLogResourceChange_FieldPathMapArrayOfValues struct {
	ResourceChangeLogResourceChange_FieldPathMap
	values interface{}
}

var _ ResourceChangeLogResourceChange_FieldPathArrayOfValues = (*ResourceChangeLogResourceChange_FieldPathMapArrayOfValues)(nil)

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

type ResourceChangeLogResourceChange_FieldSubPathArrayOfValues struct {
	ResourceChangeLogResourceChange_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ ResourceChangeLogResourceChange_FieldPathArrayOfValues = (*ResourceChangeLogResourceChange_FieldSubPathArrayOfValues)(nil)

func (fpsaov *ResourceChangeLogResourceChange_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *ResourceChangeLogResourceChange_FieldSubPathArrayOfValues) AsPrePathArrayOfValues() (common.ObjectState_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(common.ObjectState_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *ResourceChangeLogResourceChange_FieldSubPathArrayOfValues) AsPostPathArrayOfValues() (common.ObjectState_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(common.ObjectState_FieldPathArrayOfValues)
	return res, ok
}

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

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

type ResourceChangeLogTransactionInfo_FieldPathSelector int32

const (
	ResourceChangeLogTransactionInfo_FieldPathSelectorIdentifier ResourceChangeLogTransactionInfo_FieldPathSelector = 0
	ResourceChangeLogTransactionInfo_FieldPathSelectorTryCounter ResourceChangeLogTransactionInfo_FieldPathSelector = 1
	ResourceChangeLogTransactionInfo_FieldPathSelectorState      ResourceChangeLogTransactionInfo_FieldPathSelector = 2
)

func (s ResourceChangeLogTransactionInfo_FieldPathSelector) String() string {
	switch s {
	case ResourceChangeLogTransactionInfo_FieldPathSelectorIdentifier:
		return "identifier"
	case ResourceChangeLogTransactionInfo_FieldPathSelectorTryCounter:
		return "try_counter"
	case ResourceChangeLogTransactionInfo_FieldPathSelectorState:
		return "state"
	default:
		panic(fmt.Sprintf("Invalid selector for ResourceChangeLog_TransactionInfo: %d", s))
	}
}

func BuildResourceChangeLogTransactionInfo_FieldPath(fp gotenobject.RawFieldPath) (ResourceChangeLogTransactionInfo_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object ResourceChangeLog_TransactionInfo")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "identifier":
			return &ResourceChangeLogTransactionInfo_FieldTerminalPath{selector: ResourceChangeLogTransactionInfo_FieldPathSelectorIdentifier}, nil
		case "try_counter", "tryCounter", "try-counter":
			return &ResourceChangeLogTransactionInfo_FieldTerminalPath{selector: ResourceChangeLogTransactionInfo_FieldPathSelectorTryCounter}, nil
		case "state":
			return &ResourceChangeLogTransactionInfo_FieldTerminalPath{selector: ResourceChangeLogTransactionInfo_FieldPathSelectorState}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object ResourceChangeLog_TransactionInfo", fp)
}

func ParseResourceChangeLogTransactionInfo_FieldPath(rawField string) (ResourceChangeLogTransactionInfo_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildResourceChangeLogTransactionInfo_FieldPath(fp)
}

func MustParseResourceChangeLogTransactionInfo_FieldPath(rawField string) ResourceChangeLogTransactionInfo_FieldPath {
	fp, err := ParseResourceChangeLogTransactionInfo_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type ResourceChangeLogTransactionInfo_FieldTerminalPath struct {
	selector ResourceChangeLogTransactionInfo_FieldPathSelector
}

var _ ResourceChangeLogTransactionInfo_FieldPath = (*ResourceChangeLogTransactionInfo_FieldTerminalPath)(nil)

func (fp *ResourceChangeLogTransactionInfo_FieldTerminalPath) Selector() ResourceChangeLogTransactionInfo_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source ResourceChangeLog_TransactionInfo
func (fp *ResourceChangeLogTransactionInfo_FieldTerminalPath) Get(source *ResourceChangeLog_TransactionInfo) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case ResourceChangeLogTransactionInfo_FieldPathSelectorIdentifier:
			values = append(values, source.Identifier)
		case ResourceChangeLogTransactionInfo_FieldPathSelectorTryCounter:
			values = append(values, source.TryCounter)
		case ResourceChangeLogTransactionInfo_FieldPathSelectorState:
			values = append(values, source.State)
		default:
			panic(fmt.Sprintf("Invalid selector for ResourceChangeLog_TransactionInfo: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source ResourceChangeLog_TransactionInfo
func (fp *ResourceChangeLogTransactionInfo_FieldTerminalPath) GetSingle(source *ResourceChangeLog_TransactionInfo) (interface{}, bool) {
	switch fp.selector {
	case ResourceChangeLogTransactionInfo_FieldPathSelectorIdentifier:
		return source.GetIdentifier(), source != nil
	case ResourceChangeLogTransactionInfo_FieldPathSelectorTryCounter:
		return source.GetTryCounter(), source != nil
	case ResourceChangeLogTransactionInfo_FieldPathSelectorState:
		return source.GetState(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for ResourceChangeLog_TransactionInfo: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *ResourceChangeLogTransactionInfo_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case ResourceChangeLogTransactionInfo_FieldPathSelectorIdentifier:
		return ""
	case ResourceChangeLogTransactionInfo_FieldPathSelectorTryCounter:
		return int32(0)
	case ResourceChangeLogTransactionInfo_FieldPathSelectorState:
		return ResourceChangeLog_TransactionInfo_UNDEFINED
	default:
		panic(fmt.Sprintf("Invalid selector for ResourceChangeLog_TransactionInfo: %d", fp.selector))
	}
}

func (fp *ResourceChangeLogTransactionInfo_FieldTerminalPath) ClearValue(item *ResourceChangeLog_TransactionInfo) {
	if item != nil {
		switch fp.selector {
		case ResourceChangeLogTransactionInfo_FieldPathSelectorIdentifier:
			item.Identifier = ""
		case ResourceChangeLogTransactionInfo_FieldPathSelectorTryCounter:
			item.TryCounter = int32(0)
		case ResourceChangeLogTransactionInfo_FieldPathSelectorState:
			item.State = ResourceChangeLog_TransactionInfo_UNDEFINED
		default:
			panic(fmt.Sprintf("Invalid selector for ResourceChangeLog_TransactionInfo: %d", fp.selector))
		}
	}
}

func (fp *ResourceChangeLogTransactionInfo_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*ResourceChangeLog_TransactionInfo))
}

// IsLeaf - whether field path is holds simple value
func (fp *ResourceChangeLogTransactionInfo_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == ResourceChangeLogTransactionInfo_FieldPathSelectorIdentifier ||
		fp.selector == ResourceChangeLogTransactionInfo_FieldPathSelectorTryCounter ||
		fp.selector == ResourceChangeLogTransactionInfo_FieldPathSelectorState
}

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

func (fp *ResourceChangeLogTransactionInfo_FieldTerminalPath) WithIValue(value interface{}) ResourceChangeLogTransactionInfo_FieldPathValue {
	switch fp.selector {
	case ResourceChangeLogTransactionInfo_FieldPathSelectorIdentifier:
		return &ResourceChangeLogTransactionInfo_FieldTerminalPathValue{ResourceChangeLogTransactionInfo_FieldTerminalPath: *fp, value: value.(string)}
	case ResourceChangeLogTransactionInfo_FieldPathSelectorTryCounter:
		return &ResourceChangeLogTransactionInfo_FieldTerminalPathValue{ResourceChangeLogTransactionInfo_FieldTerminalPath: *fp, value: value.(int32)}
	case ResourceChangeLogTransactionInfo_FieldPathSelectorState:
		return &ResourceChangeLogTransactionInfo_FieldTerminalPathValue{ResourceChangeLogTransactionInfo_FieldTerminalPath: *fp, value: value.(ResourceChangeLog_TransactionInfo_State)}
	default:
		panic(fmt.Sprintf("Invalid selector for ResourceChangeLog_TransactionInfo: %d", fp.selector))
	}
}

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

func (fp *ResourceChangeLogTransactionInfo_FieldTerminalPath) WithIArrayOfValues(values interface{}) ResourceChangeLogTransactionInfo_FieldPathArrayOfValues {
	fpaov := &ResourceChangeLogTransactionInfo_FieldTerminalPathArrayOfValues{ResourceChangeLogTransactionInfo_FieldTerminalPath: *fp}
	switch fp.selector {
	case ResourceChangeLogTransactionInfo_FieldPathSelectorIdentifier:
		return &ResourceChangeLogTransactionInfo_FieldTerminalPathArrayOfValues{ResourceChangeLogTransactionInfo_FieldTerminalPath: *fp, values: values.([]string)}
	case ResourceChangeLogTransactionInfo_FieldPathSelectorTryCounter:
		return &ResourceChangeLogTransactionInfo_FieldTerminalPathArrayOfValues{ResourceChangeLogTransactionInfo_FieldTerminalPath: *fp, values: values.([]int32)}
	case ResourceChangeLogTransactionInfo_FieldPathSelectorState:
		return &ResourceChangeLogTransactionInfo_FieldTerminalPathArrayOfValues{ResourceChangeLogTransactionInfo_FieldTerminalPath: *fp, values: values.([]ResourceChangeLog_TransactionInfo_State)}
	default:
		panic(fmt.Sprintf("Invalid selector for ResourceChangeLog_TransactionInfo: %d", fp.selector))
	}
	return fpaov
}

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

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

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

// ResourceChangeLogTransactionInfo_FieldPathValue allows storing values for TransactionInfo fields according to their type
type ResourceChangeLogTransactionInfo_FieldPathValue interface {
	ResourceChangeLogTransactionInfo_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **ResourceChangeLog_TransactionInfo)
	CompareWith(*ResourceChangeLog_TransactionInfo) (cmp int, comparable bool)
}

func ParseResourceChangeLogTransactionInfo_FieldPathValue(pathStr, valueStr string) (ResourceChangeLogTransactionInfo_FieldPathValue, error) {
	fp, err := ParseResourceChangeLogTransactionInfo_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 TransactionInfo field path value from %s: %v", valueStr, err)
	}
	return fpv.(ResourceChangeLogTransactionInfo_FieldPathValue), nil
}

func MustParseResourceChangeLogTransactionInfo_FieldPathValue(pathStr, valueStr string) ResourceChangeLogTransactionInfo_FieldPathValue {
	fpv, err := ParseResourceChangeLogTransactionInfo_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type ResourceChangeLogTransactionInfo_FieldTerminalPathValue struct {
	ResourceChangeLogTransactionInfo_FieldTerminalPath
	value interface{}
}

var _ ResourceChangeLogTransactionInfo_FieldPathValue = (*ResourceChangeLogTransactionInfo_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'TransactionInfo' as interface{}
func (fpv *ResourceChangeLogTransactionInfo_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *ResourceChangeLogTransactionInfo_FieldTerminalPathValue) AsIdentifierValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *ResourceChangeLogTransactionInfo_FieldTerminalPathValue) AsTryCounterValue() (int32, bool) {
	res, ok := fpv.value.(int32)
	return res, ok
}
func (fpv *ResourceChangeLogTransactionInfo_FieldTerminalPathValue) AsStateValue() (ResourceChangeLog_TransactionInfo_State, bool) {
	res, ok := fpv.value.(ResourceChangeLog_TransactionInfo_State)
	return res, ok
}

// SetTo stores value for selected field for object TransactionInfo
func (fpv *ResourceChangeLogTransactionInfo_FieldTerminalPathValue) SetTo(target **ResourceChangeLog_TransactionInfo) {
	if *target == nil {
		*target = new(ResourceChangeLog_TransactionInfo)
	}
	switch fpv.selector {
	case ResourceChangeLogTransactionInfo_FieldPathSelectorIdentifier:
		(*target).Identifier = fpv.value.(string)
	case ResourceChangeLogTransactionInfo_FieldPathSelectorTryCounter:
		(*target).TryCounter = fpv.value.(int32)
	case ResourceChangeLogTransactionInfo_FieldPathSelectorState:
		(*target).State = fpv.value.(ResourceChangeLog_TransactionInfo_State)
	default:
		panic(fmt.Sprintf("Invalid selector for ResourceChangeLog_TransactionInfo: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'ResourceChangeLogTransactionInfo_FieldTerminalPathValue' with the value under path in 'ResourceChangeLog_TransactionInfo'.
func (fpv *ResourceChangeLogTransactionInfo_FieldTerminalPathValue) CompareWith(source *ResourceChangeLog_TransactionInfo) (int, bool) {
	switch fpv.selector {
	case ResourceChangeLogTransactionInfo_FieldPathSelectorIdentifier:
		leftValue := fpv.value.(string)
		rightValue := source.GetIdentifier()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case ResourceChangeLogTransactionInfo_FieldPathSelectorTryCounter:
		leftValue := fpv.value.(int32)
		rightValue := source.GetTryCounter()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case ResourceChangeLogTransactionInfo_FieldPathSelectorState:
		leftValue := fpv.value.(ResourceChangeLog_TransactionInfo_State)
		rightValue := source.GetState()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for ResourceChangeLog_TransactionInfo: %d", fpv.selector))
	}
}

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

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

// ParseResourceChangeLogTransactionInfo_FieldPathArrayItemValue parses string and JSON-encoded value to its Value
func ParseResourceChangeLogTransactionInfo_FieldPathArrayItemValue(pathStr, valueStr string) (ResourceChangeLogTransactionInfo_FieldPathArrayItemValue, error) {
	fp, err := ParseResourceChangeLogTransactionInfo_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 TransactionInfo field path array item value from %s: %v", valueStr, err)
	}
	return fpaiv.(ResourceChangeLogTransactionInfo_FieldPathArrayItemValue), nil
}

func MustParseResourceChangeLogTransactionInfo_FieldPathArrayItemValue(pathStr, valueStr string) ResourceChangeLogTransactionInfo_FieldPathArrayItemValue {
	fpaiv, err := ParseResourceChangeLogTransactionInfo_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type ResourceChangeLogTransactionInfo_FieldTerminalPathArrayItemValue struct {
	ResourceChangeLogTransactionInfo_FieldTerminalPath
	value interface{}
}

var _ ResourceChangeLogTransactionInfo_FieldPathArrayItemValue = (*ResourceChangeLogTransactionInfo_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *ResourceChangeLogTransactionInfo_FieldTerminalPathArrayItemValue) GetSingle(source *ResourceChangeLog_TransactionInfo) (interface{}, bool) {
	return nil, false
}

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

// Contains returns a boolean indicating if value that is being held is present in given 'TransactionInfo'
func (fpaiv *ResourceChangeLogTransactionInfo_FieldTerminalPathArrayItemValue) ContainsValue(source *ResourceChangeLog_TransactionInfo) bool {
	slice := fpaiv.ResourceChangeLogTransactionInfo_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
}

// ResourceChangeLogTransactionInfo_FieldPathArrayOfValues allows storing slice of values for TransactionInfo fields according to their type
type ResourceChangeLogTransactionInfo_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	ResourceChangeLogTransactionInfo_FieldPath
}

func ParseResourceChangeLogTransactionInfo_FieldPathArrayOfValues(pathStr, valuesStr string) (ResourceChangeLogTransactionInfo_FieldPathArrayOfValues, error) {
	fp, err := ParseResourceChangeLogTransactionInfo_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 TransactionInfo field path array of values from %s: %v", valuesStr, err)
	}
	return fpaov.(ResourceChangeLogTransactionInfo_FieldPathArrayOfValues), nil
}

func MustParseResourceChangeLogTransactionInfo_FieldPathArrayOfValues(pathStr, valuesStr string) ResourceChangeLogTransactionInfo_FieldPathArrayOfValues {
	fpaov, err := ParseResourceChangeLogTransactionInfo_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type ResourceChangeLogTransactionInfo_FieldTerminalPathArrayOfValues struct {
	ResourceChangeLogTransactionInfo_FieldTerminalPath
	values interface{}
}

var _ ResourceChangeLogTransactionInfo_FieldPathArrayOfValues = (*ResourceChangeLogTransactionInfo_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *ResourceChangeLogTransactionInfo_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case ResourceChangeLogTransactionInfo_FieldPathSelectorIdentifier:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case ResourceChangeLogTransactionInfo_FieldPathSelectorTryCounter:
		for _, v := range fpaov.values.([]int32) {
			values = append(values, v)
		}
	case ResourceChangeLogTransactionInfo_FieldPathSelectorState:
		for _, v := range fpaov.values.([]ResourceChangeLog_TransactionInfo_State) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *ResourceChangeLogTransactionInfo_FieldTerminalPathArrayOfValues) AsIdentifierArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *ResourceChangeLogTransactionInfo_FieldTerminalPathArrayOfValues) AsTryCounterArrayOfValues() ([]int32, bool) {
	res, ok := fpaov.values.([]int32)
	return res, ok
}
func (fpaov *ResourceChangeLogTransactionInfo_FieldTerminalPathArrayOfValues) AsStateArrayOfValues() ([]ResourceChangeLog_TransactionInfo_State, bool) {
	res, ok := fpaov.values.([]ResourceChangeLog_TransactionInfo_State)
	return res, ok
}