service_account_key_service.pb.fieldpath.go

// Code generated by protoc-gen-goten-object
// File: edgelq/iam/proto/v1alpha/service_account_key_service.proto
// DO NOT EDIT!!!

package service_account_key_client

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

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

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

// proto imports
import (
	service_account "github.com/cloudwan/edgelq-sdk/iam/resources/v1alpha/service_account"
	service_account_key "github.com/cloudwan/edgelq-sdk/iam/resources/v1alpha/service_account_key"
	view "github.com/cloudwan/goten-sdk/runtime/api/view"
	watch_type "github.com/cloudwan/goten-sdk/runtime/api/watch_type"
	empty "github.com/golang/protobuf/ptypes/empty"
	timestamp "github.com/golang/protobuf/ptypes/timestamp"
	field_mask "google.golang.org/genproto/protobuf/field_mask"
)

// 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
	_ = fieldmaskpb.FieldMask{}

	_ = new(gotenobject.FieldPath)
)

// make sure we're using proto imports
var (
	_ = &service_account.ServiceAccount{}
	_ = &service_account_key.ServiceAccountKey{}
	_ = &empty.Empty{}
	_ = &field_mask.FieldMask{}
	_ = &timestamp.Timestamp{}
	_ = view.View(0)
	_ = watch_type.WatchType(0)
)

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

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

type GetServiceAccountKeyRequest_FieldPathSelector int32

const (
	GetServiceAccountKeyRequest_FieldPathSelectorName      GetServiceAccountKeyRequest_FieldPathSelector = 0
	GetServiceAccountKeyRequest_FieldPathSelectorFieldMask GetServiceAccountKeyRequest_FieldPathSelector = 1
	GetServiceAccountKeyRequest_FieldPathSelectorView      GetServiceAccountKeyRequest_FieldPathSelector = 2
)

func (s GetServiceAccountKeyRequest_FieldPathSelector) String() string {
	switch s {
	case GetServiceAccountKeyRequest_FieldPathSelectorName:
		return "name"
	case GetServiceAccountKeyRequest_FieldPathSelectorFieldMask:
		return "field_mask"
	case GetServiceAccountKeyRequest_FieldPathSelectorView:
		return "view"
	default:
		panic(fmt.Sprintf("Invalid selector for GetServiceAccountKeyRequest: %d", s))
	}
}

func BuildGetServiceAccountKeyRequest_FieldPath(fp gotenobject.RawFieldPath) (GetServiceAccountKeyRequest_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object GetServiceAccountKeyRequest")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "name":
			return &GetServiceAccountKeyRequest_FieldTerminalPath{selector: GetServiceAccountKeyRequest_FieldPathSelectorName}, nil
		case "field_mask", "fieldMask", "field-mask":
			return &GetServiceAccountKeyRequest_FieldTerminalPath{selector: GetServiceAccountKeyRequest_FieldPathSelectorFieldMask}, nil
		case "view":
			return &GetServiceAccountKeyRequest_FieldTerminalPath{selector: GetServiceAccountKeyRequest_FieldPathSelectorView}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object GetServiceAccountKeyRequest", fp)
}

func ParseGetServiceAccountKeyRequest_FieldPath(rawField string) (GetServiceAccountKeyRequest_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildGetServiceAccountKeyRequest_FieldPath(fp)
}

func MustParseGetServiceAccountKeyRequest_FieldPath(rawField string) GetServiceAccountKeyRequest_FieldPath {
	fp, err := ParseGetServiceAccountKeyRequest_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type GetServiceAccountKeyRequest_FieldTerminalPath struct {
	selector GetServiceAccountKeyRequest_FieldPathSelector
}

var _ GetServiceAccountKeyRequest_FieldPath = (*GetServiceAccountKeyRequest_FieldTerminalPath)(nil)

func (fp *GetServiceAccountKeyRequest_FieldTerminalPath) Selector() GetServiceAccountKeyRequest_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source GetServiceAccountKeyRequest
func (fp *GetServiceAccountKeyRequest_FieldTerminalPath) Get(source *GetServiceAccountKeyRequest) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case GetServiceAccountKeyRequest_FieldPathSelectorName:
			if source.Name != nil {
				values = append(values, source.Name)
			}
		case GetServiceAccountKeyRequest_FieldPathSelectorFieldMask:
			if source.FieldMask != nil {
				values = append(values, source.FieldMask)
			}
		case GetServiceAccountKeyRequest_FieldPathSelectorView:
			values = append(values, source.View)
		default:
			panic(fmt.Sprintf("Invalid selector for GetServiceAccountKeyRequest: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source GetServiceAccountKeyRequest
func (fp *GetServiceAccountKeyRequest_FieldTerminalPath) GetSingle(source *GetServiceAccountKeyRequest) (interface{}, bool) {
	switch fp.selector {
	case GetServiceAccountKeyRequest_FieldPathSelectorName:
		res := source.GetName()
		return res, res != nil
	case GetServiceAccountKeyRequest_FieldPathSelectorFieldMask:
		res := source.GetFieldMask()
		return res, res != nil
	case GetServiceAccountKeyRequest_FieldPathSelectorView:
		return source.GetView(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for GetServiceAccountKeyRequest: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *GetServiceAccountKeyRequest_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case GetServiceAccountKeyRequest_FieldPathSelectorName:
		return (*service_account_key.Reference)(nil)
	case GetServiceAccountKeyRequest_FieldPathSelectorFieldMask:
		return (*service_account_key.ServiceAccountKey_FieldMask)(nil)
	case GetServiceAccountKeyRequest_FieldPathSelectorView:
		return view.View_UNSPECIFIED
	default:
		panic(fmt.Sprintf("Invalid selector for GetServiceAccountKeyRequest: %d", fp.selector))
	}
}

func (fp *GetServiceAccountKeyRequest_FieldTerminalPath) ClearValue(item *GetServiceAccountKeyRequest) {
	if item != nil {
		switch fp.selector {
		case GetServiceAccountKeyRequest_FieldPathSelectorName:
			item.Name = nil
		case GetServiceAccountKeyRequest_FieldPathSelectorFieldMask:
			item.FieldMask = nil
		case GetServiceAccountKeyRequest_FieldPathSelectorView:
			item.View = view.View_UNSPECIFIED
		default:
			panic(fmt.Sprintf("Invalid selector for GetServiceAccountKeyRequest: %d", fp.selector))
		}
	}
}

func (fp *GetServiceAccountKeyRequest_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*GetServiceAccountKeyRequest))
}

// IsLeaf - whether field path is holds simple value
func (fp *GetServiceAccountKeyRequest_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == GetServiceAccountKeyRequest_FieldPathSelectorName ||
		fp.selector == GetServiceAccountKeyRequest_FieldPathSelectorFieldMask ||
		fp.selector == GetServiceAccountKeyRequest_FieldPathSelectorView
}

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

func (fp *GetServiceAccountKeyRequest_FieldTerminalPath) WithIValue(value interface{}) GetServiceAccountKeyRequest_FieldPathValue {
	switch fp.selector {
	case GetServiceAccountKeyRequest_FieldPathSelectorName:
		return &GetServiceAccountKeyRequest_FieldTerminalPathValue{GetServiceAccountKeyRequest_FieldTerminalPath: *fp, value: value.(*service_account_key.Reference)}
	case GetServiceAccountKeyRequest_FieldPathSelectorFieldMask:
		return &GetServiceAccountKeyRequest_FieldTerminalPathValue{GetServiceAccountKeyRequest_FieldTerminalPath: *fp, value: value.(*service_account_key.ServiceAccountKey_FieldMask)}
	case GetServiceAccountKeyRequest_FieldPathSelectorView:
		return &GetServiceAccountKeyRequest_FieldTerminalPathValue{GetServiceAccountKeyRequest_FieldTerminalPath: *fp, value: value.(view.View)}
	default:
		panic(fmt.Sprintf("Invalid selector for GetServiceAccountKeyRequest: %d", fp.selector))
	}
}

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

func (fp *GetServiceAccountKeyRequest_FieldTerminalPath) WithIArrayOfValues(values interface{}) GetServiceAccountKeyRequest_FieldPathArrayOfValues {
	fpaov := &GetServiceAccountKeyRequest_FieldTerminalPathArrayOfValues{GetServiceAccountKeyRequest_FieldTerminalPath: *fp}
	switch fp.selector {
	case GetServiceAccountKeyRequest_FieldPathSelectorName:
		return &GetServiceAccountKeyRequest_FieldTerminalPathArrayOfValues{GetServiceAccountKeyRequest_FieldTerminalPath: *fp, values: values.([]*service_account_key.Reference)}
	case GetServiceAccountKeyRequest_FieldPathSelectorFieldMask:
		return &GetServiceAccountKeyRequest_FieldTerminalPathArrayOfValues{GetServiceAccountKeyRequest_FieldTerminalPath: *fp, values: values.([]*service_account_key.ServiceAccountKey_FieldMask)}
	case GetServiceAccountKeyRequest_FieldPathSelectorView:
		return &GetServiceAccountKeyRequest_FieldTerminalPathArrayOfValues{GetServiceAccountKeyRequest_FieldTerminalPath: *fp, values: values.([]view.View)}
	default:
		panic(fmt.Sprintf("Invalid selector for GetServiceAccountKeyRequest: %d", fp.selector))
	}
	return fpaov
}

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

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

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

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

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

func MustParseGetServiceAccountKeyRequest_FieldPathValue(pathStr, valueStr string) GetServiceAccountKeyRequest_FieldPathValue {
	fpv, err := ParseGetServiceAccountKeyRequest_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type GetServiceAccountKeyRequest_FieldTerminalPathValue struct {
	GetServiceAccountKeyRequest_FieldTerminalPath
	value interface{}
}

var _ GetServiceAccountKeyRequest_FieldPathValue = (*GetServiceAccountKeyRequest_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'GetServiceAccountKeyRequest' as interface{}
func (fpv *GetServiceAccountKeyRequest_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *GetServiceAccountKeyRequest_FieldTerminalPathValue) AsNameValue() (*service_account_key.Reference, bool) {
	res, ok := fpv.value.(*service_account_key.Reference)
	return res, ok
}
func (fpv *GetServiceAccountKeyRequest_FieldTerminalPathValue) AsFieldMaskValue() (*service_account_key.ServiceAccountKey_FieldMask, bool) {
	res, ok := fpv.value.(*service_account_key.ServiceAccountKey_FieldMask)
	return res, ok
}
func (fpv *GetServiceAccountKeyRequest_FieldTerminalPathValue) AsViewValue() (view.View, bool) {
	res, ok := fpv.value.(view.View)
	return res, ok
}

// SetTo stores value for selected field for object GetServiceAccountKeyRequest
func (fpv *GetServiceAccountKeyRequest_FieldTerminalPathValue) SetTo(target **GetServiceAccountKeyRequest) {
	if *target == nil {
		*target = new(GetServiceAccountKeyRequest)
	}
	switch fpv.selector {
	case GetServiceAccountKeyRequest_FieldPathSelectorName:
		(*target).Name = fpv.value.(*service_account_key.Reference)
	case GetServiceAccountKeyRequest_FieldPathSelectorFieldMask:
		(*target).FieldMask = fpv.value.(*service_account_key.ServiceAccountKey_FieldMask)
	case GetServiceAccountKeyRequest_FieldPathSelectorView:
		(*target).View = fpv.value.(view.View)
	default:
		panic(fmt.Sprintf("Invalid selector for GetServiceAccountKeyRequest: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'GetServiceAccountKeyRequest_FieldTerminalPathValue' with the value under path in 'GetServiceAccountKeyRequest'.
func (fpv *GetServiceAccountKeyRequest_FieldTerminalPathValue) CompareWith(source *GetServiceAccountKeyRequest) (int, bool) {
	switch fpv.selector {
	case GetServiceAccountKeyRequest_FieldPathSelectorName:
		leftValue := fpv.value.(*service_account_key.Reference)
		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 GetServiceAccountKeyRequest_FieldPathSelectorFieldMask:
		return 0, false
	case GetServiceAccountKeyRequest_FieldPathSelectorView:
		leftValue := fpv.value.(view.View)
		rightValue := source.GetView()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for GetServiceAccountKeyRequest: %d", fpv.selector))
	}
}

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

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

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

func MustParseGetServiceAccountKeyRequest_FieldPathArrayItemValue(pathStr, valueStr string) GetServiceAccountKeyRequest_FieldPathArrayItemValue {
	fpaiv, err := ParseGetServiceAccountKeyRequest_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type GetServiceAccountKeyRequest_FieldTerminalPathArrayItemValue struct {
	GetServiceAccountKeyRequest_FieldTerminalPath
	value interface{}
}

var _ GetServiceAccountKeyRequest_FieldPathArrayItemValue = (*GetServiceAccountKeyRequest_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *GetServiceAccountKeyRequest_FieldTerminalPathArrayItemValue) GetSingle(source *GetServiceAccountKeyRequest) (interface{}, bool) {
	return nil, false
}

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

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

// GetServiceAccountKeyRequest_FieldPathArrayOfValues allows storing slice of values for GetServiceAccountKeyRequest fields according to their type
type GetServiceAccountKeyRequest_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	GetServiceAccountKeyRequest_FieldPath
}

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

func MustParseGetServiceAccountKeyRequest_FieldPathArrayOfValues(pathStr, valuesStr string) GetServiceAccountKeyRequest_FieldPathArrayOfValues {
	fpaov, err := ParseGetServiceAccountKeyRequest_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type GetServiceAccountKeyRequest_FieldTerminalPathArrayOfValues struct {
	GetServiceAccountKeyRequest_FieldTerminalPath
	values interface{}
}

var _ GetServiceAccountKeyRequest_FieldPathArrayOfValues = (*GetServiceAccountKeyRequest_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *GetServiceAccountKeyRequest_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case GetServiceAccountKeyRequest_FieldPathSelectorName:
		for _, v := range fpaov.values.([]*service_account_key.Reference) {
			values = append(values, v)
		}
	case GetServiceAccountKeyRequest_FieldPathSelectorFieldMask:
		for _, v := range fpaov.values.([]*service_account_key.ServiceAccountKey_FieldMask) {
			values = append(values, v)
		}
	case GetServiceAccountKeyRequest_FieldPathSelectorView:
		for _, v := range fpaov.values.([]view.View) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *GetServiceAccountKeyRequest_FieldTerminalPathArrayOfValues) AsNameArrayOfValues() ([]*service_account_key.Reference, bool) {
	res, ok := fpaov.values.([]*service_account_key.Reference)
	return res, ok
}
func (fpaov *GetServiceAccountKeyRequest_FieldTerminalPathArrayOfValues) AsFieldMaskArrayOfValues() ([]*service_account_key.ServiceAccountKey_FieldMask, bool) {
	res, ok := fpaov.values.([]*service_account_key.ServiceAccountKey_FieldMask)
	return res, ok
}
func (fpaov *GetServiceAccountKeyRequest_FieldTerminalPathArrayOfValues) AsViewArrayOfValues() ([]view.View, bool) {
	res, ok := fpaov.values.([]view.View)
	return res, ok
}

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

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

type BatchGetServiceAccountKeysRequest_FieldPathSelector int32

const (
	BatchGetServiceAccountKeysRequest_FieldPathSelectorNames     BatchGetServiceAccountKeysRequest_FieldPathSelector = 0
	BatchGetServiceAccountKeysRequest_FieldPathSelectorFieldMask BatchGetServiceAccountKeysRequest_FieldPathSelector = 1
	BatchGetServiceAccountKeysRequest_FieldPathSelectorView      BatchGetServiceAccountKeysRequest_FieldPathSelector = 2
)

func (s BatchGetServiceAccountKeysRequest_FieldPathSelector) String() string {
	switch s {
	case BatchGetServiceAccountKeysRequest_FieldPathSelectorNames:
		return "names"
	case BatchGetServiceAccountKeysRequest_FieldPathSelectorFieldMask:
		return "field_mask"
	case BatchGetServiceAccountKeysRequest_FieldPathSelectorView:
		return "view"
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetServiceAccountKeysRequest: %d", s))
	}
}

func BuildBatchGetServiceAccountKeysRequest_FieldPath(fp gotenobject.RawFieldPath) (BatchGetServiceAccountKeysRequest_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object BatchGetServiceAccountKeysRequest")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "names":
			return &BatchGetServiceAccountKeysRequest_FieldTerminalPath{selector: BatchGetServiceAccountKeysRequest_FieldPathSelectorNames}, nil
		case "field_mask", "fieldMask", "field-mask":
			return &BatchGetServiceAccountKeysRequest_FieldTerminalPath{selector: BatchGetServiceAccountKeysRequest_FieldPathSelectorFieldMask}, nil
		case "view":
			return &BatchGetServiceAccountKeysRequest_FieldTerminalPath{selector: BatchGetServiceAccountKeysRequest_FieldPathSelectorView}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object BatchGetServiceAccountKeysRequest", fp)
}

func ParseBatchGetServiceAccountKeysRequest_FieldPath(rawField string) (BatchGetServiceAccountKeysRequest_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildBatchGetServiceAccountKeysRequest_FieldPath(fp)
}

func MustParseBatchGetServiceAccountKeysRequest_FieldPath(rawField string) BatchGetServiceAccountKeysRequest_FieldPath {
	fp, err := ParseBatchGetServiceAccountKeysRequest_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type BatchGetServiceAccountKeysRequest_FieldTerminalPath struct {
	selector BatchGetServiceAccountKeysRequest_FieldPathSelector
}

var _ BatchGetServiceAccountKeysRequest_FieldPath = (*BatchGetServiceAccountKeysRequest_FieldTerminalPath)(nil)

func (fp *BatchGetServiceAccountKeysRequest_FieldTerminalPath) Selector() BatchGetServiceAccountKeysRequest_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source BatchGetServiceAccountKeysRequest
func (fp *BatchGetServiceAccountKeysRequest_FieldTerminalPath) Get(source *BatchGetServiceAccountKeysRequest) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case BatchGetServiceAccountKeysRequest_FieldPathSelectorNames:
			for _, value := range source.GetNames() {
				values = append(values, value)
			}
		case BatchGetServiceAccountKeysRequest_FieldPathSelectorFieldMask:
			if source.FieldMask != nil {
				values = append(values, source.FieldMask)
			}
		case BatchGetServiceAccountKeysRequest_FieldPathSelectorView:
			values = append(values, source.View)
		default:
			panic(fmt.Sprintf("Invalid selector for BatchGetServiceAccountKeysRequest: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source BatchGetServiceAccountKeysRequest
func (fp *BatchGetServiceAccountKeysRequest_FieldTerminalPath) GetSingle(source *BatchGetServiceAccountKeysRequest) (interface{}, bool) {
	switch fp.selector {
	case BatchGetServiceAccountKeysRequest_FieldPathSelectorNames:
		res := source.GetNames()
		return res, res != nil
	case BatchGetServiceAccountKeysRequest_FieldPathSelectorFieldMask:
		res := source.GetFieldMask()
		return res, res != nil
	case BatchGetServiceAccountKeysRequest_FieldPathSelectorView:
		return source.GetView(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetServiceAccountKeysRequest: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *BatchGetServiceAccountKeysRequest_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case BatchGetServiceAccountKeysRequest_FieldPathSelectorNames:
		return ([]*service_account_key.Reference)(nil)
	case BatchGetServiceAccountKeysRequest_FieldPathSelectorFieldMask:
		return (*service_account_key.ServiceAccountKey_FieldMask)(nil)
	case BatchGetServiceAccountKeysRequest_FieldPathSelectorView:
		return view.View_UNSPECIFIED
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetServiceAccountKeysRequest: %d", fp.selector))
	}
}

func (fp *BatchGetServiceAccountKeysRequest_FieldTerminalPath) ClearValue(item *BatchGetServiceAccountKeysRequest) {
	if item != nil {
		switch fp.selector {
		case BatchGetServiceAccountKeysRequest_FieldPathSelectorNames:
			item.Names = nil
		case BatchGetServiceAccountKeysRequest_FieldPathSelectorFieldMask:
			item.FieldMask = nil
		case BatchGetServiceAccountKeysRequest_FieldPathSelectorView:
			item.View = view.View_UNSPECIFIED
		default:
			panic(fmt.Sprintf("Invalid selector for BatchGetServiceAccountKeysRequest: %d", fp.selector))
		}
	}
}

func (fp *BatchGetServiceAccountKeysRequest_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*BatchGetServiceAccountKeysRequest))
}

// IsLeaf - whether field path is holds simple value
func (fp *BatchGetServiceAccountKeysRequest_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == BatchGetServiceAccountKeysRequest_FieldPathSelectorNames ||
		fp.selector == BatchGetServiceAccountKeysRequest_FieldPathSelectorFieldMask ||
		fp.selector == BatchGetServiceAccountKeysRequest_FieldPathSelectorView
}

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

func (fp *BatchGetServiceAccountKeysRequest_FieldTerminalPath) WithIValue(value interface{}) BatchGetServiceAccountKeysRequest_FieldPathValue {
	switch fp.selector {
	case BatchGetServiceAccountKeysRequest_FieldPathSelectorNames:
		return &BatchGetServiceAccountKeysRequest_FieldTerminalPathValue{BatchGetServiceAccountKeysRequest_FieldTerminalPath: *fp, value: value.([]*service_account_key.Reference)}
	case BatchGetServiceAccountKeysRequest_FieldPathSelectorFieldMask:
		return &BatchGetServiceAccountKeysRequest_FieldTerminalPathValue{BatchGetServiceAccountKeysRequest_FieldTerminalPath: *fp, value: value.(*service_account_key.ServiceAccountKey_FieldMask)}
	case BatchGetServiceAccountKeysRequest_FieldPathSelectorView:
		return &BatchGetServiceAccountKeysRequest_FieldTerminalPathValue{BatchGetServiceAccountKeysRequest_FieldTerminalPath: *fp, value: value.(view.View)}
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetServiceAccountKeysRequest: %d", fp.selector))
	}
}

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

func (fp *BatchGetServiceAccountKeysRequest_FieldTerminalPath) WithIArrayOfValues(values interface{}) BatchGetServiceAccountKeysRequest_FieldPathArrayOfValues {
	fpaov := &BatchGetServiceAccountKeysRequest_FieldTerminalPathArrayOfValues{BatchGetServiceAccountKeysRequest_FieldTerminalPath: *fp}
	switch fp.selector {
	case BatchGetServiceAccountKeysRequest_FieldPathSelectorNames:
		return &BatchGetServiceAccountKeysRequest_FieldTerminalPathArrayOfValues{BatchGetServiceAccountKeysRequest_FieldTerminalPath: *fp, values: values.([][]*service_account_key.Reference)}
	case BatchGetServiceAccountKeysRequest_FieldPathSelectorFieldMask:
		return &BatchGetServiceAccountKeysRequest_FieldTerminalPathArrayOfValues{BatchGetServiceAccountKeysRequest_FieldTerminalPath: *fp, values: values.([]*service_account_key.ServiceAccountKey_FieldMask)}
	case BatchGetServiceAccountKeysRequest_FieldPathSelectorView:
		return &BatchGetServiceAccountKeysRequest_FieldTerminalPathArrayOfValues{BatchGetServiceAccountKeysRequest_FieldTerminalPath: *fp, values: values.([]view.View)}
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetServiceAccountKeysRequest: %d", fp.selector))
	}
	return fpaov
}

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

func (fp *BatchGetServiceAccountKeysRequest_FieldTerminalPath) WithIArrayItemValue(value interface{}) BatchGetServiceAccountKeysRequest_FieldPathArrayItemValue {
	switch fp.selector {
	case BatchGetServiceAccountKeysRequest_FieldPathSelectorNames:
		return &BatchGetServiceAccountKeysRequest_FieldTerminalPathArrayItemValue{BatchGetServiceAccountKeysRequest_FieldTerminalPath: *fp, value: value.(*service_account_key.Reference)}
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetServiceAccountKeysRequest: %d", fp.selector))
	}
}

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

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

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

func MustParseBatchGetServiceAccountKeysRequest_FieldPathValue(pathStr, valueStr string) BatchGetServiceAccountKeysRequest_FieldPathValue {
	fpv, err := ParseBatchGetServiceAccountKeysRequest_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type BatchGetServiceAccountKeysRequest_FieldTerminalPathValue struct {
	BatchGetServiceAccountKeysRequest_FieldTerminalPath
	value interface{}
}

var _ BatchGetServiceAccountKeysRequest_FieldPathValue = (*BatchGetServiceAccountKeysRequest_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'BatchGetServiceAccountKeysRequest' as interface{}
func (fpv *BatchGetServiceAccountKeysRequest_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *BatchGetServiceAccountKeysRequest_FieldTerminalPathValue) AsNamesValue() ([]*service_account_key.Reference, bool) {
	res, ok := fpv.value.([]*service_account_key.Reference)
	return res, ok
}
func (fpv *BatchGetServiceAccountKeysRequest_FieldTerminalPathValue) AsFieldMaskValue() (*service_account_key.ServiceAccountKey_FieldMask, bool) {
	res, ok := fpv.value.(*service_account_key.ServiceAccountKey_FieldMask)
	return res, ok
}
func (fpv *BatchGetServiceAccountKeysRequest_FieldTerminalPathValue) AsViewValue() (view.View, bool) {
	res, ok := fpv.value.(view.View)
	return res, ok
}

// SetTo stores value for selected field for object BatchGetServiceAccountKeysRequest
func (fpv *BatchGetServiceAccountKeysRequest_FieldTerminalPathValue) SetTo(target **BatchGetServiceAccountKeysRequest) {
	if *target == nil {
		*target = new(BatchGetServiceAccountKeysRequest)
	}
	switch fpv.selector {
	case BatchGetServiceAccountKeysRequest_FieldPathSelectorNames:
		(*target).Names = fpv.value.([]*service_account_key.Reference)
	case BatchGetServiceAccountKeysRequest_FieldPathSelectorFieldMask:
		(*target).FieldMask = fpv.value.(*service_account_key.ServiceAccountKey_FieldMask)
	case BatchGetServiceAccountKeysRequest_FieldPathSelectorView:
		(*target).View = fpv.value.(view.View)
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetServiceAccountKeysRequest: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'BatchGetServiceAccountKeysRequest_FieldTerminalPathValue' with the value under path in 'BatchGetServiceAccountKeysRequest'.
func (fpv *BatchGetServiceAccountKeysRequest_FieldTerminalPathValue) CompareWith(source *BatchGetServiceAccountKeysRequest) (int, bool) {
	switch fpv.selector {
	case BatchGetServiceAccountKeysRequest_FieldPathSelectorNames:
		return 0, false
	case BatchGetServiceAccountKeysRequest_FieldPathSelectorFieldMask:
		return 0, false
	case BatchGetServiceAccountKeysRequest_FieldPathSelectorView:
		leftValue := fpv.value.(view.View)
		rightValue := source.GetView()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetServiceAccountKeysRequest: %d", fpv.selector))
	}
}

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

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

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

func MustParseBatchGetServiceAccountKeysRequest_FieldPathArrayItemValue(pathStr, valueStr string) BatchGetServiceAccountKeysRequest_FieldPathArrayItemValue {
	fpaiv, err := ParseBatchGetServiceAccountKeysRequest_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type BatchGetServiceAccountKeysRequest_FieldTerminalPathArrayItemValue struct {
	BatchGetServiceAccountKeysRequest_FieldTerminalPath
	value interface{}
}

var _ BatchGetServiceAccountKeysRequest_FieldPathArrayItemValue = (*BatchGetServiceAccountKeysRequest_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object BatchGetServiceAccountKeysRequest as interface{}
func (fpaiv *BatchGetServiceAccountKeysRequest_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}
func (fpaiv *BatchGetServiceAccountKeysRequest_FieldTerminalPathArrayItemValue) AsNamesItemValue() (*service_account_key.Reference, bool) {
	res, ok := fpaiv.value.(*service_account_key.Reference)
	return res, ok
}

func (fpaiv *BatchGetServiceAccountKeysRequest_FieldTerminalPathArrayItemValue) GetSingle(source *BatchGetServiceAccountKeysRequest) (interface{}, bool) {
	return nil, false
}

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

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

// BatchGetServiceAccountKeysRequest_FieldPathArrayOfValues allows storing slice of values for BatchGetServiceAccountKeysRequest fields according to their type
type BatchGetServiceAccountKeysRequest_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	BatchGetServiceAccountKeysRequest_FieldPath
}

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

func MustParseBatchGetServiceAccountKeysRequest_FieldPathArrayOfValues(pathStr, valuesStr string) BatchGetServiceAccountKeysRequest_FieldPathArrayOfValues {
	fpaov, err := ParseBatchGetServiceAccountKeysRequest_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type BatchGetServiceAccountKeysRequest_FieldTerminalPathArrayOfValues struct {
	BatchGetServiceAccountKeysRequest_FieldTerminalPath
	values interface{}
}

var _ BatchGetServiceAccountKeysRequest_FieldPathArrayOfValues = (*BatchGetServiceAccountKeysRequest_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *BatchGetServiceAccountKeysRequest_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case BatchGetServiceAccountKeysRequest_FieldPathSelectorNames:
		for _, v := range fpaov.values.([][]*service_account_key.Reference) {
			values = append(values, v)
		}
	case BatchGetServiceAccountKeysRequest_FieldPathSelectorFieldMask:
		for _, v := range fpaov.values.([]*service_account_key.ServiceAccountKey_FieldMask) {
			values = append(values, v)
		}
	case BatchGetServiceAccountKeysRequest_FieldPathSelectorView:
		for _, v := range fpaov.values.([]view.View) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *BatchGetServiceAccountKeysRequest_FieldTerminalPathArrayOfValues) AsNamesArrayOfValues() ([][]*service_account_key.Reference, bool) {
	res, ok := fpaov.values.([][]*service_account_key.Reference)
	return res, ok
}
func (fpaov *BatchGetServiceAccountKeysRequest_FieldTerminalPathArrayOfValues) AsFieldMaskArrayOfValues() ([]*service_account_key.ServiceAccountKey_FieldMask, bool) {
	res, ok := fpaov.values.([]*service_account_key.ServiceAccountKey_FieldMask)
	return res, ok
}
func (fpaov *BatchGetServiceAccountKeysRequest_FieldTerminalPathArrayOfValues) AsViewArrayOfValues() ([]view.View, bool) {
	res, ok := fpaov.values.([]view.View)
	return res, ok
}

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

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

type BatchGetServiceAccountKeysResponse_FieldPathSelector int32

const (
	BatchGetServiceAccountKeysResponse_FieldPathSelectorServiceAccountKeys BatchGetServiceAccountKeysResponse_FieldPathSelector = 0
	BatchGetServiceAccountKeysResponse_FieldPathSelectorMissing            BatchGetServiceAccountKeysResponse_FieldPathSelector = 1
)

func (s BatchGetServiceAccountKeysResponse_FieldPathSelector) String() string {
	switch s {
	case BatchGetServiceAccountKeysResponse_FieldPathSelectorServiceAccountKeys:
		return "service_account_keys"
	case BatchGetServiceAccountKeysResponse_FieldPathSelectorMissing:
		return "missing"
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetServiceAccountKeysResponse: %d", s))
	}
}

func BuildBatchGetServiceAccountKeysResponse_FieldPath(fp gotenobject.RawFieldPath) (BatchGetServiceAccountKeysResponse_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object BatchGetServiceAccountKeysResponse")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "service_account_keys", "serviceAccountKeys", "service-account-keys":
			return &BatchGetServiceAccountKeysResponse_FieldTerminalPath{selector: BatchGetServiceAccountKeysResponse_FieldPathSelectorServiceAccountKeys}, nil
		case "missing":
			return &BatchGetServiceAccountKeysResponse_FieldTerminalPath{selector: BatchGetServiceAccountKeysResponse_FieldPathSelectorMissing}, nil
		}
	} else {
		switch fp[0] {
		case "service_account_keys", "serviceAccountKeys", "service-account-keys":
			if subpath, err := service_account_key.BuildServiceAccountKey_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &BatchGetServiceAccountKeysResponse_FieldSubPath{selector: BatchGetServiceAccountKeysResponse_FieldPathSelectorServiceAccountKeys, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object BatchGetServiceAccountKeysResponse", fp)
}

func ParseBatchGetServiceAccountKeysResponse_FieldPath(rawField string) (BatchGetServiceAccountKeysResponse_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildBatchGetServiceAccountKeysResponse_FieldPath(fp)
}

func MustParseBatchGetServiceAccountKeysResponse_FieldPath(rawField string) BatchGetServiceAccountKeysResponse_FieldPath {
	fp, err := ParseBatchGetServiceAccountKeysResponse_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type BatchGetServiceAccountKeysResponse_FieldTerminalPath struct {
	selector BatchGetServiceAccountKeysResponse_FieldPathSelector
}

var _ BatchGetServiceAccountKeysResponse_FieldPath = (*BatchGetServiceAccountKeysResponse_FieldTerminalPath)(nil)

func (fp *BatchGetServiceAccountKeysResponse_FieldTerminalPath) Selector() BatchGetServiceAccountKeysResponse_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source BatchGetServiceAccountKeysResponse
func (fp *BatchGetServiceAccountKeysResponse_FieldTerminalPath) Get(source *BatchGetServiceAccountKeysResponse) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case BatchGetServiceAccountKeysResponse_FieldPathSelectorServiceAccountKeys:
			for _, value := range source.GetServiceAccountKeys() {
				values = append(values, value)
			}
		case BatchGetServiceAccountKeysResponse_FieldPathSelectorMissing:
			for _, value := range source.GetMissing() {
				values = append(values, value)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for BatchGetServiceAccountKeysResponse: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source BatchGetServiceAccountKeysResponse
func (fp *BatchGetServiceAccountKeysResponse_FieldTerminalPath) GetSingle(source *BatchGetServiceAccountKeysResponse) (interface{}, bool) {
	switch fp.selector {
	case BatchGetServiceAccountKeysResponse_FieldPathSelectorServiceAccountKeys:
		res := source.GetServiceAccountKeys()
		return res, res != nil
	case BatchGetServiceAccountKeysResponse_FieldPathSelectorMissing:
		res := source.GetMissing()
		return res, res != nil
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetServiceAccountKeysResponse: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *BatchGetServiceAccountKeysResponse_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case BatchGetServiceAccountKeysResponse_FieldPathSelectorServiceAccountKeys:
		return ([]*service_account_key.ServiceAccountKey)(nil)
	case BatchGetServiceAccountKeysResponse_FieldPathSelectorMissing:
		return ([]*service_account_key.Reference)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetServiceAccountKeysResponse: %d", fp.selector))
	}
}

func (fp *BatchGetServiceAccountKeysResponse_FieldTerminalPath) ClearValue(item *BatchGetServiceAccountKeysResponse) {
	if item != nil {
		switch fp.selector {
		case BatchGetServiceAccountKeysResponse_FieldPathSelectorServiceAccountKeys:
			item.ServiceAccountKeys = nil
		case BatchGetServiceAccountKeysResponse_FieldPathSelectorMissing:
			item.Missing = nil
		default:
			panic(fmt.Sprintf("Invalid selector for BatchGetServiceAccountKeysResponse: %d", fp.selector))
		}
	}
}

func (fp *BatchGetServiceAccountKeysResponse_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*BatchGetServiceAccountKeysResponse))
}

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

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

func (fp *BatchGetServiceAccountKeysResponse_FieldTerminalPath) WithIValue(value interface{}) BatchGetServiceAccountKeysResponse_FieldPathValue {
	switch fp.selector {
	case BatchGetServiceAccountKeysResponse_FieldPathSelectorServiceAccountKeys:
		return &BatchGetServiceAccountKeysResponse_FieldTerminalPathValue{BatchGetServiceAccountKeysResponse_FieldTerminalPath: *fp, value: value.([]*service_account_key.ServiceAccountKey)}
	case BatchGetServiceAccountKeysResponse_FieldPathSelectorMissing:
		return &BatchGetServiceAccountKeysResponse_FieldTerminalPathValue{BatchGetServiceAccountKeysResponse_FieldTerminalPath: *fp, value: value.([]*service_account_key.Reference)}
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetServiceAccountKeysResponse: %d", fp.selector))
	}
}

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

func (fp *BatchGetServiceAccountKeysResponse_FieldTerminalPath) WithIArrayOfValues(values interface{}) BatchGetServiceAccountKeysResponse_FieldPathArrayOfValues {
	fpaov := &BatchGetServiceAccountKeysResponse_FieldTerminalPathArrayOfValues{BatchGetServiceAccountKeysResponse_FieldTerminalPath: *fp}
	switch fp.selector {
	case BatchGetServiceAccountKeysResponse_FieldPathSelectorServiceAccountKeys:
		return &BatchGetServiceAccountKeysResponse_FieldTerminalPathArrayOfValues{BatchGetServiceAccountKeysResponse_FieldTerminalPath: *fp, values: values.([][]*service_account_key.ServiceAccountKey)}
	case BatchGetServiceAccountKeysResponse_FieldPathSelectorMissing:
		return &BatchGetServiceAccountKeysResponse_FieldTerminalPathArrayOfValues{BatchGetServiceAccountKeysResponse_FieldTerminalPath: *fp, values: values.([][]*service_account_key.Reference)}
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetServiceAccountKeysResponse: %d", fp.selector))
	}
	return fpaov
}

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

func (fp *BatchGetServiceAccountKeysResponse_FieldTerminalPath) WithIArrayItemValue(value interface{}) BatchGetServiceAccountKeysResponse_FieldPathArrayItemValue {
	switch fp.selector {
	case BatchGetServiceAccountKeysResponse_FieldPathSelectorServiceAccountKeys:
		return &BatchGetServiceAccountKeysResponse_FieldTerminalPathArrayItemValue{BatchGetServiceAccountKeysResponse_FieldTerminalPath: *fp, value: value.(*service_account_key.ServiceAccountKey)}
	case BatchGetServiceAccountKeysResponse_FieldPathSelectorMissing:
		return &BatchGetServiceAccountKeysResponse_FieldTerminalPathArrayItemValue{BatchGetServiceAccountKeysResponse_FieldTerminalPath: *fp, value: value.(*service_account_key.Reference)}
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetServiceAccountKeysResponse: %d", fp.selector))
	}
}

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

type BatchGetServiceAccountKeysResponse_FieldSubPath struct {
	selector BatchGetServiceAccountKeysResponse_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ BatchGetServiceAccountKeysResponse_FieldPath = (*BatchGetServiceAccountKeysResponse_FieldSubPath)(nil)

func (fps *BatchGetServiceAccountKeysResponse_FieldSubPath) Selector() BatchGetServiceAccountKeysResponse_FieldPathSelector {
	return fps.selector
}
func (fps *BatchGetServiceAccountKeysResponse_FieldSubPath) AsServiceAccountKeysSubPath() (service_account_key.ServiceAccountKey_FieldPath, bool) {
	res, ok := fps.subPath.(service_account_key.ServiceAccountKey_FieldPath)
	return res, ok
}

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

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

// Get returns all values pointed by selected field from source BatchGetServiceAccountKeysResponse
func (fps *BatchGetServiceAccountKeysResponse_FieldSubPath) Get(source *BatchGetServiceAccountKeysResponse) (values []interface{}) {
	switch fps.selector {
	case BatchGetServiceAccountKeysResponse_FieldPathSelectorServiceAccountKeys:
		for _, item := range source.GetServiceAccountKeys() {
			values = append(values, fps.subPath.GetRaw(item)...)
		}
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetServiceAccountKeysResponse: %d", fps.selector))
	}
	return
}

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

// GetSingle returns value of selected field from source BatchGetServiceAccountKeysResponse
func (fps *BatchGetServiceAccountKeysResponse_FieldSubPath) GetSingle(source *BatchGetServiceAccountKeysResponse) (interface{}, bool) {
	switch fps.selector {
	case BatchGetServiceAccountKeysResponse_FieldPathSelectorServiceAccountKeys:
		if len(source.GetServiceAccountKeys()) == 0 {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetServiceAccountKeys()[0])
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetServiceAccountKeysResponse: %d", fps.selector))
	}
}

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

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

func (fps *BatchGetServiceAccountKeysResponse_FieldSubPath) ClearValue(item *BatchGetServiceAccountKeysResponse) {
	if item != nil {
		switch fps.selector {
		case BatchGetServiceAccountKeysResponse_FieldPathSelectorServiceAccountKeys:
			for _, subItem := range item.ServiceAccountKeys {
				fps.subPath.ClearValueRaw(subItem)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for BatchGetServiceAccountKeysResponse: %d", fps.selector))
		}
	}
}

func (fps *BatchGetServiceAccountKeysResponse_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*BatchGetServiceAccountKeysResponse))
}

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

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

func (fps *BatchGetServiceAccountKeysResponse_FieldSubPath) WithIValue(value interface{}) BatchGetServiceAccountKeysResponse_FieldPathValue {
	return &BatchGetServiceAccountKeysResponse_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *BatchGetServiceAccountKeysResponse_FieldSubPath) WithIArrayOfValues(values interface{}) BatchGetServiceAccountKeysResponse_FieldPathArrayOfValues {
	return &BatchGetServiceAccountKeysResponse_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *BatchGetServiceAccountKeysResponse_FieldSubPath) WithIArrayItemValue(value interface{}) BatchGetServiceAccountKeysResponse_FieldPathArrayItemValue {
	return &BatchGetServiceAccountKeysResponse_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

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

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

func MustParseBatchGetServiceAccountKeysResponse_FieldPathValue(pathStr, valueStr string) BatchGetServiceAccountKeysResponse_FieldPathValue {
	fpv, err := ParseBatchGetServiceAccountKeysResponse_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type BatchGetServiceAccountKeysResponse_FieldTerminalPathValue struct {
	BatchGetServiceAccountKeysResponse_FieldTerminalPath
	value interface{}
}

var _ BatchGetServiceAccountKeysResponse_FieldPathValue = (*BatchGetServiceAccountKeysResponse_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'BatchGetServiceAccountKeysResponse' as interface{}
func (fpv *BatchGetServiceAccountKeysResponse_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *BatchGetServiceAccountKeysResponse_FieldTerminalPathValue) AsServiceAccountKeysValue() ([]*service_account_key.ServiceAccountKey, bool) {
	res, ok := fpv.value.([]*service_account_key.ServiceAccountKey)
	return res, ok
}
func (fpv *BatchGetServiceAccountKeysResponse_FieldTerminalPathValue) AsMissingValue() ([]*service_account_key.Reference, bool) {
	res, ok := fpv.value.([]*service_account_key.Reference)
	return res, ok
}

// SetTo stores value for selected field for object BatchGetServiceAccountKeysResponse
func (fpv *BatchGetServiceAccountKeysResponse_FieldTerminalPathValue) SetTo(target **BatchGetServiceAccountKeysResponse) {
	if *target == nil {
		*target = new(BatchGetServiceAccountKeysResponse)
	}
	switch fpv.selector {
	case BatchGetServiceAccountKeysResponse_FieldPathSelectorServiceAccountKeys:
		(*target).ServiceAccountKeys = fpv.value.([]*service_account_key.ServiceAccountKey)
	case BatchGetServiceAccountKeysResponse_FieldPathSelectorMissing:
		(*target).Missing = fpv.value.([]*service_account_key.Reference)
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetServiceAccountKeysResponse: %d", fpv.selector))
	}
}

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

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

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

type BatchGetServiceAccountKeysResponse_FieldSubPathValue struct {
	BatchGetServiceAccountKeysResponse_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ BatchGetServiceAccountKeysResponse_FieldPathValue = (*BatchGetServiceAccountKeysResponse_FieldSubPathValue)(nil)

func (fpvs *BatchGetServiceAccountKeysResponse_FieldSubPathValue) AsServiceAccountKeysPathValue() (service_account_key.ServiceAccountKey_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(service_account_key.ServiceAccountKey_FieldPathValue)
	return res, ok
}

func (fpvs *BatchGetServiceAccountKeysResponse_FieldSubPathValue) SetTo(target **BatchGetServiceAccountKeysResponse) {
	if *target == nil {
		*target = new(BatchGetServiceAccountKeysResponse)
	}
	switch fpvs.Selector() {
	case BatchGetServiceAccountKeysResponse_FieldPathSelectorServiceAccountKeys:
		panic("FieldPath setter is unsupported for array subpaths")
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetServiceAccountKeysResponse: %d", fpvs.Selector()))
	}
}

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

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

func (fpvs *BatchGetServiceAccountKeysResponse_FieldSubPathValue) CompareWith(source *BatchGetServiceAccountKeysResponse) (int, bool) {
	switch fpvs.Selector() {
	case BatchGetServiceAccountKeysResponse_FieldPathSelectorServiceAccountKeys:
		return 0, false // repeated field
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetServiceAccountKeysResponse: %d", fpvs.Selector()))
	}
}

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

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

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

func MustParseBatchGetServiceAccountKeysResponse_FieldPathArrayItemValue(pathStr, valueStr string) BatchGetServiceAccountKeysResponse_FieldPathArrayItemValue {
	fpaiv, err := ParseBatchGetServiceAccountKeysResponse_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type BatchGetServiceAccountKeysResponse_FieldTerminalPathArrayItemValue struct {
	BatchGetServiceAccountKeysResponse_FieldTerminalPath
	value interface{}
}

var _ BatchGetServiceAccountKeysResponse_FieldPathArrayItemValue = (*BatchGetServiceAccountKeysResponse_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object BatchGetServiceAccountKeysResponse as interface{}
func (fpaiv *BatchGetServiceAccountKeysResponse_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}
func (fpaiv *BatchGetServiceAccountKeysResponse_FieldTerminalPathArrayItemValue) AsServiceAccountKeysItemValue() (*service_account_key.ServiceAccountKey, bool) {
	res, ok := fpaiv.value.(*service_account_key.ServiceAccountKey)
	return res, ok
}
func (fpaiv *BatchGetServiceAccountKeysResponse_FieldTerminalPathArrayItemValue) AsMissingItemValue() (*service_account_key.Reference, bool) {
	res, ok := fpaiv.value.(*service_account_key.Reference)
	return res, ok
}

func (fpaiv *BatchGetServiceAccountKeysResponse_FieldTerminalPathArrayItemValue) GetSingle(source *BatchGetServiceAccountKeysResponse) (interface{}, bool) {
	return nil, false
}

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

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

// GetRawValue returns stored array item value
func (fpaivs *BatchGetServiceAccountKeysResponse_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *BatchGetServiceAccountKeysResponse_FieldSubPathArrayItemValue) AsServiceAccountKeysPathItemValue() (service_account_key.ServiceAccountKey_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(service_account_key.ServiceAccountKey_FieldPathArrayItemValue)
	return res, ok
}

// Contains returns a boolean indicating if value that is being held is present in given 'BatchGetServiceAccountKeysResponse'
func (fpaivs *BatchGetServiceAccountKeysResponse_FieldSubPathArrayItemValue) ContainsValue(source *BatchGetServiceAccountKeysResponse) bool {
	switch fpaivs.Selector() {
	case BatchGetServiceAccountKeysResponse_FieldPathSelectorServiceAccountKeys:
		return false // repeated/map field
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetServiceAccountKeysResponse: %d", fpaivs.Selector()))
	}
}

// BatchGetServiceAccountKeysResponse_FieldPathArrayOfValues allows storing slice of values for BatchGetServiceAccountKeysResponse fields according to their type
type BatchGetServiceAccountKeysResponse_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	BatchGetServiceAccountKeysResponse_FieldPath
}

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

func MustParseBatchGetServiceAccountKeysResponse_FieldPathArrayOfValues(pathStr, valuesStr string) BatchGetServiceAccountKeysResponse_FieldPathArrayOfValues {
	fpaov, err := ParseBatchGetServiceAccountKeysResponse_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type BatchGetServiceAccountKeysResponse_FieldTerminalPathArrayOfValues struct {
	BatchGetServiceAccountKeysResponse_FieldTerminalPath
	values interface{}
}

var _ BatchGetServiceAccountKeysResponse_FieldPathArrayOfValues = (*BatchGetServiceAccountKeysResponse_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *BatchGetServiceAccountKeysResponse_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case BatchGetServiceAccountKeysResponse_FieldPathSelectorServiceAccountKeys:
		for _, v := range fpaov.values.([][]*service_account_key.ServiceAccountKey) {
			values = append(values, v)
		}
	case BatchGetServiceAccountKeysResponse_FieldPathSelectorMissing:
		for _, v := range fpaov.values.([][]*service_account_key.Reference) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *BatchGetServiceAccountKeysResponse_FieldTerminalPathArrayOfValues) AsServiceAccountKeysArrayOfValues() ([][]*service_account_key.ServiceAccountKey, bool) {
	res, ok := fpaov.values.([][]*service_account_key.ServiceAccountKey)
	return res, ok
}
func (fpaov *BatchGetServiceAccountKeysResponse_FieldTerminalPathArrayOfValues) AsMissingArrayOfValues() ([][]*service_account_key.Reference, bool) {
	res, ok := fpaov.values.([][]*service_account_key.Reference)
	return res, ok
}

type BatchGetServiceAccountKeysResponse_FieldSubPathArrayOfValues struct {
	BatchGetServiceAccountKeysResponse_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ BatchGetServiceAccountKeysResponse_FieldPathArrayOfValues = (*BatchGetServiceAccountKeysResponse_FieldSubPathArrayOfValues)(nil)

func (fpsaov *BatchGetServiceAccountKeysResponse_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *BatchGetServiceAccountKeysResponse_FieldSubPathArrayOfValues) AsServiceAccountKeysPathArrayOfValues() (service_account_key.ServiceAccountKey_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(service_account_key.ServiceAccountKey_FieldPathArrayOfValues)
	return res, ok
}

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

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

type ListServiceAccountKeysRequest_FieldPathSelector int32

const (
	ListServiceAccountKeysRequest_FieldPathSelectorParent            ListServiceAccountKeysRequest_FieldPathSelector = 0
	ListServiceAccountKeysRequest_FieldPathSelectorPageSize          ListServiceAccountKeysRequest_FieldPathSelector = 1
	ListServiceAccountKeysRequest_FieldPathSelectorPageToken         ListServiceAccountKeysRequest_FieldPathSelector = 2
	ListServiceAccountKeysRequest_FieldPathSelectorOrderBy           ListServiceAccountKeysRequest_FieldPathSelector = 3
	ListServiceAccountKeysRequest_FieldPathSelectorFilter            ListServiceAccountKeysRequest_FieldPathSelector = 4
	ListServiceAccountKeysRequest_FieldPathSelectorFieldMask         ListServiceAccountKeysRequest_FieldPathSelector = 5
	ListServiceAccountKeysRequest_FieldPathSelectorView              ListServiceAccountKeysRequest_FieldPathSelector = 6
	ListServiceAccountKeysRequest_FieldPathSelectorIncludePagingInfo ListServiceAccountKeysRequest_FieldPathSelector = 7
)

func (s ListServiceAccountKeysRequest_FieldPathSelector) String() string {
	switch s {
	case ListServiceAccountKeysRequest_FieldPathSelectorParent:
		return "parent"
	case ListServiceAccountKeysRequest_FieldPathSelectorPageSize:
		return "page_size"
	case ListServiceAccountKeysRequest_FieldPathSelectorPageToken:
		return "page_token"
	case ListServiceAccountKeysRequest_FieldPathSelectorOrderBy:
		return "order_by"
	case ListServiceAccountKeysRequest_FieldPathSelectorFilter:
		return "filter"
	case ListServiceAccountKeysRequest_FieldPathSelectorFieldMask:
		return "field_mask"
	case ListServiceAccountKeysRequest_FieldPathSelectorView:
		return "view"
	case ListServiceAccountKeysRequest_FieldPathSelectorIncludePagingInfo:
		return "include_paging_info"
	default:
		panic(fmt.Sprintf("Invalid selector for ListServiceAccountKeysRequest: %d", s))
	}
}

func BuildListServiceAccountKeysRequest_FieldPath(fp gotenobject.RawFieldPath) (ListServiceAccountKeysRequest_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object ListServiceAccountKeysRequest")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "parent":
			return &ListServiceAccountKeysRequest_FieldTerminalPath{selector: ListServiceAccountKeysRequest_FieldPathSelectorParent}, nil
		case "page_size", "pageSize", "page-size":
			return &ListServiceAccountKeysRequest_FieldTerminalPath{selector: ListServiceAccountKeysRequest_FieldPathSelectorPageSize}, nil
		case "page_token", "pageToken", "page-token":
			return &ListServiceAccountKeysRequest_FieldTerminalPath{selector: ListServiceAccountKeysRequest_FieldPathSelectorPageToken}, nil
		case "order_by", "orderBy", "order-by":
			return &ListServiceAccountKeysRequest_FieldTerminalPath{selector: ListServiceAccountKeysRequest_FieldPathSelectorOrderBy}, nil
		case "filter":
			return &ListServiceAccountKeysRequest_FieldTerminalPath{selector: ListServiceAccountKeysRequest_FieldPathSelectorFilter}, nil
		case "field_mask", "fieldMask", "field-mask":
			return &ListServiceAccountKeysRequest_FieldTerminalPath{selector: ListServiceAccountKeysRequest_FieldPathSelectorFieldMask}, nil
		case "view":
			return &ListServiceAccountKeysRequest_FieldTerminalPath{selector: ListServiceAccountKeysRequest_FieldPathSelectorView}, nil
		case "include_paging_info", "includePagingInfo", "include-paging-info":
			return &ListServiceAccountKeysRequest_FieldTerminalPath{selector: ListServiceAccountKeysRequest_FieldPathSelectorIncludePagingInfo}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object ListServiceAccountKeysRequest", fp)
}

func ParseListServiceAccountKeysRequest_FieldPath(rawField string) (ListServiceAccountKeysRequest_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildListServiceAccountKeysRequest_FieldPath(fp)
}

func MustParseListServiceAccountKeysRequest_FieldPath(rawField string) ListServiceAccountKeysRequest_FieldPath {
	fp, err := ParseListServiceAccountKeysRequest_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type ListServiceAccountKeysRequest_FieldTerminalPath struct {
	selector ListServiceAccountKeysRequest_FieldPathSelector
}

var _ ListServiceAccountKeysRequest_FieldPath = (*ListServiceAccountKeysRequest_FieldTerminalPath)(nil)

func (fp *ListServiceAccountKeysRequest_FieldTerminalPath) Selector() ListServiceAccountKeysRequest_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source ListServiceAccountKeysRequest
func (fp *ListServiceAccountKeysRequest_FieldTerminalPath) Get(source *ListServiceAccountKeysRequest) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case ListServiceAccountKeysRequest_FieldPathSelectorParent:
			if source.Parent != nil {
				values = append(values, source.Parent)
			}
		case ListServiceAccountKeysRequest_FieldPathSelectorPageSize:
			values = append(values, source.PageSize)
		case ListServiceAccountKeysRequest_FieldPathSelectorPageToken:
			if source.PageToken != nil {
				values = append(values, source.PageToken)
			}
		case ListServiceAccountKeysRequest_FieldPathSelectorOrderBy:
			if source.OrderBy != nil {
				values = append(values, source.OrderBy)
			}
		case ListServiceAccountKeysRequest_FieldPathSelectorFilter:
			if source.Filter != nil {
				values = append(values, source.Filter)
			}
		case ListServiceAccountKeysRequest_FieldPathSelectorFieldMask:
			if source.FieldMask != nil {
				values = append(values, source.FieldMask)
			}
		case ListServiceAccountKeysRequest_FieldPathSelectorView:
			values = append(values, source.View)
		case ListServiceAccountKeysRequest_FieldPathSelectorIncludePagingInfo:
			values = append(values, source.IncludePagingInfo)
		default:
			panic(fmt.Sprintf("Invalid selector for ListServiceAccountKeysRequest: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source ListServiceAccountKeysRequest
func (fp *ListServiceAccountKeysRequest_FieldTerminalPath) GetSingle(source *ListServiceAccountKeysRequest) (interface{}, bool) {
	switch fp.selector {
	case ListServiceAccountKeysRequest_FieldPathSelectorParent:
		res := source.GetParent()
		return res, res != nil
	case ListServiceAccountKeysRequest_FieldPathSelectorPageSize:
		return source.GetPageSize(), source != nil
	case ListServiceAccountKeysRequest_FieldPathSelectorPageToken:
		res := source.GetPageToken()
		return res, res != nil
	case ListServiceAccountKeysRequest_FieldPathSelectorOrderBy:
		res := source.GetOrderBy()
		return res, res != nil
	case ListServiceAccountKeysRequest_FieldPathSelectorFilter:
		res := source.GetFilter()
		return res, res != nil
	case ListServiceAccountKeysRequest_FieldPathSelectorFieldMask:
		res := source.GetFieldMask()
		return res, res != nil
	case ListServiceAccountKeysRequest_FieldPathSelectorView:
		return source.GetView(), source != nil
	case ListServiceAccountKeysRequest_FieldPathSelectorIncludePagingInfo:
		return source.GetIncludePagingInfo(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for ListServiceAccountKeysRequest: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *ListServiceAccountKeysRequest_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case ListServiceAccountKeysRequest_FieldPathSelectorParent:
		return (*service_account_key.ParentName)(nil)
	case ListServiceAccountKeysRequest_FieldPathSelectorPageSize:
		return int32(0)
	case ListServiceAccountKeysRequest_FieldPathSelectorPageToken:
		return (*service_account_key.PagerCursor)(nil)
	case ListServiceAccountKeysRequest_FieldPathSelectorOrderBy:
		return (*service_account_key.OrderBy)(nil)
	case ListServiceAccountKeysRequest_FieldPathSelectorFilter:
		return (*service_account_key.Filter)(nil)
	case ListServiceAccountKeysRequest_FieldPathSelectorFieldMask:
		return (*service_account_key.ServiceAccountKey_FieldMask)(nil)
	case ListServiceAccountKeysRequest_FieldPathSelectorView:
		return view.View_UNSPECIFIED
	case ListServiceAccountKeysRequest_FieldPathSelectorIncludePagingInfo:
		return false
	default:
		panic(fmt.Sprintf("Invalid selector for ListServiceAccountKeysRequest: %d", fp.selector))
	}
}

func (fp *ListServiceAccountKeysRequest_FieldTerminalPath) ClearValue(item *ListServiceAccountKeysRequest) {
	if item != nil {
		switch fp.selector {
		case ListServiceAccountKeysRequest_FieldPathSelectorParent:
			item.Parent = nil
		case ListServiceAccountKeysRequest_FieldPathSelectorPageSize:
			item.PageSize = int32(0)
		case ListServiceAccountKeysRequest_FieldPathSelectorPageToken:
			item.PageToken = nil
		case ListServiceAccountKeysRequest_FieldPathSelectorOrderBy:
			item.OrderBy = nil
		case ListServiceAccountKeysRequest_FieldPathSelectorFilter:
			item.Filter = nil
		case ListServiceAccountKeysRequest_FieldPathSelectorFieldMask:
			item.FieldMask = nil
		case ListServiceAccountKeysRequest_FieldPathSelectorView:
			item.View = view.View_UNSPECIFIED
		case ListServiceAccountKeysRequest_FieldPathSelectorIncludePagingInfo:
			item.IncludePagingInfo = false
		default:
			panic(fmt.Sprintf("Invalid selector for ListServiceAccountKeysRequest: %d", fp.selector))
		}
	}
}

func (fp *ListServiceAccountKeysRequest_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*ListServiceAccountKeysRequest))
}

// IsLeaf - whether field path is holds simple value
func (fp *ListServiceAccountKeysRequest_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == ListServiceAccountKeysRequest_FieldPathSelectorParent ||
		fp.selector == ListServiceAccountKeysRequest_FieldPathSelectorPageSize ||
		fp.selector == ListServiceAccountKeysRequest_FieldPathSelectorPageToken ||
		fp.selector == ListServiceAccountKeysRequest_FieldPathSelectorOrderBy ||
		fp.selector == ListServiceAccountKeysRequest_FieldPathSelectorFilter ||
		fp.selector == ListServiceAccountKeysRequest_FieldPathSelectorFieldMask ||
		fp.selector == ListServiceAccountKeysRequest_FieldPathSelectorView ||
		fp.selector == ListServiceAccountKeysRequest_FieldPathSelectorIncludePagingInfo
}

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

func (fp *ListServiceAccountKeysRequest_FieldTerminalPath) WithIValue(value interface{}) ListServiceAccountKeysRequest_FieldPathValue {
	switch fp.selector {
	case ListServiceAccountKeysRequest_FieldPathSelectorParent:
		return &ListServiceAccountKeysRequest_FieldTerminalPathValue{ListServiceAccountKeysRequest_FieldTerminalPath: *fp, value: value.(*service_account_key.ParentName)}
	case ListServiceAccountKeysRequest_FieldPathSelectorPageSize:
		return &ListServiceAccountKeysRequest_FieldTerminalPathValue{ListServiceAccountKeysRequest_FieldTerminalPath: *fp, value: value.(int32)}
	case ListServiceAccountKeysRequest_FieldPathSelectorPageToken:
		return &ListServiceAccountKeysRequest_FieldTerminalPathValue{ListServiceAccountKeysRequest_FieldTerminalPath: *fp, value: value.(*service_account_key.PagerCursor)}
	case ListServiceAccountKeysRequest_FieldPathSelectorOrderBy:
		return &ListServiceAccountKeysRequest_FieldTerminalPathValue{ListServiceAccountKeysRequest_FieldTerminalPath: *fp, value: value.(*service_account_key.OrderBy)}
	case ListServiceAccountKeysRequest_FieldPathSelectorFilter:
		return &ListServiceAccountKeysRequest_FieldTerminalPathValue{ListServiceAccountKeysRequest_FieldTerminalPath: *fp, value: value.(*service_account_key.Filter)}
	case ListServiceAccountKeysRequest_FieldPathSelectorFieldMask:
		return &ListServiceAccountKeysRequest_FieldTerminalPathValue{ListServiceAccountKeysRequest_FieldTerminalPath: *fp, value: value.(*service_account_key.ServiceAccountKey_FieldMask)}
	case ListServiceAccountKeysRequest_FieldPathSelectorView:
		return &ListServiceAccountKeysRequest_FieldTerminalPathValue{ListServiceAccountKeysRequest_FieldTerminalPath: *fp, value: value.(view.View)}
	case ListServiceAccountKeysRequest_FieldPathSelectorIncludePagingInfo:
		return &ListServiceAccountKeysRequest_FieldTerminalPathValue{ListServiceAccountKeysRequest_FieldTerminalPath: *fp, value: value.(bool)}
	default:
		panic(fmt.Sprintf("Invalid selector for ListServiceAccountKeysRequest: %d", fp.selector))
	}
}

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

func (fp *ListServiceAccountKeysRequest_FieldTerminalPath) WithIArrayOfValues(values interface{}) ListServiceAccountKeysRequest_FieldPathArrayOfValues {
	fpaov := &ListServiceAccountKeysRequest_FieldTerminalPathArrayOfValues{ListServiceAccountKeysRequest_FieldTerminalPath: *fp}
	switch fp.selector {
	case ListServiceAccountKeysRequest_FieldPathSelectorParent:
		return &ListServiceAccountKeysRequest_FieldTerminalPathArrayOfValues{ListServiceAccountKeysRequest_FieldTerminalPath: *fp, values: values.([]*service_account_key.ParentName)}
	case ListServiceAccountKeysRequest_FieldPathSelectorPageSize:
		return &ListServiceAccountKeysRequest_FieldTerminalPathArrayOfValues{ListServiceAccountKeysRequest_FieldTerminalPath: *fp, values: values.([]int32)}
	case ListServiceAccountKeysRequest_FieldPathSelectorPageToken:
		return &ListServiceAccountKeysRequest_FieldTerminalPathArrayOfValues{ListServiceAccountKeysRequest_FieldTerminalPath: *fp, values: values.([]*service_account_key.PagerCursor)}
	case ListServiceAccountKeysRequest_FieldPathSelectorOrderBy:
		return &ListServiceAccountKeysRequest_FieldTerminalPathArrayOfValues{ListServiceAccountKeysRequest_FieldTerminalPath: *fp, values: values.([]*service_account_key.OrderBy)}
	case ListServiceAccountKeysRequest_FieldPathSelectorFilter:
		return &ListServiceAccountKeysRequest_FieldTerminalPathArrayOfValues{ListServiceAccountKeysRequest_FieldTerminalPath: *fp, values: values.([]*service_account_key.Filter)}
	case ListServiceAccountKeysRequest_FieldPathSelectorFieldMask:
		return &ListServiceAccountKeysRequest_FieldTerminalPathArrayOfValues{ListServiceAccountKeysRequest_FieldTerminalPath: *fp, values: values.([]*service_account_key.ServiceAccountKey_FieldMask)}
	case ListServiceAccountKeysRequest_FieldPathSelectorView:
		return &ListServiceAccountKeysRequest_FieldTerminalPathArrayOfValues{ListServiceAccountKeysRequest_FieldTerminalPath: *fp, values: values.([]view.View)}
	case ListServiceAccountKeysRequest_FieldPathSelectorIncludePagingInfo:
		return &ListServiceAccountKeysRequest_FieldTerminalPathArrayOfValues{ListServiceAccountKeysRequest_FieldTerminalPath: *fp, values: values.([]bool)}
	default:
		panic(fmt.Sprintf("Invalid selector for ListServiceAccountKeysRequest: %d", fp.selector))
	}
	return fpaov
}

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

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

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

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

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

func MustParseListServiceAccountKeysRequest_FieldPathValue(pathStr, valueStr string) ListServiceAccountKeysRequest_FieldPathValue {
	fpv, err := ParseListServiceAccountKeysRequest_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type ListServiceAccountKeysRequest_FieldTerminalPathValue struct {
	ListServiceAccountKeysRequest_FieldTerminalPath
	value interface{}
}

var _ ListServiceAccountKeysRequest_FieldPathValue = (*ListServiceAccountKeysRequest_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'ListServiceAccountKeysRequest' as interface{}
func (fpv *ListServiceAccountKeysRequest_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *ListServiceAccountKeysRequest_FieldTerminalPathValue) AsParentValue() (*service_account_key.ParentName, bool) {
	res, ok := fpv.value.(*service_account_key.ParentName)
	return res, ok
}
func (fpv *ListServiceAccountKeysRequest_FieldTerminalPathValue) AsPageSizeValue() (int32, bool) {
	res, ok := fpv.value.(int32)
	return res, ok
}
func (fpv *ListServiceAccountKeysRequest_FieldTerminalPathValue) AsPageTokenValue() (*service_account_key.PagerCursor, bool) {
	res, ok := fpv.value.(*service_account_key.PagerCursor)
	return res, ok
}
func (fpv *ListServiceAccountKeysRequest_FieldTerminalPathValue) AsOrderByValue() (*service_account_key.OrderBy, bool) {
	res, ok := fpv.value.(*service_account_key.OrderBy)
	return res, ok
}
func (fpv *ListServiceAccountKeysRequest_FieldTerminalPathValue) AsFilterValue() (*service_account_key.Filter, bool) {
	res, ok := fpv.value.(*service_account_key.Filter)
	return res, ok
}
func (fpv *ListServiceAccountKeysRequest_FieldTerminalPathValue) AsFieldMaskValue() (*service_account_key.ServiceAccountKey_FieldMask, bool) {
	res, ok := fpv.value.(*service_account_key.ServiceAccountKey_FieldMask)
	return res, ok
}
func (fpv *ListServiceAccountKeysRequest_FieldTerminalPathValue) AsViewValue() (view.View, bool) {
	res, ok := fpv.value.(view.View)
	return res, ok
}
func (fpv *ListServiceAccountKeysRequest_FieldTerminalPathValue) AsIncludePagingInfoValue() (bool, bool) {
	res, ok := fpv.value.(bool)
	return res, ok
}

// SetTo stores value for selected field for object ListServiceAccountKeysRequest
func (fpv *ListServiceAccountKeysRequest_FieldTerminalPathValue) SetTo(target **ListServiceAccountKeysRequest) {
	if *target == nil {
		*target = new(ListServiceAccountKeysRequest)
	}
	switch fpv.selector {
	case ListServiceAccountKeysRequest_FieldPathSelectorParent:
		(*target).Parent = fpv.value.(*service_account_key.ParentName)
	case ListServiceAccountKeysRequest_FieldPathSelectorPageSize:
		(*target).PageSize = fpv.value.(int32)
	case ListServiceAccountKeysRequest_FieldPathSelectorPageToken:
		(*target).PageToken = fpv.value.(*service_account_key.PagerCursor)
	case ListServiceAccountKeysRequest_FieldPathSelectorOrderBy:
		(*target).OrderBy = fpv.value.(*service_account_key.OrderBy)
	case ListServiceAccountKeysRequest_FieldPathSelectorFilter:
		(*target).Filter = fpv.value.(*service_account_key.Filter)
	case ListServiceAccountKeysRequest_FieldPathSelectorFieldMask:
		(*target).FieldMask = fpv.value.(*service_account_key.ServiceAccountKey_FieldMask)
	case ListServiceAccountKeysRequest_FieldPathSelectorView:
		(*target).View = fpv.value.(view.View)
	case ListServiceAccountKeysRequest_FieldPathSelectorIncludePagingInfo:
		(*target).IncludePagingInfo = fpv.value.(bool)
	default:
		panic(fmt.Sprintf("Invalid selector for ListServiceAccountKeysRequest: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'ListServiceAccountKeysRequest_FieldTerminalPathValue' with the value under path in 'ListServiceAccountKeysRequest'.
func (fpv *ListServiceAccountKeysRequest_FieldTerminalPathValue) CompareWith(source *ListServiceAccountKeysRequest) (int, bool) {
	switch fpv.selector {
	case ListServiceAccountKeysRequest_FieldPathSelectorParent:
		leftValue := fpv.value.(*service_account_key.ParentName)
		rightValue := source.GetParent()
		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 ListServiceAccountKeysRequest_FieldPathSelectorPageSize:
		leftValue := fpv.value.(int32)
		rightValue := source.GetPageSize()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case ListServiceAccountKeysRequest_FieldPathSelectorPageToken:
		return 0, false
	case ListServiceAccountKeysRequest_FieldPathSelectorOrderBy:
		return 0, false
	case ListServiceAccountKeysRequest_FieldPathSelectorFilter:
		return 0, false
	case ListServiceAccountKeysRequest_FieldPathSelectorFieldMask:
		return 0, false
	case ListServiceAccountKeysRequest_FieldPathSelectorView:
		leftValue := fpv.value.(view.View)
		rightValue := source.GetView()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case ListServiceAccountKeysRequest_FieldPathSelectorIncludePagingInfo:
		leftValue := fpv.value.(bool)
		rightValue := source.GetIncludePagingInfo()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if !(leftValue) && (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for ListServiceAccountKeysRequest: %d", fpv.selector))
	}
}

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

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

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

func MustParseListServiceAccountKeysRequest_FieldPathArrayItemValue(pathStr, valueStr string) ListServiceAccountKeysRequest_FieldPathArrayItemValue {
	fpaiv, err := ParseListServiceAccountKeysRequest_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type ListServiceAccountKeysRequest_FieldTerminalPathArrayItemValue struct {
	ListServiceAccountKeysRequest_FieldTerminalPath
	value interface{}
}

var _ ListServiceAccountKeysRequest_FieldPathArrayItemValue = (*ListServiceAccountKeysRequest_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *ListServiceAccountKeysRequest_FieldTerminalPathArrayItemValue) GetSingle(source *ListServiceAccountKeysRequest) (interface{}, bool) {
	return nil, false
}

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

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

// ListServiceAccountKeysRequest_FieldPathArrayOfValues allows storing slice of values for ListServiceAccountKeysRequest fields according to their type
type ListServiceAccountKeysRequest_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	ListServiceAccountKeysRequest_FieldPath
}

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

func MustParseListServiceAccountKeysRequest_FieldPathArrayOfValues(pathStr, valuesStr string) ListServiceAccountKeysRequest_FieldPathArrayOfValues {
	fpaov, err := ParseListServiceAccountKeysRequest_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type ListServiceAccountKeysRequest_FieldTerminalPathArrayOfValues struct {
	ListServiceAccountKeysRequest_FieldTerminalPath
	values interface{}
}

var _ ListServiceAccountKeysRequest_FieldPathArrayOfValues = (*ListServiceAccountKeysRequest_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *ListServiceAccountKeysRequest_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case ListServiceAccountKeysRequest_FieldPathSelectorParent:
		for _, v := range fpaov.values.([]*service_account_key.ParentName) {
			values = append(values, v)
		}
	case ListServiceAccountKeysRequest_FieldPathSelectorPageSize:
		for _, v := range fpaov.values.([]int32) {
			values = append(values, v)
		}
	case ListServiceAccountKeysRequest_FieldPathSelectorPageToken:
		for _, v := range fpaov.values.([]*service_account_key.PagerCursor) {
			values = append(values, v)
		}
	case ListServiceAccountKeysRequest_FieldPathSelectorOrderBy:
		for _, v := range fpaov.values.([]*service_account_key.OrderBy) {
			values = append(values, v)
		}
	case ListServiceAccountKeysRequest_FieldPathSelectorFilter:
		for _, v := range fpaov.values.([]*service_account_key.Filter) {
			values = append(values, v)
		}
	case ListServiceAccountKeysRequest_FieldPathSelectorFieldMask:
		for _, v := range fpaov.values.([]*service_account_key.ServiceAccountKey_FieldMask) {
			values = append(values, v)
		}
	case ListServiceAccountKeysRequest_FieldPathSelectorView:
		for _, v := range fpaov.values.([]view.View) {
			values = append(values, v)
		}
	case ListServiceAccountKeysRequest_FieldPathSelectorIncludePagingInfo:
		for _, v := range fpaov.values.([]bool) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *ListServiceAccountKeysRequest_FieldTerminalPathArrayOfValues) AsParentArrayOfValues() ([]*service_account_key.ParentName, bool) {
	res, ok := fpaov.values.([]*service_account_key.ParentName)
	return res, ok
}
func (fpaov *ListServiceAccountKeysRequest_FieldTerminalPathArrayOfValues) AsPageSizeArrayOfValues() ([]int32, bool) {
	res, ok := fpaov.values.([]int32)
	return res, ok
}
func (fpaov *ListServiceAccountKeysRequest_FieldTerminalPathArrayOfValues) AsPageTokenArrayOfValues() ([]*service_account_key.PagerCursor, bool) {
	res, ok := fpaov.values.([]*service_account_key.PagerCursor)
	return res, ok
}
func (fpaov *ListServiceAccountKeysRequest_FieldTerminalPathArrayOfValues) AsOrderByArrayOfValues() ([]*service_account_key.OrderBy, bool) {
	res, ok := fpaov.values.([]*service_account_key.OrderBy)
	return res, ok
}
func (fpaov *ListServiceAccountKeysRequest_FieldTerminalPathArrayOfValues) AsFilterArrayOfValues() ([]*service_account_key.Filter, bool) {
	res, ok := fpaov.values.([]*service_account_key.Filter)
	return res, ok
}
func (fpaov *ListServiceAccountKeysRequest_FieldTerminalPathArrayOfValues) AsFieldMaskArrayOfValues() ([]*service_account_key.ServiceAccountKey_FieldMask, bool) {
	res, ok := fpaov.values.([]*service_account_key.ServiceAccountKey_FieldMask)
	return res, ok
}
func (fpaov *ListServiceAccountKeysRequest_FieldTerminalPathArrayOfValues) AsViewArrayOfValues() ([]view.View, bool) {
	res, ok := fpaov.values.([]view.View)
	return res, ok
}
func (fpaov *ListServiceAccountKeysRequest_FieldTerminalPathArrayOfValues) AsIncludePagingInfoArrayOfValues() ([]bool, bool) {
	res, ok := fpaov.values.([]bool)
	return res, ok
}

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

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

type ListServiceAccountKeysResponse_FieldPathSelector int32

const (
	ListServiceAccountKeysResponse_FieldPathSelectorServiceAccountKeys ListServiceAccountKeysResponse_FieldPathSelector = 0
	ListServiceAccountKeysResponse_FieldPathSelectorPrevPageToken      ListServiceAccountKeysResponse_FieldPathSelector = 1
	ListServiceAccountKeysResponse_FieldPathSelectorNextPageToken      ListServiceAccountKeysResponse_FieldPathSelector = 2
	ListServiceAccountKeysResponse_FieldPathSelectorCurrentOffset      ListServiceAccountKeysResponse_FieldPathSelector = 3
	ListServiceAccountKeysResponse_FieldPathSelectorTotalResultsCount  ListServiceAccountKeysResponse_FieldPathSelector = 4
)

func (s ListServiceAccountKeysResponse_FieldPathSelector) String() string {
	switch s {
	case ListServiceAccountKeysResponse_FieldPathSelectorServiceAccountKeys:
		return "service_account_keys"
	case ListServiceAccountKeysResponse_FieldPathSelectorPrevPageToken:
		return "prev_page_token"
	case ListServiceAccountKeysResponse_FieldPathSelectorNextPageToken:
		return "next_page_token"
	case ListServiceAccountKeysResponse_FieldPathSelectorCurrentOffset:
		return "current_offset"
	case ListServiceAccountKeysResponse_FieldPathSelectorTotalResultsCount:
		return "total_results_count"
	default:
		panic(fmt.Sprintf("Invalid selector for ListServiceAccountKeysResponse: %d", s))
	}
}

func BuildListServiceAccountKeysResponse_FieldPath(fp gotenobject.RawFieldPath) (ListServiceAccountKeysResponse_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object ListServiceAccountKeysResponse")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "service_account_keys", "serviceAccountKeys", "service-account-keys":
			return &ListServiceAccountKeysResponse_FieldTerminalPath{selector: ListServiceAccountKeysResponse_FieldPathSelectorServiceAccountKeys}, nil
		case "prev_page_token", "prevPageToken", "prev-page-token":
			return &ListServiceAccountKeysResponse_FieldTerminalPath{selector: ListServiceAccountKeysResponse_FieldPathSelectorPrevPageToken}, nil
		case "next_page_token", "nextPageToken", "next-page-token":
			return &ListServiceAccountKeysResponse_FieldTerminalPath{selector: ListServiceAccountKeysResponse_FieldPathSelectorNextPageToken}, nil
		case "current_offset", "currentOffset", "current-offset":
			return &ListServiceAccountKeysResponse_FieldTerminalPath{selector: ListServiceAccountKeysResponse_FieldPathSelectorCurrentOffset}, nil
		case "total_results_count", "totalResultsCount", "total-results-count":
			return &ListServiceAccountKeysResponse_FieldTerminalPath{selector: ListServiceAccountKeysResponse_FieldPathSelectorTotalResultsCount}, nil
		}
	} else {
		switch fp[0] {
		case "service_account_keys", "serviceAccountKeys", "service-account-keys":
			if subpath, err := service_account_key.BuildServiceAccountKey_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &ListServiceAccountKeysResponse_FieldSubPath{selector: ListServiceAccountKeysResponse_FieldPathSelectorServiceAccountKeys, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object ListServiceAccountKeysResponse", fp)
}

func ParseListServiceAccountKeysResponse_FieldPath(rawField string) (ListServiceAccountKeysResponse_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildListServiceAccountKeysResponse_FieldPath(fp)
}

func MustParseListServiceAccountKeysResponse_FieldPath(rawField string) ListServiceAccountKeysResponse_FieldPath {
	fp, err := ParseListServiceAccountKeysResponse_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type ListServiceAccountKeysResponse_FieldTerminalPath struct {
	selector ListServiceAccountKeysResponse_FieldPathSelector
}

var _ ListServiceAccountKeysResponse_FieldPath = (*ListServiceAccountKeysResponse_FieldTerminalPath)(nil)

func (fp *ListServiceAccountKeysResponse_FieldTerminalPath) Selector() ListServiceAccountKeysResponse_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source ListServiceAccountKeysResponse
func (fp *ListServiceAccountKeysResponse_FieldTerminalPath) Get(source *ListServiceAccountKeysResponse) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case ListServiceAccountKeysResponse_FieldPathSelectorServiceAccountKeys:
			for _, value := range source.GetServiceAccountKeys() {
				values = append(values, value)
			}
		case ListServiceAccountKeysResponse_FieldPathSelectorPrevPageToken:
			if source.PrevPageToken != nil {
				values = append(values, source.PrevPageToken)
			}
		case ListServiceAccountKeysResponse_FieldPathSelectorNextPageToken:
			if source.NextPageToken != nil {
				values = append(values, source.NextPageToken)
			}
		case ListServiceAccountKeysResponse_FieldPathSelectorCurrentOffset:
			values = append(values, source.CurrentOffset)
		case ListServiceAccountKeysResponse_FieldPathSelectorTotalResultsCount:
			values = append(values, source.TotalResultsCount)
		default:
			panic(fmt.Sprintf("Invalid selector for ListServiceAccountKeysResponse: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source ListServiceAccountKeysResponse
func (fp *ListServiceAccountKeysResponse_FieldTerminalPath) GetSingle(source *ListServiceAccountKeysResponse) (interface{}, bool) {
	switch fp.selector {
	case ListServiceAccountKeysResponse_FieldPathSelectorServiceAccountKeys:
		res := source.GetServiceAccountKeys()
		return res, res != nil
	case ListServiceAccountKeysResponse_FieldPathSelectorPrevPageToken:
		res := source.GetPrevPageToken()
		return res, res != nil
	case ListServiceAccountKeysResponse_FieldPathSelectorNextPageToken:
		res := source.GetNextPageToken()
		return res, res != nil
	case ListServiceAccountKeysResponse_FieldPathSelectorCurrentOffset:
		return source.GetCurrentOffset(), source != nil
	case ListServiceAccountKeysResponse_FieldPathSelectorTotalResultsCount:
		return source.GetTotalResultsCount(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for ListServiceAccountKeysResponse: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *ListServiceAccountKeysResponse_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case ListServiceAccountKeysResponse_FieldPathSelectorServiceAccountKeys:
		return ([]*service_account_key.ServiceAccountKey)(nil)
	case ListServiceAccountKeysResponse_FieldPathSelectorPrevPageToken:
		return (*service_account_key.PagerCursor)(nil)
	case ListServiceAccountKeysResponse_FieldPathSelectorNextPageToken:
		return (*service_account_key.PagerCursor)(nil)
	case ListServiceAccountKeysResponse_FieldPathSelectorCurrentOffset:
		return int32(0)
	case ListServiceAccountKeysResponse_FieldPathSelectorTotalResultsCount:
		return int32(0)
	default:
		panic(fmt.Sprintf("Invalid selector for ListServiceAccountKeysResponse: %d", fp.selector))
	}
}

func (fp *ListServiceAccountKeysResponse_FieldTerminalPath) ClearValue(item *ListServiceAccountKeysResponse) {
	if item != nil {
		switch fp.selector {
		case ListServiceAccountKeysResponse_FieldPathSelectorServiceAccountKeys:
			item.ServiceAccountKeys = nil
		case ListServiceAccountKeysResponse_FieldPathSelectorPrevPageToken:
			item.PrevPageToken = nil
		case ListServiceAccountKeysResponse_FieldPathSelectorNextPageToken:
			item.NextPageToken = nil
		case ListServiceAccountKeysResponse_FieldPathSelectorCurrentOffset:
			item.CurrentOffset = int32(0)
		case ListServiceAccountKeysResponse_FieldPathSelectorTotalResultsCount:
			item.TotalResultsCount = int32(0)
		default:
			panic(fmt.Sprintf("Invalid selector for ListServiceAccountKeysResponse: %d", fp.selector))
		}
	}
}

func (fp *ListServiceAccountKeysResponse_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*ListServiceAccountKeysResponse))
}

// IsLeaf - whether field path is holds simple value
func (fp *ListServiceAccountKeysResponse_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == ListServiceAccountKeysResponse_FieldPathSelectorPrevPageToken ||
		fp.selector == ListServiceAccountKeysResponse_FieldPathSelectorNextPageToken ||
		fp.selector == ListServiceAccountKeysResponse_FieldPathSelectorCurrentOffset ||
		fp.selector == ListServiceAccountKeysResponse_FieldPathSelectorTotalResultsCount
}

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

func (fp *ListServiceAccountKeysResponse_FieldTerminalPath) WithIValue(value interface{}) ListServiceAccountKeysResponse_FieldPathValue {
	switch fp.selector {
	case ListServiceAccountKeysResponse_FieldPathSelectorServiceAccountKeys:
		return &ListServiceAccountKeysResponse_FieldTerminalPathValue{ListServiceAccountKeysResponse_FieldTerminalPath: *fp, value: value.([]*service_account_key.ServiceAccountKey)}
	case ListServiceAccountKeysResponse_FieldPathSelectorPrevPageToken:
		return &ListServiceAccountKeysResponse_FieldTerminalPathValue{ListServiceAccountKeysResponse_FieldTerminalPath: *fp, value: value.(*service_account_key.PagerCursor)}
	case ListServiceAccountKeysResponse_FieldPathSelectorNextPageToken:
		return &ListServiceAccountKeysResponse_FieldTerminalPathValue{ListServiceAccountKeysResponse_FieldTerminalPath: *fp, value: value.(*service_account_key.PagerCursor)}
	case ListServiceAccountKeysResponse_FieldPathSelectorCurrentOffset:
		return &ListServiceAccountKeysResponse_FieldTerminalPathValue{ListServiceAccountKeysResponse_FieldTerminalPath: *fp, value: value.(int32)}
	case ListServiceAccountKeysResponse_FieldPathSelectorTotalResultsCount:
		return &ListServiceAccountKeysResponse_FieldTerminalPathValue{ListServiceAccountKeysResponse_FieldTerminalPath: *fp, value: value.(int32)}
	default:
		panic(fmt.Sprintf("Invalid selector for ListServiceAccountKeysResponse: %d", fp.selector))
	}
}

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

func (fp *ListServiceAccountKeysResponse_FieldTerminalPath) WithIArrayOfValues(values interface{}) ListServiceAccountKeysResponse_FieldPathArrayOfValues {
	fpaov := &ListServiceAccountKeysResponse_FieldTerminalPathArrayOfValues{ListServiceAccountKeysResponse_FieldTerminalPath: *fp}
	switch fp.selector {
	case ListServiceAccountKeysResponse_FieldPathSelectorServiceAccountKeys:
		return &ListServiceAccountKeysResponse_FieldTerminalPathArrayOfValues{ListServiceAccountKeysResponse_FieldTerminalPath: *fp, values: values.([][]*service_account_key.ServiceAccountKey)}
	case ListServiceAccountKeysResponse_FieldPathSelectorPrevPageToken:
		return &ListServiceAccountKeysResponse_FieldTerminalPathArrayOfValues{ListServiceAccountKeysResponse_FieldTerminalPath: *fp, values: values.([]*service_account_key.PagerCursor)}
	case ListServiceAccountKeysResponse_FieldPathSelectorNextPageToken:
		return &ListServiceAccountKeysResponse_FieldTerminalPathArrayOfValues{ListServiceAccountKeysResponse_FieldTerminalPath: *fp, values: values.([]*service_account_key.PagerCursor)}
	case ListServiceAccountKeysResponse_FieldPathSelectorCurrentOffset:
		return &ListServiceAccountKeysResponse_FieldTerminalPathArrayOfValues{ListServiceAccountKeysResponse_FieldTerminalPath: *fp, values: values.([]int32)}
	case ListServiceAccountKeysResponse_FieldPathSelectorTotalResultsCount:
		return &ListServiceAccountKeysResponse_FieldTerminalPathArrayOfValues{ListServiceAccountKeysResponse_FieldTerminalPath: *fp, values: values.([]int32)}
	default:
		panic(fmt.Sprintf("Invalid selector for ListServiceAccountKeysResponse: %d", fp.selector))
	}
	return fpaov
}

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

func (fp *ListServiceAccountKeysResponse_FieldTerminalPath) WithIArrayItemValue(value interface{}) ListServiceAccountKeysResponse_FieldPathArrayItemValue {
	switch fp.selector {
	case ListServiceAccountKeysResponse_FieldPathSelectorServiceAccountKeys:
		return &ListServiceAccountKeysResponse_FieldTerminalPathArrayItemValue{ListServiceAccountKeysResponse_FieldTerminalPath: *fp, value: value.(*service_account_key.ServiceAccountKey)}
	default:
		panic(fmt.Sprintf("Invalid selector for ListServiceAccountKeysResponse: %d", fp.selector))
	}
}

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

type ListServiceAccountKeysResponse_FieldSubPath struct {
	selector ListServiceAccountKeysResponse_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ ListServiceAccountKeysResponse_FieldPath = (*ListServiceAccountKeysResponse_FieldSubPath)(nil)

func (fps *ListServiceAccountKeysResponse_FieldSubPath) Selector() ListServiceAccountKeysResponse_FieldPathSelector {
	return fps.selector
}
func (fps *ListServiceAccountKeysResponse_FieldSubPath) AsServiceAccountKeysSubPath() (service_account_key.ServiceAccountKey_FieldPath, bool) {
	res, ok := fps.subPath.(service_account_key.ServiceAccountKey_FieldPath)
	return res, ok
}

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

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

// Get returns all values pointed by selected field from source ListServiceAccountKeysResponse
func (fps *ListServiceAccountKeysResponse_FieldSubPath) Get(source *ListServiceAccountKeysResponse) (values []interface{}) {
	switch fps.selector {
	case ListServiceAccountKeysResponse_FieldPathSelectorServiceAccountKeys:
		for _, item := range source.GetServiceAccountKeys() {
			values = append(values, fps.subPath.GetRaw(item)...)
		}
	default:
		panic(fmt.Sprintf("Invalid selector for ListServiceAccountKeysResponse: %d", fps.selector))
	}
	return
}

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

// GetSingle returns value of selected field from source ListServiceAccountKeysResponse
func (fps *ListServiceAccountKeysResponse_FieldSubPath) GetSingle(source *ListServiceAccountKeysResponse) (interface{}, bool) {
	switch fps.selector {
	case ListServiceAccountKeysResponse_FieldPathSelectorServiceAccountKeys:
		if len(source.GetServiceAccountKeys()) == 0 {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetServiceAccountKeys()[0])
	default:
		panic(fmt.Sprintf("Invalid selector for ListServiceAccountKeysResponse: %d", fps.selector))
	}
}

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

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

func (fps *ListServiceAccountKeysResponse_FieldSubPath) ClearValue(item *ListServiceAccountKeysResponse) {
	if item != nil {
		switch fps.selector {
		case ListServiceAccountKeysResponse_FieldPathSelectorServiceAccountKeys:
			for _, subItem := range item.ServiceAccountKeys {
				fps.subPath.ClearValueRaw(subItem)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for ListServiceAccountKeysResponse: %d", fps.selector))
		}
	}
}

func (fps *ListServiceAccountKeysResponse_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*ListServiceAccountKeysResponse))
}

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

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

func (fps *ListServiceAccountKeysResponse_FieldSubPath) WithIValue(value interface{}) ListServiceAccountKeysResponse_FieldPathValue {
	return &ListServiceAccountKeysResponse_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *ListServiceAccountKeysResponse_FieldSubPath) WithIArrayOfValues(values interface{}) ListServiceAccountKeysResponse_FieldPathArrayOfValues {
	return &ListServiceAccountKeysResponse_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *ListServiceAccountKeysResponse_FieldSubPath) WithIArrayItemValue(value interface{}) ListServiceAccountKeysResponse_FieldPathArrayItemValue {
	return &ListServiceAccountKeysResponse_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

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

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

func MustParseListServiceAccountKeysResponse_FieldPathValue(pathStr, valueStr string) ListServiceAccountKeysResponse_FieldPathValue {
	fpv, err := ParseListServiceAccountKeysResponse_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type ListServiceAccountKeysResponse_FieldTerminalPathValue struct {
	ListServiceAccountKeysResponse_FieldTerminalPath
	value interface{}
}

var _ ListServiceAccountKeysResponse_FieldPathValue = (*ListServiceAccountKeysResponse_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'ListServiceAccountKeysResponse' as interface{}
func (fpv *ListServiceAccountKeysResponse_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *ListServiceAccountKeysResponse_FieldTerminalPathValue) AsServiceAccountKeysValue() ([]*service_account_key.ServiceAccountKey, bool) {
	res, ok := fpv.value.([]*service_account_key.ServiceAccountKey)
	return res, ok
}
func (fpv *ListServiceAccountKeysResponse_FieldTerminalPathValue) AsPrevPageTokenValue() (*service_account_key.PagerCursor, bool) {
	res, ok := fpv.value.(*service_account_key.PagerCursor)
	return res, ok
}
func (fpv *ListServiceAccountKeysResponse_FieldTerminalPathValue) AsNextPageTokenValue() (*service_account_key.PagerCursor, bool) {
	res, ok := fpv.value.(*service_account_key.PagerCursor)
	return res, ok
}
func (fpv *ListServiceAccountKeysResponse_FieldTerminalPathValue) AsCurrentOffsetValue() (int32, bool) {
	res, ok := fpv.value.(int32)
	return res, ok
}
func (fpv *ListServiceAccountKeysResponse_FieldTerminalPathValue) AsTotalResultsCountValue() (int32, bool) {
	res, ok := fpv.value.(int32)
	return res, ok
}

// SetTo stores value for selected field for object ListServiceAccountKeysResponse
func (fpv *ListServiceAccountKeysResponse_FieldTerminalPathValue) SetTo(target **ListServiceAccountKeysResponse) {
	if *target == nil {
		*target = new(ListServiceAccountKeysResponse)
	}
	switch fpv.selector {
	case ListServiceAccountKeysResponse_FieldPathSelectorServiceAccountKeys:
		(*target).ServiceAccountKeys = fpv.value.([]*service_account_key.ServiceAccountKey)
	case ListServiceAccountKeysResponse_FieldPathSelectorPrevPageToken:
		(*target).PrevPageToken = fpv.value.(*service_account_key.PagerCursor)
	case ListServiceAccountKeysResponse_FieldPathSelectorNextPageToken:
		(*target).NextPageToken = fpv.value.(*service_account_key.PagerCursor)
	case ListServiceAccountKeysResponse_FieldPathSelectorCurrentOffset:
		(*target).CurrentOffset = fpv.value.(int32)
	case ListServiceAccountKeysResponse_FieldPathSelectorTotalResultsCount:
		(*target).TotalResultsCount = fpv.value.(int32)
	default:
		panic(fmt.Sprintf("Invalid selector for ListServiceAccountKeysResponse: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'ListServiceAccountKeysResponse_FieldTerminalPathValue' with the value under path in 'ListServiceAccountKeysResponse'.
func (fpv *ListServiceAccountKeysResponse_FieldTerminalPathValue) CompareWith(source *ListServiceAccountKeysResponse) (int, bool) {
	switch fpv.selector {
	case ListServiceAccountKeysResponse_FieldPathSelectorServiceAccountKeys:
		return 0, false
	case ListServiceAccountKeysResponse_FieldPathSelectorPrevPageToken:
		return 0, false
	case ListServiceAccountKeysResponse_FieldPathSelectorNextPageToken:
		return 0, false
	case ListServiceAccountKeysResponse_FieldPathSelectorCurrentOffset:
		leftValue := fpv.value.(int32)
		rightValue := source.GetCurrentOffset()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case ListServiceAccountKeysResponse_FieldPathSelectorTotalResultsCount:
		leftValue := fpv.value.(int32)
		rightValue := source.GetTotalResultsCount()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for ListServiceAccountKeysResponse: %d", fpv.selector))
	}
}

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

type ListServiceAccountKeysResponse_FieldSubPathValue struct {
	ListServiceAccountKeysResponse_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ ListServiceAccountKeysResponse_FieldPathValue = (*ListServiceAccountKeysResponse_FieldSubPathValue)(nil)

func (fpvs *ListServiceAccountKeysResponse_FieldSubPathValue) AsServiceAccountKeysPathValue() (service_account_key.ServiceAccountKey_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(service_account_key.ServiceAccountKey_FieldPathValue)
	return res, ok
}

func (fpvs *ListServiceAccountKeysResponse_FieldSubPathValue) SetTo(target **ListServiceAccountKeysResponse) {
	if *target == nil {
		*target = new(ListServiceAccountKeysResponse)
	}
	switch fpvs.Selector() {
	case ListServiceAccountKeysResponse_FieldPathSelectorServiceAccountKeys:
		panic("FieldPath setter is unsupported for array subpaths")
	default:
		panic(fmt.Sprintf("Invalid selector for ListServiceAccountKeysResponse: %d", fpvs.Selector()))
	}
}

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

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

func (fpvs *ListServiceAccountKeysResponse_FieldSubPathValue) CompareWith(source *ListServiceAccountKeysResponse) (int, bool) {
	switch fpvs.Selector() {
	case ListServiceAccountKeysResponse_FieldPathSelectorServiceAccountKeys:
		return 0, false // repeated field
	default:
		panic(fmt.Sprintf("Invalid selector for ListServiceAccountKeysResponse: %d", fpvs.Selector()))
	}
}

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

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

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

func MustParseListServiceAccountKeysResponse_FieldPathArrayItemValue(pathStr, valueStr string) ListServiceAccountKeysResponse_FieldPathArrayItemValue {
	fpaiv, err := ParseListServiceAccountKeysResponse_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type ListServiceAccountKeysResponse_FieldTerminalPathArrayItemValue struct {
	ListServiceAccountKeysResponse_FieldTerminalPath
	value interface{}
}

var _ ListServiceAccountKeysResponse_FieldPathArrayItemValue = (*ListServiceAccountKeysResponse_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object ListServiceAccountKeysResponse as interface{}
func (fpaiv *ListServiceAccountKeysResponse_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}
func (fpaiv *ListServiceAccountKeysResponse_FieldTerminalPathArrayItemValue) AsServiceAccountKeysItemValue() (*service_account_key.ServiceAccountKey, bool) {
	res, ok := fpaiv.value.(*service_account_key.ServiceAccountKey)
	return res, ok
}

func (fpaiv *ListServiceAccountKeysResponse_FieldTerminalPathArrayItemValue) GetSingle(source *ListServiceAccountKeysResponse) (interface{}, bool) {
	return nil, false
}

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

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

// GetRawValue returns stored array item value
func (fpaivs *ListServiceAccountKeysResponse_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *ListServiceAccountKeysResponse_FieldSubPathArrayItemValue) AsServiceAccountKeysPathItemValue() (service_account_key.ServiceAccountKey_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(service_account_key.ServiceAccountKey_FieldPathArrayItemValue)
	return res, ok
}

// Contains returns a boolean indicating if value that is being held is present in given 'ListServiceAccountKeysResponse'
func (fpaivs *ListServiceAccountKeysResponse_FieldSubPathArrayItemValue) ContainsValue(source *ListServiceAccountKeysResponse) bool {
	switch fpaivs.Selector() {
	case ListServiceAccountKeysResponse_FieldPathSelectorServiceAccountKeys:
		return false // repeated/map field
	default:
		panic(fmt.Sprintf("Invalid selector for ListServiceAccountKeysResponse: %d", fpaivs.Selector()))
	}
}

// ListServiceAccountKeysResponse_FieldPathArrayOfValues allows storing slice of values for ListServiceAccountKeysResponse fields according to their type
type ListServiceAccountKeysResponse_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	ListServiceAccountKeysResponse_FieldPath
}

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

func MustParseListServiceAccountKeysResponse_FieldPathArrayOfValues(pathStr, valuesStr string) ListServiceAccountKeysResponse_FieldPathArrayOfValues {
	fpaov, err := ParseListServiceAccountKeysResponse_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type ListServiceAccountKeysResponse_FieldTerminalPathArrayOfValues struct {
	ListServiceAccountKeysResponse_FieldTerminalPath
	values interface{}
}

var _ ListServiceAccountKeysResponse_FieldPathArrayOfValues = (*ListServiceAccountKeysResponse_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *ListServiceAccountKeysResponse_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case ListServiceAccountKeysResponse_FieldPathSelectorServiceAccountKeys:
		for _, v := range fpaov.values.([][]*service_account_key.ServiceAccountKey) {
			values = append(values, v)
		}
	case ListServiceAccountKeysResponse_FieldPathSelectorPrevPageToken:
		for _, v := range fpaov.values.([]*service_account_key.PagerCursor) {
			values = append(values, v)
		}
	case ListServiceAccountKeysResponse_FieldPathSelectorNextPageToken:
		for _, v := range fpaov.values.([]*service_account_key.PagerCursor) {
			values = append(values, v)
		}
	case ListServiceAccountKeysResponse_FieldPathSelectorCurrentOffset:
		for _, v := range fpaov.values.([]int32) {
			values = append(values, v)
		}
	case ListServiceAccountKeysResponse_FieldPathSelectorTotalResultsCount:
		for _, v := range fpaov.values.([]int32) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *ListServiceAccountKeysResponse_FieldTerminalPathArrayOfValues) AsServiceAccountKeysArrayOfValues() ([][]*service_account_key.ServiceAccountKey, bool) {
	res, ok := fpaov.values.([][]*service_account_key.ServiceAccountKey)
	return res, ok
}
func (fpaov *ListServiceAccountKeysResponse_FieldTerminalPathArrayOfValues) AsPrevPageTokenArrayOfValues() ([]*service_account_key.PagerCursor, bool) {
	res, ok := fpaov.values.([]*service_account_key.PagerCursor)
	return res, ok
}
func (fpaov *ListServiceAccountKeysResponse_FieldTerminalPathArrayOfValues) AsNextPageTokenArrayOfValues() ([]*service_account_key.PagerCursor, bool) {
	res, ok := fpaov.values.([]*service_account_key.PagerCursor)
	return res, ok
}
func (fpaov *ListServiceAccountKeysResponse_FieldTerminalPathArrayOfValues) AsCurrentOffsetArrayOfValues() ([]int32, bool) {
	res, ok := fpaov.values.([]int32)
	return res, ok
}
func (fpaov *ListServiceAccountKeysResponse_FieldTerminalPathArrayOfValues) AsTotalResultsCountArrayOfValues() ([]int32, bool) {
	res, ok := fpaov.values.([]int32)
	return res, ok
}

type ListServiceAccountKeysResponse_FieldSubPathArrayOfValues struct {
	ListServiceAccountKeysResponse_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ ListServiceAccountKeysResponse_FieldPathArrayOfValues = (*ListServiceAccountKeysResponse_FieldSubPathArrayOfValues)(nil)

func (fpsaov *ListServiceAccountKeysResponse_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *ListServiceAccountKeysResponse_FieldSubPathArrayOfValues) AsServiceAccountKeysPathArrayOfValues() (service_account_key.ServiceAccountKey_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(service_account_key.ServiceAccountKey_FieldPathArrayOfValues)
	return res, ok
}

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

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

type WatchServiceAccountKeyRequest_FieldPathSelector int32

const (
	WatchServiceAccountKeyRequest_FieldPathSelectorName      WatchServiceAccountKeyRequest_FieldPathSelector = 0
	WatchServiceAccountKeyRequest_FieldPathSelectorFieldMask WatchServiceAccountKeyRequest_FieldPathSelector = 1
	WatchServiceAccountKeyRequest_FieldPathSelectorView      WatchServiceAccountKeyRequest_FieldPathSelector = 2
)

func (s WatchServiceAccountKeyRequest_FieldPathSelector) String() string {
	switch s {
	case WatchServiceAccountKeyRequest_FieldPathSelectorName:
		return "name"
	case WatchServiceAccountKeyRequest_FieldPathSelectorFieldMask:
		return "field_mask"
	case WatchServiceAccountKeyRequest_FieldPathSelectorView:
		return "view"
	default:
		panic(fmt.Sprintf("Invalid selector for WatchServiceAccountKeyRequest: %d", s))
	}
}

func BuildWatchServiceAccountKeyRequest_FieldPath(fp gotenobject.RawFieldPath) (WatchServiceAccountKeyRequest_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object WatchServiceAccountKeyRequest")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "name":
			return &WatchServiceAccountKeyRequest_FieldTerminalPath{selector: WatchServiceAccountKeyRequest_FieldPathSelectorName}, nil
		case "field_mask", "fieldMask", "field-mask":
			return &WatchServiceAccountKeyRequest_FieldTerminalPath{selector: WatchServiceAccountKeyRequest_FieldPathSelectorFieldMask}, nil
		case "view":
			return &WatchServiceAccountKeyRequest_FieldTerminalPath{selector: WatchServiceAccountKeyRequest_FieldPathSelectorView}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object WatchServiceAccountKeyRequest", fp)
}

func ParseWatchServiceAccountKeyRequest_FieldPath(rawField string) (WatchServiceAccountKeyRequest_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildWatchServiceAccountKeyRequest_FieldPath(fp)
}

func MustParseWatchServiceAccountKeyRequest_FieldPath(rawField string) WatchServiceAccountKeyRequest_FieldPath {
	fp, err := ParseWatchServiceAccountKeyRequest_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type WatchServiceAccountKeyRequest_FieldTerminalPath struct {
	selector WatchServiceAccountKeyRequest_FieldPathSelector
}

var _ WatchServiceAccountKeyRequest_FieldPath = (*WatchServiceAccountKeyRequest_FieldTerminalPath)(nil)

func (fp *WatchServiceAccountKeyRequest_FieldTerminalPath) Selector() WatchServiceAccountKeyRequest_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source WatchServiceAccountKeyRequest
func (fp *WatchServiceAccountKeyRequest_FieldTerminalPath) Get(source *WatchServiceAccountKeyRequest) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case WatchServiceAccountKeyRequest_FieldPathSelectorName:
			if source.Name != nil {
				values = append(values, source.Name)
			}
		case WatchServiceAccountKeyRequest_FieldPathSelectorFieldMask:
			if source.FieldMask != nil {
				values = append(values, source.FieldMask)
			}
		case WatchServiceAccountKeyRequest_FieldPathSelectorView:
			values = append(values, source.View)
		default:
			panic(fmt.Sprintf("Invalid selector for WatchServiceAccountKeyRequest: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source WatchServiceAccountKeyRequest
func (fp *WatchServiceAccountKeyRequest_FieldTerminalPath) GetSingle(source *WatchServiceAccountKeyRequest) (interface{}, bool) {
	switch fp.selector {
	case WatchServiceAccountKeyRequest_FieldPathSelectorName:
		res := source.GetName()
		return res, res != nil
	case WatchServiceAccountKeyRequest_FieldPathSelectorFieldMask:
		res := source.GetFieldMask()
		return res, res != nil
	case WatchServiceAccountKeyRequest_FieldPathSelectorView:
		return source.GetView(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for WatchServiceAccountKeyRequest: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *WatchServiceAccountKeyRequest_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case WatchServiceAccountKeyRequest_FieldPathSelectorName:
		return (*service_account_key.Reference)(nil)
	case WatchServiceAccountKeyRequest_FieldPathSelectorFieldMask:
		return (*service_account_key.ServiceAccountKey_FieldMask)(nil)
	case WatchServiceAccountKeyRequest_FieldPathSelectorView:
		return view.View_UNSPECIFIED
	default:
		panic(fmt.Sprintf("Invalid selector for WatchServiceAccountKeyRequest: %d", fp.selector))
	}
}

func (fp *WatchServiceAccountKeyRequest_FieldTerminalPath) ClearValue(item *WatchServiceAccountKeyRequest) {
	if item != nil {
		switch fp.selector {
		case WatchServiceAccountKeyRequest_FieldPathSelectorName:
			item.Name = nil
		case WatchServiceAccountKeyRequest_FieldPathSelectorFieldMask:
			item.FieldMask = nil
		case WatchServiceAccountKeyRequest_FieldPathSelectorView:
			item.View = view.View_UNSPECIFIED
		default:
			panic(fmt.Sprintf("Invalid selector for WatchServiceAccountKeyRequest: %d", fp.selector))
		}
	}
}

func (fp *WatchServiceAccountKeyRequest_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*WatchServiceAccountKeyRequest))
}

// IsLeaf - whether field path is holds simple value
func (fp *WatchServiceAccountKeyRequest_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == WatchServiceAccountKeyRequest_FieldPathSelectorName ||
		fp.selector == WatchServiceAccountKeyRequest_FieldPathSelectorFieldMask ||
		fp.selector == WatchServiceAccountKeyRequest_FieldPathSelectorView
}

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

func (fp *WatchServiceAccountKeyRequest_FieldTerminalPath) WithIValue(value interface{}) WatchServiceAccountKeyRequest_FieldPathValue {
	switch fp.selector {
	case WatchServiceAccountKeyRequest_FieldPathSelectorName:
		return &WatchServiceAccountKeyRequest_FieldTerminalPathValue{WatchServiceAccountKeyRequest_FieldTerminalPath: *fp, value: value.(*service_account_key.Reference)}
	case WatchServiceAccountKeyRequest_FieldPathSelectorFieldMask:
		return &WatchServiceAccountKeyRequest_FieldTerminalPathValue{WatchServiceAccountKeyRequest_FieldTerminalPath: *fp, value: value.(*service_account_key.ServiceAccountKey_FieldMask)}
	case WatchServiceAccountKeyRequest_FieldPathSelectorView:
		return &WatchServiceAccountKeyRequest_FieldTerminalPathValue{WatchServiceAccountKeyRequest_FieldTerminalPath: *fp, value: value.(view.View)}
	default:
		panic(fmt.Sprintf("Invalid selector for WatchServiceAccountKeyRequest: %d", fp.selector))
	}
}

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

func (fp *WatchServiceAccountKeyRequest_FieldTerminalPath) WithIArrayOfValues(values interface{}) WatchServiceAccountKeyRequest_FieldPathArrayOfValues {
	fpaov := &WatchServiceAccountKeyRequest_FieldTerminalPathArrayOfValues{WatchServiceAccountKeyRequest_FieldTerminalPath: *fp}
	switch fp.selector {
	case WatchServiceAccountKeyRequest_FieldPathSelectorName:
		return &WatchServiceAccountKeyRequest_FieldTerminalPathArrayOfValues{WatchServiceAccountKeyRequest_FieldTerminalPath: *fp, values: values.([]*service_account_key.Reference)}
	case WatchServiceAccountKeyRequest_FieldPathSelectorFieldMask:
		return &WatchServiceAccountKeyRequest_FieldTerminalPathArrayOfValues{WatchServiceAccountKeyRequest_FieldTerminalPath: *fp, values: values.([]*service_account_key.ServiceAccountKey_FieldMask)}
	case WatchServiceAccountKeyRequest_FieldPathSelectorView:
		return &WatchServiceAccountKeyRequest_FieldTerminalPathArrayOfValues{WatchServiceAccountKeyRequest_FieldTerminalPath: *fp, values: values.([]view.View)}
	default:
		panic(fmt.Sprintf("Invalid selector for WatchServiceAccountKeyRequest: %d", fp.selector))
	}
	return fpaov
}

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

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

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

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

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

func MustParseWatchServiceAccountKeyRequest_FieldPathValue(pathStr, valueStr string) WatchServiceAccountKeyRequest_FieldPathValue {
	fpv, err := ParseWatchServiceAccountKeyRequest_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type WatchServiceAccountKeyRequest_FieldTerminalPathValue struct {
	WatchServiceAccountKeyRequest_FieldTerminalPath
	value interface{}
}

var _ WatchServiceAccountKeyRequest_FieldPathValue = (*WatchServiceAccountKeyRequest_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'WatchServiceAccountKeyRequest' as interface{}
func (fpv *WatchServiceAccountKeyRequest_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *WatchServiceAccountKeyRequest_FieldTerminalPathValue) AsNameValue() (*service_account_key.Reference, bool) {
	res, ok := fpv.value.(*service_account_key.Reference)
	return res, ok
}
func (fpv *WatchServiceAccountKeyRequest_FieldTerminalPathValue) AsFieldMaskValue() (*service_account_key.ServiceAccountKey_FieldMask, bool) {
	res, ok := fpv.value.(*service_account_key.ServiceAccountKey_FieldMask)
	return res, ok
}
func (fpv *WatchServiceAccountKeyRequest_FieldTerminalPathValue) AsViewValue() (view.View, bool) {
	res, ok := fpv.value.(view.View)
	return res, ok
}

// SetTo stores value for selected field for object WatchServiceAccountKeyRequest
func (fpv *WatchServiceAccountKeyRequest_FieldTerminalPathValue) SetTo(target **WatchServiceAccountKeyRequest) {
	if *target == nil {
		*target = new(WatchServiceAccountKeyRequest)
	}
	switch fpv.selector {
	case WatchServiceAccountKeyRequest_FieldPathSelectorName:
		(*target).Name = fpv.value.(*service_account_key.Reference)
	case WatchServiceAccountKeyRequest_FieldPathSelectorFieldMask:
		(*target).FieldMask = fpv.value.(*service_account_key.ServiceAccountKey_FieldMask)
	case WatchServiceAccountKeyRequest_FieldPathSelectorView:
		(*target).View = fpv.value.(view.View)
	default:
		panic(fmt.Sprintf("Invalid selector for WatchServiceAccountKeyRequest: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'WatchServiceAccountKeyRequest_FieldTerminalPathValue' with the value under path in 'WatchServiceAccountKeyRequest'.
func (fpv *WatchServiceAccountKeyRequest_FieldTerminalPathValue) CompareWith(source *WatchServiceAccountKeyRequest) (int, bool) {
	switch fpv.selector {
	case WatchServiceAccountKeyRequest_FieldPathSelectorName:
		leftValue := fpv.value.(*service_account_key.Reference)
		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 WatchServiceAccountKeyRequest_FieldPathSelectorFieldMask:
		return 0, false
	case WatchServiceAccountKeyRequest_FieldPathSelectorView:
		leftValue := fpv.value.(view.View)
		rightValue := source.GetView()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for WatchServiceAccountKeyRequest: %d", fpv.selector))
	}
}

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

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

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

func MustParseWatchServiceAccountKeyRequest_FieldPathArrayItemValue(pathStr, valueStr string) WatchServiceAccountKeyRequest_FieldPathArrayItemValue {
	fpaiv, err := ParseWatchServiceAccountKeyRequest_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type WatchServiceAccountKeyRequest_FieldTerminalPathArrayItemValue struct {
	WatchServiceAccountKeyRequest_FieldTerminalPath
	value interface{}
}

var _ WatchServiceAccountKeyRequest_FieldPathArrayItemValue = (*WatchServiceAccountKeyRequest_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *WatchServiceAccountKeyRequest_FieldTerminalPathArrayItemValue) GetSingle(source *WatchServiceAccountKeyRequest) (interface{}, bool) {
	return nil, false
}

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

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

// WatchServiceAccountKeyRequest_FieldPathArrayOfValues allows storing slice of values for WatchServiceAccountKeyRequest fields according to their type
type WatchServiceAccountKeyRequest_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	WatchServiceAccountKeyRequest_FieldPath
}

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

func MustParseWatchServiceAccountKeyRequest_FieldPathArrayOfValues(pathStr, valuesStr string) WatchServiceAccountKeyRequest_FieldPathArrayOfValues {
	fpaov, err := ParseWatchServiceAccountKeyRequest_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type WatchServiceAccountKeyRequest_FieldTerminalPathArrayOfValues struct {
	WatchServiceAccountKeyRequest_FieldTerminalPath
	values interface{}
}

var _ WatchServiceAccountKeyRequest_FieldPathArrayOfValues = (*WatchServiceAccountKeyRequest_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *WatchServiceAccountKeyRequest_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case WatchServiceAccountKeyRequest_FieldPathSelectorName:
		for _, v := range fpaov.values.([]*service_account_key.Reference) {
			values = append(values, v)
		}
	case WatchServiceAccountKeyRequest_FieldPathSelectorFieldMask:
		for _, v := range fpaov.values.([]*service_account_key.ServiceAccountKey_FieldMask) {
			values = append(values, v)
		}
	case WatchServiceAccountKeyRequest_FieldPathSelectorView:
		for _, v := range fpaov.values.([]view.View) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *WatchServiceAccountKeyRequest_FieldTerminalPathArrayOfValues) AsNameArrayOfValues() ([]*service_account_key.Reference, bool) {
	res, ok := fpaov.values.([]*service_account_key.Reference)
	return res, ok
}
func (fpaov *WatchServiceAccountKeyRequest_FieldTerminalPathArrayOfValues) AsFieldMaskArrayOfValues() ([]*service_account_key.ServiceAccountKey_FieldMask, bool) {
	res, ok := fpaov.values.([]*service_account_key.ServiceAccountKey_FieldMask)
	return res, ok
}
func (fpaov *WatchServiceAccountKeyRequest_FieldTerminalPathArrayOfValues) AsViewArrayOfValues() ([]view.View, bool) {
	res, ok := fpaov.values.([]view.View)
	return res, ok
}

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

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

type WatchServiceAccountKeyResponse_FieldPathSelector int32

const (
	WatchServiceAccountKeyResponse_FieldPathSelectorChange WatchServiceAccountKeyResponse_FieldPathSelector = 0
)

func (s WatchServiceAccountKeyResponse_FieldPathSelector) String() string {
	switch s {
	case WatchServiceAccountKeyResponse_FieldPathSelectorChange:
		return "change"
	default:
		panic(fmt.Sprintf("Invalid selector for WatchServiceAccountKeyResponse: %d", s))
	}
}

func BuildWatchServiceAccountKeyResponse_FieldPath(fp gotenobject.RawFieldPath) (WatchServiceAccountKeyResponse_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object WatchServiceAccountKeyResponse")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "change":
			return &WatchServiceAccountKeyResponse_FieldTerminalPath{selector: WatchServiceAccountKeyResponse_FieldPathSelectorChange}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object WatchServiceAccountKeyResponse", fp)
}

func ParseWatchServiceAccountKeyResponse_FieldPath(rawField string) (WatchServiceAccountKeyResponse_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildWatchServiceAccountKeyResponse_FieldPath(fp)
}

func MustParseWatchServiceAccountKeyResponse_FieldPath(rawField string) WatchServiceAccountKeyResponse_FieldPath {
	fp, err := ParseWatchServiceAccountKeyResponse_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type WatchServiceAccountKeyResponse_FieldTerminalPath struct {
	selector WatchServiceAccountKeyResponse_FieldPathSelector
}

var _ WatchServiceAccountKeyResponse_FieldPath = (*WatchServiceAccountKeyResponse_FieldTerminalPath)(nil)

func (fp *WatchServiceAccountKeyResponse_FieldTerminalPath) Selector() WatchServiceAccountKeyResponse_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

// GetDefault returns a default value of the field type
func (fp *WatchServiceAccountKeyResponse_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case WatchServiceAccountKeyResponse_FieldPathSelectorChange:
		return (*service_account_key.ServiceAccountKeyChange)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for WatchServiceAccountKeyResponse: %d", fp.selector))
	}
}

func (fp *WatchServiceAccountKeyResponse_FieldTerminalPath) ClearValue(item *WatchServiceAccountKeyResponse) {
	if item != nil {
		switch fp.selector {
		case WatchServiceAccountKeyResponse_FieldPathSelectorChange:
			item.Change = nil
		default:
			panic(fmt.Sprintf("Invalid selector for WatchServiceAccountKeyResponse: %d", fp.selector))
		}
	}
}

func (fp *WatchServiceAccountKeyResponse_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*WatchServiceAccountKeyResponse))
}

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

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

func (fp *WatchServiceAccountKeyResponse_FieldTerminalPath) WithIValue(value interface{}) WatchServiceAccountKeyResponse_FieldPathValue {
	switch fp.selector {
	case WatchServiceAccountKeyResponse_FieldPathSelectorChange:
		return &WatchServiceAccountKeyResponse_FieldTerminalPathValue{WatchServiceAccountKeyResponse_FieldTerminalPath: *fp, value: value.(*service_account_key.ServiceAccountKeyChange)}
	default:
		panic(fmt.Sprintf("Invalid selector for WatchServiceAccountKeyResponse: %d", fp.selector))
	}
}

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

func (fp *WatchServiceAccountKeyResponse_FieldTerminalPath) WithIArrayOfValues(values interface{}) WatchServiceAccountKeyResponse_FieldPathArrayOfValues {
	fpaov := &WatchServiceAccountKeyResponse_FieldTerminalPathArrayOfValues{WatchServiceAccountKeyResponse_FieldTerminalPath: *fp}
	switch fp.selector {
	case WatchServiceAccountKeyResponse_FieldPathSelectorChange:
		return &WatchServiceAccountKeyResponse_FieldTerminalPathArrayOfValues{WatchServiceAccountKeyResponse_FieldTerminalPath: *fp, values: values.([]*service_account_key.ServiceAccountKeyChange)}
	default:
		panic(fmt.Sprintf("Invalid selector for WatchServiceAccountKeyResponse: %d", fp.selector))
	}
	return fpaov
}

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

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

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

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

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

func MustParseWatchServiceAccountKeyResponse_FieldPathValue(pathStr, valueStr string) WatchServiceAccountKeyResponse_FieldPathValue {
	fpv, err := ParseWatchServiceAccountKeyResponse_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type WatchServiceAccountKeyResponse_FieldTerminalPathValue struct {
	WatchServiceAccountKeyResponse_FieldTerminalPath
	value interface{}
}

var _ WatchServiceAccountKeyResponse_FieldPathValue = (*WatchServiceAccountKeyResponse_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'WatchServiceAccountKeyResponse' as interface{}
func (fpv *WatchServiceAccountKeyResponse_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *WatchServiceAccountKeyResponse_FieldTerminalPathValue) AsChangeValue() (*service_account_key.ServiceAccountKeyChange, bool) {
	res, ok := fpv.value.(*service_account_key.ServiceAccountKeyChange)
	return res, ok
}

// SetTo stores value for selected field for object WatchServiceAccountKeyResponse
func (fpv *WatchServiceAccountKeyResponse_FieldTerminalPathValue) SetTo(target **WatchServiceAccountKeyResponse) {
	if *target == nil {
		*target = new(WatchServiceAccountKeyResponse)
	}
	switch fpv.selector {
	case WatchServiceAccountKeyResponse_FieldPathSelectorChange:
		(*target).Change = fpv.value.(*service_account_key.ServiceAccountKeyChange)
	default:
		panic(fmt.Sprintf("Invalid selector for WatchServiceAccountKeyResponse: %d", fpv.selector))
	}
}

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

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

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

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

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

func MustParseWatchServiceAccountKeyResponse_FieldPathArrayItemValue(pathStr, valueStr string) WatchServiceAccountKeyResponse_FieldPathArrayItemValue {
	fpaiv, err := ParseWatchServiceAccountKeyResponse_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type WatchServiceAccountKeyResponse_FieldTerminalPathArrayItemValue struct {
	WatchServiceAccountKeyResponse_FieldTerminalPath
	value interface{}
}

var _ WatchServiceAccountKeyResponse_FieldPathArrayItemValue = (*WatchServiceAccountKeyResponse_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *WatchServiceAccountKeyResponse_FieldTerminalPathArrayItemValue) GetSingle(source *WatchServiceAccountKeyResponse) (interface{}, bool) {
	return nil, false
}

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

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

// WatchServiceAccountKeyResponse_FieldPathArrayOfValues allows storing slice of values for WatchServiceAccountKeyResponse fields according to their type
type WatchServiceAccountKeyResponse_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	WatchServiceAccountKeyResponse_FieldPath
}

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

func MustParseWatchServiceAccountKeyResponse_FieldPathArrayOfValues(pathStr, valuesStr string) WatchServiceAccountKeyResponse_FieldPathArrayOfValues {
	fpaov, err := ParseWatchServiceAccountKeyResponse_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type WatchServiceAccountKeyResponse_FieldTerminalPathArrayOfValues struct {
	WatchServiceAccountKeyResponse_FieldTerminalPath
	values interface{}
}

var _ WatchServiceAccountKeyResponse_FieldPathArrayOfValues = (*WatchServiceAccountKeyResponse_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *WatchServiceAccountKeyResponse_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case WatchServiceAccountKeyResponse_FieldPathSelectorChange:
		for _, v := range fpaov.values.([]*service_account_key.ServiceAccountKeyChange) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *WatchServiceAccountKeyResponse_FieldTerminalPathArrayOfValues) AsChangeArrayOfValues() ([]*service_account_key.ServiceAccountKeyChange, bool) {
	res, ok := fpaov.values.([]*service_account_key.ServiceAccountKeyChange)
	return res, ok
}

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

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

type WatchServiceAccountKeysRequest_FieldPathSelector int32

const (
	WatchServiceAccountKeysRequest_FieldPathSelectorType         WatchServiceAccountKeysRequest_FieldPathSelector = 0
	WatchServiceAccountKeysRequest_FieldPathSelectorParent       WatchServiceAccountKeysRequest_FieldPathSelector = 1
	WatchServiceAccountKeysRequest_FieldPathSelectorPageSize     WatchServiceAccountKeysRequest_FieldPathSelector = 2
	WatchServiceAccountKeysRequest_FieldPathSelectorPageToken    WatchServiceAccountKeysRequest_FieldPathSelector = 3
	WatchServiceAccountKeysRequest_FieldPathSelectorOrderBy      WatchServiceAccountKeysRequest_FieldPathSelector = 4
	WatchServiceAccountKeysRequest_FieldPathSelectorResumeToken  WatchServiceAccountKeysRequest_FieldPathSelector = 5
	WatchServiceAccountKeysRequest_FieldPathSelectorStartingTime WatchServiceAccountKeysRequest_FieldPathSelector = 6
	WatchServiceAccountKeysRequest_FieldPathSelectorFilter       WatchServiceAccountKeysRequest_FieldPathSelector = 7
	WatchServiceAccountKeysRequest_FieldPathSelectorFieldMask    WatchServiceAccountKeysRequest_FieldPathSelector = 8
	WatchServiceAccountKeysRequest_FieldPathSelectorView         WatchServiceAccountKeysRequest_FieldPathSelector = 9
	WatchServiceAccountKeysRequest_FieldPathSelectorMaxChunkSize WatchServiceAccountKeysRequest_FieldPathSelector = 10
)

func (s WatchServiceAccountKeysRequest_FieldPathSelector) String() string {
	switch s {
	case WatchServiceAccountKeysRequest_FieldPathSelectorType:
		return "type"
	case WatchServiceAccountKeysRequest_FieldPathSelectorParent:
		return "parent"
	case WatchServiceAccountKeysRequest_FieldPathSelectorPageSize:
		return "page_size"
	case WatchServiceAccountKeysRequest_FieldPathSelectorPageToken:
		return "page_token"
	case WatchServiceAccountKeysRequest_FieldPathSelectorOrderBy:
		return "order_by"
	case WatchServiceAccountKeysRequest_FieldPathSelectorResumeToken:
		return "resume_token"
	case WatchServiceAccountKeysRequest_FieldPathSelectorStartingTime:
		return "starting_time"
	case WatchServiceAccountKeysRequest_FieldPathSelectorFilter:
		return "filter"
	case WatchServiceAccountKeysRequest_FieldPathSelectorFieldMask:
		return "field_mask"
	case WatchServiceAccountKeysRequest_FieldPathSelectorView:
		return "view"
	case WatchServiceAccountKeysRequest_FieldPathSelectorMaxChunkSize:
		return "max_chunk_size"
	default:
		panic(fmt.Sprintf("Invalid selector for WatchServiceAccountKeysRequest: %d", s))
	}
}

func BuildWatchServiceAccountKeysRequest_FieldPath(fp gotenobject.RawFieldPath) (WatchServiceAccountKeysRequest_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object WatchServiceAccountKeysRequest")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "type":
			return &WatchServiceAccountKeysRequest_FieldTerminalPath{selector: WatchServiceAccountKeysRequest_FieldPathSelectorType}, nil
		case "parent":
			return &WatchServiceAccountKeysRequest_FieldTerminalPath{selector: WatchServiceAccountKeysRequest_FieldPathSelectorParent}, nil
		case "page_size", "pageSize", "page-size":
			return &WatchServiceAccountKeysRequest_FieldTerminalPath{selector: WatchServiceAccountKeysRequest_FieldPathSelectorPageSize}, nil
		case "page_token", "pageToken", "page-token":
			return &WatchServiceAccountKeysRequest_FieldTerminalPath{selector: WatchServiceAccountKeysRequest_FieldPathSelectorPageToken}, nil
		case "order_by", "orderBy", "order-by":
			return &WatchServiceAccountKeysRequest_FieldTerminalPath{selector: WatchServiceAccountKeysRequest_FieldPathSelectorOrderBy}, nil
		case "resume_token", "resumeToken", "resume-token":
			return &WatchServiceAccountKeysRequest_FieldTerminalPath{selector: WatchServiceAccountKeysRequest_FieldPathSelectorResumeToken}, nil
		case "starting_time", "startingTime", "starting-time":
			return &WatchServiceAccountKeysRequest_FieldTerminalPath{selector: WatchServiceAccountKeysRequest_FieldPathSelectorStartingTime}, nil
		case "filter":
			return &WatchServiceAccountKeysRequest_FieldTerminalPath{selector: WatchServiceAccountKeysRequest_FieldPathSelectorFilter}, nil
		case "field_mask", "fieldMask", "field-mask":
			return &WatchServiceAccountKeysRequest_FieldTerminalPath{selector: WatchServiceAccountKeysRequest_FieldPathSelectorFieldMask}, nil
		case "view":
			return &WatchServiceAccountKeysRequest_FieldTerminalPath{selector: WatchServiceAccountKeysRequest_FieldPathSelectorView}, nil
		case "max_chunk_size", "maxChunkSize", "max-chunk-size":
			return &WatchServiceAccountKeysRequest_FieldTerminalPath{selector: WatchServiceAccountKeysRequest_FieldPathSelectorMaxChunkSize}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object WatchServiceAccountKeysRequest", fp)
}

func ParseWatchServiceAccountKeysRequest_FieldPath(rawField string) (WatchServiceAccountKeysRequest_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildWatchServiceAccountKeysRequest_FieldPath(fp)
}

func MustParseWatchServiceAccountKeysRequest_FieldPath(rawField string) WatchServiceAccountKeysRequest_FieldPath {
	fp, err := ParseWatchServiceAccountKeysRequest_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type WatchServiceAccountKeysRequest_FieldTerminalPath struct {
	selector WatchServiceAccountKeysRequest_FieldPathSelector
}

var _ WatchServiceAccountKeysRequest_FieldPath = (*WatchServiceAccountKeysRequest_FieldTerminalPath)(nil)

func (fp *WatchServiceAccountKeysRequest_FieldTerminalPath) Selector() WatchServiceAccountKeysRequest_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source WatchServiceAccountKeysRequest
func (fp *WatchServiceAccountKeysRequest_FieldTerminalPath) Get(source *WatchServiceAccountKeysRequest) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case WatchServiceAccountKeysRequest_FieldPathSelectorType:
			values = append(values, source.Type)
		case WatchServiceAccountKeysRequest_FieldPathSelectorParent:
			if source.Parent != nil {
				values = append(values, source.Parent)
			}
		case WatchServiceAccountKeysRequest_FieldPathSelectorPageSize:
			values = append(values, source.PageSize)
		case WatchServiceAccountKeysRequest_FieldPathSelectorPageToken:
			if source.PageToken != nil {
				values = append(values, source.PageToken)
			}
		case WatchServiceAccountKeysRequest_FieldPathSelectorOrderBy:
			if source.OrderBy != nil {
				values = append(values, source.OrderBy)
			}
		case WatchServiceAccountKeysRequest_FieldPathSelectorResumeToken:
			values = append(values, source.ResumeToken)
		case WatchServiceAccountKeysRequest_FieldPathSelectorStartingTime:
			if source.StartingTime != nil {
				values = append(values, source.StartingTime)
			}
		case WatchServiceAccountKeysRequest_FieldPathSelectorFilter:
			if source.Filter != nil {
				values = append(values, source.Filter)
			}
		case WatchServiceAccountKeysRequest_FieldPathSelectorFieldMask:
			if source.FieldMask != nil {
				values = append(values, source.FieldMask)
			}
		case WatchServiceAccountKeysRequest_FieldPathSelectorView:
			values = append(values, source.View)
		case WatchServiceAccountKeysRequest_FieldPathSelectorMaxChunkSize:
			values = append(values, source.MaxChunkSize)
		default:
			panic(fmt.Sprintf("Invalid selector for WatchServiceAccountKeysRequest: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source WatchServiceAccountKeysRequest
func (fp *WatchServiceAccountKeysRequest_FieldTerminalPath) GetSingle(source *WatchServiceAccountKeysRequest) (interface{}, bool) {
	switch fp.selector {
	case WatchServiceAccountKeysRequest_FieldPathSelectorType:
		return source.GetType(), source != nil
	case WatchServiceAccountKeysRequest_FieldPathSelectorParent:
		res := source.GetParent()
		return res, res != nil
	case WatchServiceAccountKeysRequest_FieldPathSelectorPageSize:
		return source.GetPageSize(), source != nil
	case WatchServiceAccountKeysRequest_FieldPathSelectorPageToken:
		res := source.GetPageToken()
		return res, res != nil
	case WatchServiceAccountKeysRequest_FieldPathSelectorOrderBy:
		res := source.GetOrderBy()
		return res, res != nil
	case WatchServiceAccountKeysRequest_FieldPathSelectorResumeToken:
		return source.GetResumeToken(), source != nil
	case WatchServiceAccountKeysRequest_FieldPathSelectorStartingTime:
		res := source.GetStartingTime()
		return res, res != nil
	case WatchServiceAccountKeysRequest_FieldPathSelectorFilter:
		res := source.GetFilter()
		return res, res != nil
	case WatchServiceAccountKeysRequest_FieldPathSelectorFieldMask:
		res := source.GetFieldMask()
		return res, res != nil
	case WatchServiceAccountKeysRequest_FieldPathSelectorView:
		return source.GetView(), source != nil
	case WatchServiceAccountKeysRequest_FieldPathSelectorMaxChunkSize:
		return source.GetMaxChunkSize(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for WatchServiceAccountKeysRequest: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *WatchServiceAccountKeysRequest_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case WatchServiceAccountKeysRequest_FieldPathSelectorType:
		return watch_type.WatchType_STATEFUL
	case WatchServiceAccountKeysRequest_FieldPathSelectorParent:
		return (*service_account_key.ParentReference)(nil)
	case WatchServiceAccountKeysRequest_FieldPathSelectorPageSize:
		return int32(0)
	case WatchServiceAccountKeysRequest_FieldPathSelectorPageToken:
		return (*service_account_key.PagerCursor)(nil)
	case WatchServiceAccountKeysRequest_FieldPathSelectorOrderBy:
		return (*service_account_key.OrderBy)(nil)
	case WatchServiceAccountKeysRequest_FieldPathSelectorResumeToken:
		return ""
	case WatchServiceAccountKeysRequest_FieldPathSelectorStartingTime:
		return (*timestamp.Timestamp)(nil)
	case WatchServiceAccountKeysRequest_FieldPathSelectorFilter:
		return (*service_account_key.Filter)(nil)
	case WatchServiceAccountKeysRequest_FieldPathSelectorFieldMask:
		return (*service_account_key.ServiceAccountKey_FieldMask)(nil)
	case WatchServiceAccountKeysRequest_FieldPathSelectorView:
		return view.View_UNSPECIFIED
	case WatchServiceAccountKeysRequest_FieldPathSelectorMaxChunkSize:
		return int32(0)
	default:
		panic(fmt.Sprintf("Invalid selector for WatchServiceAccountKeysRequest: %d", fp.selector))
	}
}

func (fp *WatchServiceAccountKeysRequest_FieldTerminalPath) ClearValue(item *WatchServiceAccountKeysRequest) {
	if item != nil {
		switch fp.selector {
		case WatchServiceAccountKeysRequest_FieldPathSelectorType:
			item.Type = watch_type.WatchType_STATEFUL
		case WatchServiceAccountKeysRequest_FieldPathSelectorParent:
			item.Parent = nil
		case WatchServiceAccountKeysRequest_FieldPathSelectorPageSize:
			item.PageSize = int32(0)
		case WatchServiceAccountKeysRequest_FieldPathSelectorPageToken:
			item.PageToken = nil
		case WatchServiceAccountKeysRequest_FieldPathSelectorOrderBy:
			item.OrderBy = nil
		case WatchServiceAccountKeysRequest_FieldPathSelectorResumeToken:
			item.ResumeToken = ""
		case WatchServiceAccountKeysRequest_FieldPathSelectorStartingTime:
			item.StartingTime = nil
		case WatchServiceAccountKeysRequest_FieldPathSelectorFilter:
			item.Filter = nil
		case WatchServiceAccountKeysRequest_FieldPathSelectorFieldMask:
			item.FieldMask = nil
		case WatchServiceAccountKeysRequest_FieldPathSelectorView:
			item.View = view.View_UNSPECIFIED
		case WatchServiceAccountKeysRequest_FieldPathSelectorMaxChunkSize:
			item.MaxChunkSize = int32(0)
		default:
			panic(fmt.Sprintf("Invalid selector for WatchServiceAccountKeysRequest: %d", fp.selector))
		}
	}
}

func (fp *WatchServiceAccountKeysRequest_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*WatchServiceAccountKeysRequest))
}

// IsLeaf - whether field path is holds simple value
func (fp *WatchServiceAccountKeysRequest_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == WatchServiceAccountKeysRequest_FieldPathSelectorType ||
		fp.selector == WatchServiceAccountKeysRequest_FieldPathSelectorParent ||
		fp.selector == WatchServiceAccountKeysRequest_FieldPathSelectorPageSize ||
		fp.selector == WatchServiceAccountKeysRequest_FieldPathSelectorPageToken ||
		fp.selector == WatchServiceAccountKeysRequest_FieldPathSelectorOrderBy ||
		fp.selector == WatchServiceAccountKeysRequest_FieldPathSelectorResumeToken ||
		fp.selector == WatchServiceAccountKeysRequest_FieldPathSelectorStartingTime ||
		fp.selector == WatchServiceAccountKeysRequest_FieldPathSelectorFilter ||
		fp.selector == WatchServiceAccountKeysRequest_FieldPathSelectorFieldMask ||
		fp.selector == WatchServiceAccountKeysRequest_FieldPathSelectorView ||
		fp.selector == WatchServiceAccountKeysRequest_FieldPathSelectorMaxChunkSize
}

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

func (fp *WatchServiceAccountKeysRequest_FieldTerminalPath) WithIValue(value interface{}) WatchServiceAccountKeysRequest_FieldPathValue {
	switch fp.selector {
	case WatchServiceAccountKeysRequest_FieldPathSelectorType:
		return &WatchServiceAccountKeysRequest_FieldTerminalPathValue{WatchServiceAccountKeysRequest_FieldTerminalPath: *fp, value: value.(watch_type.WatchType)}
	case WatchServiceAccountKeysRequest_FieldPathSelectorParent:
		return &WatchServiceAccountKeysRequest_FieldTerminalPathValue{WatchServiceAccountKeysRequest_FieldTerminalPath: *fp, value: value.(*service_account_key.ParentReference)}
	case WatchServiceAccountKeysRequest_FieldPathSelectorPageSize:
		return &WatchServiceAccountKeysRequest_FieldTerminalPathValue{WatchServiceAccountKeysRequest_FieldTerminalPath: *fp, value: value.(int32)}
	case WatchServiceAccountKeysRequest_FieldPathSelectorPageToken:
		return &WatchServiceAccountKeysRequest_FieldTerminalPathValue{WatchServiceAccountKeysRequest_FieldTerminalPath: *fp, value: value.(*service_account_key.PagerCursor)}
	case WatchServiceAccountKeysRequest_FieldPathSelectorOrderBy:
		return &WatchServiceAccountKeysRequest_FieldTerminalPathValue{WatchServiceAccountKeysRequest_FieldTerminalPath: *fp, value: value.(*service_account_key.OrderBy)}
	case WatchServiceAccountKeysRequest_FieldPathSelectorResumeToken:
		return &WatchServiceAccountKeysRequest_FieldTerminalPathValue{WatchServiceAccountKeysRequest_FieldTerminalPath: *fp, value: value.(string)}
	case WatchServiceAccountKeysRequest_FieldPathSelectorStartingTime:
		return &WatchServiceAccountKeysRequest_FieldTerminalPathValue{WatchServiceAccountKeysRequest_FieldTerminalPath: *fp, value: value.(*timestamp.Timestamp)}
	case WatchServiceAccountKeysRequest_FieldPathSelectorFilter:
		return &WatchServiceAccountKeysRequest_FieldTerminalPathValue{WatchServiceAccountKeysRequest_FieldTerminalPath: *fp, value: value.(*service_account_key.Filter)}
	case WatchServiceAccountKeysRequest_FieldPathSelectorFieldMask:
		return &WatchServiceAccountKeysRequest_FieldTerminalPathValue{WatchServiceAccountKeysRequest_FieldTerminalPath: *fp, value: value.(*service_account_key.ServiceAccountKey_FieldMask)}
	case WatchServiceAccountKeysRequest_FieldPathSelectorView:
		return &WatchServiceAccountKeysRequest_FieldTerminalPathValue{WatchServiceAccountKeysRequest_FieldTerminalPath: *fp, value: value.(view.View)}
	case WatchServiceAccountKeysRequest_FieldPathSelectorMaxChunkSize:
		return &WatchServiceAccountKeysRequest_FieldTerminalPathValue{WatchServiceAccountKeysRequest_FieldTerminalPath: *fp, value: value.(int32)}
	default:
		panic(fmt.Sprintf("Invalid selector for WatchServiceAccountKeysRequest: %d", fp.selector))
	}
}

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

func (fp *WatchServiceAccountKeysRequest_FieldTerminalPath) WithIArrayOfValues(values interface{}) WatchServiceAccountKeysRequest_FieldPathArrayOfValues {
	fpaov := &WatchServiceAccountKeysRequest_FieldTerminalPathArrayOfValues{WatchServiceAccountKeysRequest_FieldTerminalPath: *fp}
	switch fp.selector {
	case WatchServiceAccountKeysRequest_FieldPathSelectorType:
		return &WatchServiceAccountKeysRequest_FieldTerminalPathArrayOfValues{WatchServiceAccountKeysRequest_FieldTerminalPath: *fp, values: values.([]watch_type.WatchType)}
	case WatchServiceAccountKeysRequest_FieldPathSelectorParent:
		return &WatchServiceAccountKeysRequest_FieldTerminalPathArrayOfValues{WatchServiceAccountKeysRequest_FieldTerminalPath: *fp, values: values.([]*service_account_key.ParentReference)}
	case WatchServiceAccountKeysRequest_FieldPathSelectorPageSize:
		return &WatchServiceAccountKeysRequest_FieldTerminalPathArrayOfValues{WatchServiceAccountKeysRequest_FieldTerminalPath: *fp, values: values.([]int32)}
	case WatchServiceAccountKeysRequest_FieldPathSelectorPageToken:
		return &WatchServiceAccountKeysRequest_FieldTerminalPathArrayOfValues{WatchServiceAccountKeysRequest_FieldTerminalPath: *fp, values: values.([]*service_account_key.PagerCursor)}
	case WatchServiceAccountKeysRequest_FieldPathSelectorOrderBy:
		return &WatchServiceAccountKeysRequest_FieldTerminalPathArrayOfValues{WatchServiceAccountKeysRequest_FieldTerminalPath: *fp, values: values.([]*service_account_key.OrderBy)}
	case WatchServiceAccountKeysRequest_FieldPathSelectorResumeToken:
		return &WatchServiceAccountKeysRequest_FieldTerminalPathArrayOfValues{WatchServiceAccountKeysRequest_FieldTerminalPath: *fp, values: values.([]string)}
	case WatchServiceAccountKeysRequest_FieldPathSelectorStartingTime:
		return &WatchServiceAccountKeysRequest_FieldTerminalPathArrayOfValues{WatchServiceAccountKeysRequest_FieldTerminalPath: *fp, values: values.([]*timestamp.Timestamp)}
	case WatchServiceAccountKeysRequest_FieldPathSelectorFilter:
		return &WatchServiceAccountKeysRequest_FieldTerminalPathArrayOfValues{WatchServiceAccountKeysRequest_FieldTerminalPath: *fp, values: values.([]*service_account_key.Filter)}
	case WatchServiceAccountKeysRequest_FieldPathSelectorFieldMask:
		return &WatchServiceAccountKeysRequest_FieldTerminalPathArrayOfValues{WatchServiceAccountKeysRequest_FieldTerminalPath: *fp, values: values.([]*service_account_key.ServiceAccountKey_FieldMask)}
	case WatchServiceAccountKeysRequest_FieldPathSelectorView:
		return &WatchServiceAccountKeysRequest_FieldTerminalPathArrayOfValues{WatchServiceAccountKeysRequest_FieldTerminalPath: *fp, values: values.([]view.View)}
	case WatchServiceAccountKeysRequest_FieldPathSelectorMaxChunkSize:
		return &WatchServiceAccountKeysRequest_FieldTerminalPathArrayOfValues{WatchServiceAccountKeysRequest_FieldTerminalPath: *fp, values: values.([]int32)}
	default:
		panic(fmt.Sprintf("Invalid selector for WatchServiceAccountKeysRequest: %d", fp.selector))
	}
	return fpaov
}

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

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

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

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

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

func MustParseWatchServiceAccountKeysRequest_FieldPathValue(pathStr, valueStr string) WatchServiceAccountKeysRequest_FieldPathValue {
	fpv, err := ParseWatchServiceAccountKeysRequest_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type WatchServiceAccountKeysRequest_FieldTerminalPathValue struct {
	WatchServiceAccountKeysRequest_FieldTerminalPath
	value interface{}
}

var _ WatchServiceAccountKeysRequest_FieldPathValue = (*WatchServiceAccountKeysRequest_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'WatchServiceAccountKeysRequest' as interface{}
func (fpv *WatchServiceAccountKeysRequest_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *WatchServiceAccountKeysRequest_FieldTerminalPathValue) AsTypeValue() (watch_type.WatchType, bool) {
	res, ok := fpv.value.(watch_type.WatchType)
	return res, ok
}
func (fpv *WatchServiceAccountKeysRequest_FieldTerminalPathValue) AsParentValue() (*service_account_key.ParentReference, bool) {
	res, ok := fpv.value.(*service_account_key.ParentReference)
	return res, ok
}
func (fpv *WatchServiceAccountKeysRequest_FieldTerminalPathValue) AsPageSizeValue() (int32, bool) {
	res, ok := fpv.value.(int32)
	return res, ok
}
func (fpv *WatchServiceAccountKeysRequest_FieldTerminalPathValue) AsPageTokenValue() (*service_account_key.PagerCursor, bool) {
	res, ok := fpv.value.(*service_account_key.PagerCursor)
	return res, ok
}
func (fpv *WatchServiceAccountKeysRequest_FieldTerminalPathValue) AsOrderByValue() (*service_account_key.OrderBy, bool) {
	res, ok := fpv.value.(*service_account_key.OrderBy)
	return res, ok
}
func (fpv *WatchServiceAccountKeysRequest_FieldTerminalPathValue) AsResumeTokenValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *WatchServiceAccountKeysRequest_FieldTerminalPathValue) AsStartingTimeValue() (*timestamp.Timestamp, bool) {
	res, ok := fpv.value.(*timestamp.Timestamp)
	return res, ok
}
func (fpv *WatchServiceAccountKeysRequest_FieldTerminalPathValue) AsFilterValue() (*service_account_key.Filter, bool) {
	res, ok := fpv.value.(*service_account_key.Filter)
	return res, ok
}
func (fpv *WatchServiceAccountKeysRequest_FieldTerminalPathValue) AsFieldMaskValue() (*service_account_key.ServiceAccountKey_FieldMask, bool) {
	res, ok := fpv.value.(*service_account_key.ServiceAccountKey_FieldMask)
	return res, ok
}
func (fpv *WatchServiceAccountKeysRequest_FieldTerminalPathValue) AsViewValue() (view.View, bool) {
	res, ok := fpv.value.(view.View)
	return res, ok
}
func (fpv *WatchServiceAccountKeysRequest_FieldTerminalPathValue) AsMaxChunkSizeValue() (int32, bool) {
	res, ok := fpv.value.(int32)
	return res, ok
}

// SetTo stores value for selected field for object WatchServiceAccountKeysRequest
func (fpv *WatchServiceAccountKeysRequest_FieldTerminalPathValue) SetTo(target **WatchServiceAccountKeysRequest) {
	if *target == nil {
		*target = new(WatchServiceAccountKeysRequest)
	}
	switch fpv.selector {
	case WatchServiceAccountKeysRequest_FieldPathSelectorType:
		(*target).Type = fpv.value.(watch_type.WatchType)
	case WatchServiceAccountKeysRequest_FieldPathSelectorParent:
		(*target).Parent = fpv.value.(*service_account_key.ParentReference)
	case WatchServiceAccountKeysRequest_FieldPathSelectorPageSize:
		(*target).PageSize = fpv.value.(int32)
	case WatchServiceAccountKeysRequest_FieldPathSelectorPageToken:
		(*target).PageToken = fpv.value.(*service_account_key.PagerCursor)
	case WatchServiceAccountKeysRequest_FieldPathSelectorOrderBy:
		(*target).OrderBy = fpv.value.(*service_account_key.OrderBy)
	case WatchServiceAccountKeysRequest_FieldPathSelectorResumeToken:
		(*target).ResumeToken = fpv.value.(string)
	case WatchServiceAccountKeysRequest_FieldPathSelectorStartingTime:
		(*target).StartingTime = fpv.value.(*timestamp.Timestamp)
	case WatchServiceAccountKeysRequest_FieldPathSelectorFilter:
		(*target).Filter = fpv.value.(*service_account_key.Filter)
	case WatchServiceAccountKeysRequest_FieldPathSelectorFieldMask:
		(*target).FieldMask = fpv.value.(*service_account_key.ServiceAccountKey_FieldMask)
	case WatchServiceAccountKeysRequest_FieldPathSelectorView:
		(*target).View = fpv.value.(view.View)
	case WatchServiceAccountKeysRequest_FieldPathSelectorMaxChunkSize:
		(*target).MaxChunkSize = fpv.value.(int32)
	default:
		panic(fmt.Sprintf("Invalid selector for WatchServiceAccountKeysRequest: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'WatchServiceAccountKeysRequest_FieldTerminalPathValue' with the value under path in 'WatchServiceAccountKeysRequest'.
func (fpv *WatchServiceAccountKeysRequest_FieldTerminalPathValue) CompareWith(source *WatchServiceAccountKeysRequest) (int, bool) {
	switch fpv.selector {
	case WatchServiceAccountKeysRequest_FieldPathSelectorType:
		leftValue := fpv.value.(watch_type.WatchType)
		rightValue := source.GetType()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case WatchServiceAccountKeysRequest_FieldPathSelectorParent:
		leftValue := fpv.value.(*service_account_key.ParentReference)
		rightValue := source.GetParent()
		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 WatchServiceAccountKeysRequest_FieldPathSelectorPageSize:
		leftValue := fpv.value.(int32)
		rightValue := source.GetPageSize()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case WatchServiceAccountKeysRequest_FieldPathSelectorPageToken:
		return 0, false
	case WatchServiceAccountKeysRequest_FieldPathSelectorOrderBy:
		return 0, false
	case WatchServiceAccountKeysRequest_FieldPathSelectorResumeToken:
		leftValue := fpv.value.(string)
		rightValue := source.GetResumeToken()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case WatchServiceAccountKeysRequest_FieldPathSelectorStartingTime:
		leftValue := fpv.value.(*timestamp.Timestamp)
		rightValue := source.GetStartingTime()
		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 WatchServiceAccountKeysRequest_FieldPathSelectorFilter:
		return 0, false
	case WatchServiceAccountKeysRequest_FieldPathSelectorFieldMask:
		return 0, false
	case WatchServiceAccountKeysRequest_FieldPathSelectorView:
		leftValue := fpv.value.(view.View)
		rightValue := source.GetView()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case WatchServiceAccountKeysRequest_FieldPathSelectorMaxChunkSize:
		leftValue := fpv.value.(int32)
		rightValue := source.GetMaxChunkSize()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for WatchServiceAccountKeysRequest: %d", fpv.selector))
	}
}

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

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

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

func MustParseWatchServiceAccountKeysRequest_FieldPathArrayItemValue(pathStr, valueStr string) WatchServiceAccountKeysRequest_FieldPathArrayItemValue {
	fpaiv, err := ParseWatchServiceAccountKeysRequest_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type WatchServiceAccountKeysRequest_FieldTerminalPathArrayItemValue struct {
	WatchServiceAccountKeysRequest_FieldTerminalPath
	value interface{}
}

var _ WatchServiceAccountKeysRequest_FieldPathArrayItemValue = (*WatchServiceAccountKeysRequest_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *WatchServiceAccountKeysRequest_FieldTerminalPathArrayItemValue) GetSingle(source *WatchServiceAccountKeysRequest) (interface{}, bool) {
	return nil, false
}

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

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

// WatchServiceAccountKeysRequest_FieldPathArrayOfValues allows storing slice of values for WatchServiceAccountKeysRequest fields according to their type
type WatchServiceAccountKeysRequest_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	WatchServiceAccountKeysRequest_FieldPath
}

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

func MustParseWatchServiceAccountKeysRequest_FieldPathArrayOfValues(pathStr, valuesStr string) WatchServiceAccountKeysRequest_FieldPathArrayOfValues {
	fpaov, err := ParseWatchServiceAccountKeysRequest_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type WatchServiceAccountKeysRequest_FieldTerminalPathArrayOfValues struct {
	WatchServiceAccountKeysRequest_FieldTerminalPath
	values interface{}
}

var _ WatchServiceAccountKeysRequest_FieldPathArrayOfValues = (*WatchServiceAccountKeysRequest_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *WatchServiceAccountKeysRequest_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case WatchServiceAccountKeysRequest_FieldPathSelectorType:
		for _, v := range fpaov.values.([]watch_type.WatchType) {
			values = append(values, v)
		}
	case WatchServiceAccountKeysRequest_FieldPathSelectorParent:
		for _, v := range fpaov.values.([]*service_account_key.ParentReference) {
			values = append(values, v)
		}
	case WatchServiceAccountKeysRequest_FieldPathSelectorPageSize:
		for _, v := range fpaov.values.([]int32) {
			values = append(values, v)
		}
	case WatchServiceAccountKeysRequest_FieldPathSelectorPageToken:
		for _, v := range fpaov.values.([]*service_account_key.PagerCursor) {
			values = append(values, v)
		}
	case WatchServiceAccountKeysRequest_FieldPathSelectorOrderBy:
		for _, v := range fpaov.values.([]*service_account_key.OrderBy) {
			values = append(values, v)
		}
	case WatchServiceAccountKeysRequest_FieldPathSelectorResumeToken:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case WatchServiceAccountKeysRequest_FieldPathSelectorStartingTime:
		for _, v := range fpaov.values.([]*timestamp.Timestamp) {
			values = append(values, v)
		}
	case WatchServiceAccountKeysRequest_FieldPathSelectorFilter:
		for _, v := range fpaov.values.([]*service_account_key.Filter) {
			values = append(values, v)
		}
	case WatchServiceAccountKeysRequest_FieldPathSelectorFieldMask:
		for _, v := range fpaov.values.([]*service_account_key.ServiceAccountKey_FieldMask) {
			values = append(values, v)
		}
	case WatchServiceAccountKeysRequest_FieldPathSelectorView:
		for _, v := range fpaov.values.([]view.View) {
			values = append(values, v)
		}
	case WatchServiceAccountKeysRequest_FieldPathSelectorMaxChunkSize:
		for _, v := range fpaov.values.([]int32) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *WatchServiceAccountKeysRequest_FieldTerminalPathArrayOfValues) AsTypeArrayOfValues() ([]watch_type.WatchType, bool) {
	res, ok := fpaov.values.([]watch_type.WatchType)
	return res, ok
}
func (fpaov *WatchServiceAccountKeysRequest_FieldTerminalPathArrayOfValues) AsParentArrayOfValues() ([]*service_account_key.ParentReference, bool) {
	res, ok := fpaov.values.([]*service_account_key.ParentReference)
	return res, ok
}
func (fpaov *WatchServiceAccountKeysRequest_FieldTerminalPathArrayOfValues) AsPageSizeArrayOfValues() ([]int32, bool) {
	res, ok := fpaov.values.([]int32)
	return res, ok
}
func (fpaov *WatchServiceAccountKeysRequest_FieldTerminalPathArrayOfValues) AsPageTokenArrayOfValues() ([]*service_account_key.PagerCursor, bool) {
	res, ok := fpaov.values.([]*service_account_key.PagerCursor)
	return res, ok
}
func (fpaov *WatchServiceAccountKeysRequest_FieldTerminalPathArrayOfValues) AsOrderByArrayOfValues() ([]*service_account_key.OrderBy, bool) {
	res, ok := fpaov.values.([]*service_account_key.OrderBy)
	return res, ok
}
func (fpaov *WatchServiceAccountKeysRequest_FieldTerminalPathArrayOfValues) AsResumeTokenArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *WatchServiceAccountKeysRequest_FieldTerminalPathArrayOfValues) AsStartingTimeArrayOfValues() ([]*timestamp.Timestamp, bool) {
	res, ok := fpaov.values.([]*timestamp.Timestamp)
	return res, ok
}
func (fpaov *WatchServiceAccountKeysRequest_FieldTerminalPathArrayOfValues) AsFilterArrayOfValues() ([]*service_account_key.Filter, bool) {
	res, ok := fpaov.values.([]*service_account_key.Filter)
	return res, ok
}
func (fpaov *WatchServiceAccountKeysRequest_FieldTerminalPathArrayOfValues) AsFieldMaskArrayOfValues() ([]*service_account_key.ServiceAccountKey_FieldMask, bool) {
	res, ok := fpaov.values.([]*service_account_key.ServiceAccountKey_FieldMask)
	return res, ok
}
func (fpaov *WatchServiceAccountKeysRequest_FieldTerminalPathArrayOfValues) AsViewArrayOfValues() ([]view.View, bool) {
	res, ok := fpaov.values.([]view.View)
	return res, ok
}
func (fpaov *WatchServiceAccountKeysRequest_FieldTerminalPathArrayOfValues) AsMaxChunkSizeArrayOfValues() ([]int32, bool) {
	res, ok := fpaov.values.([]int32)
	return res, ok
}

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

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

type WatchServiceAccountKeysResponse_FieldPathSelector int32

const (
	WatchServiceAccountKeysResponse_FieldPathSelectorServiceAccountKeyChanges WatchServiceAccountKeysResponse_FieldPathSelector = 0
	WatchServiceAccountKeysResponse_FieldPathSelectorIsCurrent                WatchServiceAccountKeysResponse_FieldPathSelector = 1
	WatchServiceAccountKeysResponse_FieldPathSelectorPageTokenChange          WatchServiceAccountKeysResponse_FieldPathSelector = 2
	WatchServiceAccountKeysResponse_FieldPathSelectorResumeToken              WatchServiceAccountKeysResponse_FieldPathSelector = 3
	WatchServiceAccountKeysResponse_FieldPathSelectorSnapshotSize             WatchServiceAccountKeysResponse_FieldPathSelector = 4
	WatchServiceAccountKeysResponse_FieldPathSelectorIsSoftReset              WatchServiceAccountKeysResponse_FieldPathSelector = 5
	WatchServiceAccountKeysResponse_FieldPathSelectorIsHardReset              WatchServiceAccountKeysResponse_FieldPathSelector = 6
)

func (s WatchServiceAccountKeysResponse_FieldPathSelector) String() string {
	switch s {
	case WatchServiceAccountKeysResponse_FieldPathSelectorServiceAccountKeyChanges:
		return "service_account_key_changes"
	case WatchServiceAccountKeysResponse_FieldPathSelectorIsCurrent:
		return "is_current"
	case WatchServiceAccountKeysResponse_FieldPathSelectorPageTokenChange:
		return "page_token_change"
	case WatchServiceAccountKeysResponse_FieldPathSelectorResumeToken:
		return "resume_token"
	case WatchServiceAccountKeysResponse_FieldPathSelectorSnapshotSize:
		return "snapshot_size"
	case WatchServiceAccountKeysResponse_FieldPathSelectorIsSoftReset:
		return "is_soft_reset"
	case WatchServiceAccountKeysResponse_FieldPathSelectorIsHardReset:
		return "is_hard_reset"
	default:
		panic(fmt.Sprintf("Invalid selector for WatchServiceAccountKeysResponse: %d", s))
	}
}

func BuildWatchServiceAccountKeysResponse_FieldPath(fp gotenobject.RawFieldPath) (WatchServiceAccountKeysResponse_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object WatchServiceAccountKeysResponse")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "service_account_key_changes", "serviceAccountKeyChanges", "service-account-key-changes":
			return &WatchServiceAccountKeysResponse_FieldTerminalPath{selector: WatchServiceAccountKeysResponse_FieldPathSelectorServiceAccountKeyChanges}, nil
		case "is_current", "isCurrent", "is-current":
			return &WatchServiceAccountKeysResponse_FieldTerminalPath{selector: WatchServiceAccountKeysResponse_FieldPathSelectorIsCurrent}, nil
		case "page_token_change", "pageTokenChange", "page-token-change":
			return &WatchServiceAccountKeysResponse_FieldTerminalPath{selector: WatchServiceAccountKeysResponse_FieldPathSelectorPageTokenChange}, nil
		case "resume_token", "resumeToken", "resume-token":
			return &WatchServiceAccountKeysResponse_FieldTerminalPath{selector: WatchServiceAccountKeysResponse_FieldPathSelectorResumeToken}, nil
		case "snapshot_size", "snapshotSize", "snapshot-size":
			return &WatchServiceAccountKeysResponse_FieldTerminalPath{selector: WatchServiceAccountKeysResponse_FieldPathSelectorSnapshotSize}, nil
		case "is_soft_reset", "isSoftReset", "is-soft-reset":
			return &WatchServiceAccountKeysResponse_FieldTerminalPath{selector: WatchServiceAccountKeysResponse_FieldPathSelectorIsSoftReset}, nil
		case "is_hard_reset", "isHardReset", "is-hard-reset":
			return &WatchServiceAccountKeysResponse_FieldTerminalPath{selector: WatchServiceAccountKeysResponse_FieldPathSelectorIsHardReset}, nil
		}
	} else {
		switch fp[0] {
		case "page_token_change", "pageTokenChange", "page-token-change":
			if subpath, err := BuildWatchServiceAccountKeysResponsePageTokenChange_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &WatchServiceAccountKeysResponse_FieldSubPath{selector: WatchServiceAccountKeysResponse_FieldPathSelectorPageTokenChange, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object WatchServiceAccountKeysResponse", fp)
}

func ParseWatchServiceAccountKeysResponse_FieldPath(rawField string) (WatchServiceAccountKeysResponse_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildWatchServiceAccountKeysResponse_FieldPath(fp)
}

func MustParseWatchServiceAccountKeysResponse_FieldPath(rawField string) WatchServiceAccountKeysResponse_FieldPath {
	fp, err := ParseWatchServiceAccountKeysResponse_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type WatchServiceAccountKeysResponse_FieldTerminalPath struct {
	selector WatchServiceAccountKeysResponse_FieldPathSelector
}

var _ WatchServiceAccountKeysResponse_FieldPath = (*WatchServiceAccountKeysResponse_FieldTerminalPath)(nil)

func (fp *WatchServiceAccountKeysResponse_FieldTerminalPath) Selector() WatchServiceAccountKeysResponse_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source WatchServiceAccountKeysResponse
func (fp *WatchServiceAccountKeysResponse_FieldTerminalPath) Get(source *WatchServiceAccountKeysResponse) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case WatchServiceAccountKeysResponse_FieldPathSelectorServiceAccountKeyChanges:
			for _, value := range source.GetServiceAccountKeyChanges() {
				values = append(values, value)
			}
		case WatchServiceAccountKeysResponse_FieldPathSelectorIsCurrent:
			values = append(values, source.IsCurrent)
		case WatchServiceAccountKeysResponse_FieldPathSelectorPageTokenChange:
			if source.PageTokenChange != nil {
				values = append(values, source.PageTokenChange)
			}
		case WatchServiceAccountKeysResponse_FieldPathSelectorResumeToken:
			values = append(values, source.ResumeToken)
		case WatchServiceAccountKeysResponse_FieldPathSelectorSnapshotSize:
			values = append(values, source.SnapshotSize)
		case WatchServiceAccountKeysResponse_FieldPathSelectorIsSoftReset:
			values = append(values, source.IsSoftReset)
		case WatchServiceAccountKeysResponse_FieldPathSelectorIsHardReset:
			values = append(values, source.IsHardReset)
		default:
			panic(fmt.Sprintf("Invalid selector for WatchServiceAccountKeysResponse: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source WatchServiceAccountKeysResponse
func (fp *WatchServiceAccountKeysResponse_FieldTerminalPath) GetSingle(source *WatchServiceAccountKeysResponse) (interface{}, bool) {
	switch fp.selector {
	case WatchServiceAccountKeysResponse_FieldPathSelectorServiceAccountKeyChanges:
		res := source.GetServiceAccountKeyChanges()
		return res, res != nil
	case WatchServiceAccountKeysResponse_FieldPathSelectorIsCurrent:
		return source.GetIsCurrent(), source != nil
	case WatchServiceAccountKeysResponse_FieldPathSelectorPageTokenChange:
		res := source.GetPageTokenChange()
		return res, res != nil
	case WatchServiceAccountKeysResponse_FieldPathSelectorResumeToken:
		return source.GetResumeToken(), source != nil
	case WatchServiceAccountKeysResponse_FieldPathSelectorSnapshotSize:
		return source.GetSnapshotSize(), source != nil
	case WatchServiceAccountKeysResponse_FieldPathSelectorIsSoftReset:
		return source.GetIsSoftReset(), source != nil
	case WatchServiceAccountKeysResponse_FieldPathSelectorIsHardReset:
		return source.GetIsHardReset(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for WatchServiceAccountKeysResponse: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *WatchServiceAccountKeysResponse_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case WatchServiceAccountKeysResponse_FieldPathSelectorServiceAccountKeyChanges:
		return ([]*service_account_key.ServiceAccountKeyChange)(nil)
	case WatchServiceAccountKeysResponse_FieldPathSelectorIsCurrent:
		return false
	case WatchServiceAccountKeysResponse_FieldPathSelectorPageTokenChange:
		return (*WatchServiceAccountKeysResponse_PageTokenChange)(nil)
	case WatchServiceAccountKeysResponse_FieldPathSelectorResumeToken:
		return ""
	case WatchServiceAccountKeysResponse_FieldPathSelectorSnapshotSize:
		return int64(0)
	case WatchServiceAccountKeysResponse_FieldPathSelectorIsSoftReset:
		return false
	case WatchServiceAccountKeysResponse_FieldPathSelectorIsHardReset:
		return false
	default:
		panic(fmt.Sprintf("Invalid selector for WatchServiceAccountKeysResponse: %d", fp.selector))
	}
}

func (fp *WatchServiceAccountKeysResponse_FieldTerminalPath) ClearValue(item *WatchServiceAccountKeysResponse) {
	if item != nil {
		switch fp.selector {
		case WatchServiceAccountKeysResponse_FieldPathSelectorServiceAccountKeyChanges:
			item.ServiceAccountKeyChanges = nil
		case WatchServiceAccountKeysResponse_FieldPathSelectorIsCurrent:
			item.IsCurrent = false
		case WatchServiceAccountKeysResponse_FieldPathSelectorPageTokenChange:
			item.PageTokenChange = nil
		case WatchServiceAccountKeysResponse_FieldPathSelectorResumeToken:
			item.ResumeToken = ""
		case WatchServiceAccountKeysResponse_FieldPathSelectorSnapshotSize:
			item.SnapshotSize = int64(0)
		case WatchServiceAccountKeysResponse_FieldPathSelectorIsSoftReset:
			item.IsSoftReset = false
		case WatchServiceAccountKeysResponse_FieldPathSelectorIsHardReset:
			item.IsHardReset = false
		default:
			panic(fmt.Sprintf("Invalid selector for WatchServiceAccountKeysResponse: %d", fp.selector))
		}
	}
}

func (fp *WatchServiceAccountKeysResponse_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*WatchServiceAccountKeysResponse))
}

// IsLeaf - whether field path is holds simple value
func (fp *WatchServiceAccountKeysResponse_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == WatchServiceAccountKeysResponse_FieldPathSelectorServiceAccountKeyChanges ||
		fp.selector == WatchServiceAccountKeysResponse_FieldPathSelectorIsCurrent ||
		fp.selector == WatchServiceAccountKeysResponse_FieldPathSelectorResumeToken ||
		fp.selector == WatchServiceAccountKeysResponse_FieldPathSelectorSnapshotSize ||
		fp.selector == WatchServiceAccountKeysResponse_FieldPathSelectorIsSoftReset ||
		fp.selector == WatchServiceAccountKeysResponse_FieldPathSelectorIsHardReset
}

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

func (fp *WatchServiceAccountKeysResponse_FieldTerminalPath) WithIValue(value interface{}) WatchServiceAccountKeysResponse_FieldPathValue {
	switch fp.selector {
	case WatchServiceAccountKeysResponse_FieldPathSelectorServiceAccountKeyChanges:
		return &WatchServiceAccountKeysResponse_FieldTerminalPathValue{WatchServiceAccountKeysResponse_FieldTerminalPath: *fp, value: value.([]*service_account_key.ServiceAccountKeyChange)}
	case WatchServiceAccountKeysResponse_FieldPathSelectorIsCurrent:
		return &WatchServiceAccountKeysResponse_FieldTerminalPathValue{WatchServiceAccountKeysResponse_FieldTerminalPath: *fp, value: value.(bool)}
	case WatchServiceAccountKeysResponse_FieldPathSelectorPageTokenChange:
		return &WatchServiceAccountKeysResponse_FieldTerminalPathValue{WatchServiceAccountKeysResponse_FieldTerminalPath: *fp, value: value.(*WatchServiceAccountKeysResponse_PageTokenChange)}
	case WatchServiceAccountKeysResponse_FieldPathSelectorResumeToken:
		return &WatchServiceAccountKeysResponse_FieldTerminalPathValue{WatchServiceAccountKeysResponse_FieldTerminalPath: *fp, value: value.(string)}
	case WatchServiceAccountKeysResponse_FieldPathSelectorSnapshotSize:
		return &WatchServiceAccountKeysResponse_FieldTerminalPathValue{WatchServiceAccountKeysResponse_FieldTerminalPath: *fp, value: value.(int64)}
	case WatchServiceAccountKeysResponse_FieldPathSelectorIsSoftReset:
		return &WatchServiceAccountKeysResponse_FieldTerminalPathValue{WatchServiceAccountKeysResponse_FieldTerminalPath: *fp, value: value.(bool)}
	case WatchServiceAccountKeysResponse_FieldPathSelectorIsHardReset:
		return &WatchServiceAccountKeysResponse_FieldTerminalPathValue{WatchServiceAccountKeysResponse_FieldTerminalPath: *fp, value: value.(bool)}
	default:
		panic(fmt.Sprintf("Invalid selector for WatchServiceAccountKeysResponse: %d", fp.selector))
	}
}

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

func (fp *WatchServiceAccountKeysResponse_FieldTerminalPath) WithIArrayOfValues(values interface{}) WatchServiceAccountKeysResponse_FieldPathArrayOfValues {
	fpaov := &WatchServiceAccountKeysResponse_FieldTerminalPathArrayOfValues{WatchServiceAccountKeysResponse_FieldTerminalPath: *fp}
	switch fp.selector {
	case WatchServiceAccountKeysResponse_FieldPathSelectorServiceAccountKeyChanges:
		return &WatchServiceAccountKeysResponse_FieldTerminalPathArrayOfValues{WatchServiceAccountKeysResponse_FieldTerminalPath: *fp, values: values.([][]*service_account_key.ServiceAccountKeyChange)}
	case WatchServiceAccountKeysResponse_FieldPathSelectorIsCurrent:
		return &WatchServiceAccountKeysResponse_FieldTerminalPathArrayOfValues{WatchServiceAccountKeysResponse_FieldTerminalPath: *fp, values: values.([]bool)}
	case WatchServiceAccountKeysResponse_FieldPathSelectorPageTokenChange:
		return &WatchServiceAccountKeysResponse_FieldTerminalPathArrayOfValues{WatchServiceAccountKeysResponse_FieldTerminalPath: *fp, values: values.([]*WatchServiceAccountKeysResponse_PageTokenChange)}
	case WatchServiceAccountKeysResponse_FieldPathSelectorResumeToken:
		return &WatchServiceAccountKeysResponse_FieldTerminalPathArrayOfValues{WatchServiceAccountKeysResponse_FieldTerminalPath: *fp, values: values.([]string)}
	case WatchServiceAccountKeysResponse_FieldPathSelectorSnapshotSize:
		return &WatchServiceAccountKeysResponse_FieldTerminalPathArrayOfValues{WatchServiceAccountKeysResponse_FieldTerminalPath: *fp, values: values.([]int64)}
	case WatchServiceAccountKeysResponse_FieldPathSelectorIsSoftReset:
		return &WatchServiceAccountKeysResponse_FieldTerminalPathArrayOfValues{WatchServiceAccountKeysResponse_FieldTerminalPath: *fp, values: values.([]bool)}
	case WatchServiceAccountKeysResponse_FieldPathSelectorIsHardReset:
		return &WatchServiceAccountKeysResponse_FieldTerminalPathArrayOfValues{WatchServiceAccountKeysResponse_FieldTerminalPath: *fp, values: values.([]bool)}
	default:
		panic(fmt.Sprintf("Invalid selector for WatchServiceAccountKeysResponse: %d", fp.selector))
	}
	return fpaov
}

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

func (fp *WatchServiceAccountKeysResponse_FieldTerminalPath) WithIArrayItemValue(value interface{}) WatchServiceAccountKeysResponse_FieldPathArrayItemValue {
	switch fp.selector {
	case WatchServiceAccountKeysResponse_FieldPathSelectorServiceAccountKeyChanges:
		return &WatchServiceAccountKeysResponse_FieldTerminalPathArrayItemValue{WatchServiceAccountKeysResponse_FieldTerminalPath: *fp, value: value.(*service_account_key.ServiceAccountKeyChange)}
	default:
		panic(fmt.Sprintf("Invalid selector for WatchServiceAccountKeysResponse: %d", fp.selector))
	}
}

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

type WatchServiceAccountKeysResponse_FieldSubPath struct {
	selector WatchServiceAccountKeysResponse_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ WatchServiceAccountKeysResponse_FieldPath = (*WatchServiceAccountKeysResponse_FieldSubPath)(nil)

func (fps *WatchServiceAccountKeysResponse_FieldSubPath) Selector() WatchServiceAccountKeysResponse_FieldPathSelector {
	return fps.selector
}
func (fps *WatchServiceAccountKeysResponse_FieldSubPath) AsPageTokenChangeSubPath() (WatchServiceAccountKeysResponsePageTokenChange_FieldPath, bool) {
	res, ok := fps.subPath.(WatchServiceAccountKeysResponsePageTokenChange_FieldPath)
	return res, ok
}

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

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

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

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

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

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

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

func (fps *WatchServiceAccountKeysResponse_FieldSubPath) ClearValue(item *WatchServiceAccountKeysResponse) {
	if item != nil {
		switch fps.selector {
		case WatchServiceAccountKeysResponse_FieldPathSelectorPageTokenChange:
			fps.subPath.ClearValueRaw(item.PageTokenChange)
		default:
			panic(fmt.Sprintf("Invalid selector for WatchServiceAccountKeysResponse: %d", fps.selector))
		}
	}
}

func (fps *WatchServiceAccountKeysResponse_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*WatchServiceAccountKeysResponse))
}

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

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

func (fps *WatchServiceAccountKeysResponse_FieldSubPath) WithIValue(value interface{}) WatchServiceAccountKeysResponse_FieldPathValue {
	return &WatchServiceAccountKeysResponse_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *WatchServiceAccountKeysResponse_FieldSubPath) WithIArrayOfValues(values interface{}) WatchServiceAccountKeysResponse_FieldPathArrayOfValues {
	return &WatchServiceAccountKeysResponse_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *WatchServiceAccountKeysResponse_FieldSubPath) WithIArrayItemValue(value interface{}) WatchServiceAccountKeysResponse_FieldPathArrayItemValue {
	return &WatchServiceAccountKeysResponse_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

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

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

func MustParseWatchServiceAccountKeysResponse_FieldPathValue(pathStr, valueStr string) WatchServiceAccountKeysResponse_FieldPathValue {
	fpv, err := ParseWatchServiceAccountKeysResponse_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type WatchServiceAccountKeysResponse_FieldTerminalPathValue struct {
	WatchServiceAccountKeysResponse_FieldTerminalPath
	value interface{}
}

var _ WatchServiceAccountKeysResponse_FieldPathValue = (*WatchServiceAccountKeysResponse_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'WatchServiceAccountKeysResponse' as interface{}
func (fpv *WatchServiceAccountKeysResponse_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *WatchServiceAccountKeysResponse_FieldTerminalPathValue) AsServiceAccountKeyChangesValue() ([]*service_account_key.ServiceAccountKeyChange, bool) {
	res, ok := fpv.value.([]*service_account_key.ServiceAccountKeyChange)
	return res, ok
}
func (fpv *WatchServiceAccountKeysResponse_FieldTerminalPathValue) AsIsCurrentValue() (bool, bool) {
	res, ok := fpv.value.(bool)
	return res, ok
}
func (fpv *WatchServiceAccountKeysResponse_FieldTerminalPathValue) AsPageTokenChangeValue() (*WatchServiceAccountKeysResponse_PageTokenChange, bool) {
	res, ok := fpv.value.(*WatchServiceAccountKeysResponse_PageTokenChange)
	return res, ok
}
func (fpv *WatchServiceAccountKeysResponse_FieldTerminalPathValue) AsResumeTokenValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *WatchServiceAccountKeysResponse_FieldTerminalPathValue) AsSnapshotSizeValue() (int64, bool) {
	res, ok := fpv.value.(int64)
	return res, ok
}
func (fpv *WatchServiceAccountKeysResponse_FieldTerminalPathValue) AsIsSoftResetValue() (bool, bool) {
	res, ok := fpv.value.(bool)
	return res, ok
}
func (fpv *WatchServiceAccountKeysResponse_FieldTerminalPathValue) AsIsHardResetValue() (bool, bool) {
	res, ok := fpv.value.(bool)
	return res, ok
}

// SetTo stores value for selected field for object WatchServiceAccountKeysResponse
func (fpv *WatchServiceAccountKeysResponse_FieldTerminalPathValue) SetTo(target **WatchServiceAccountKeysResponse) {
	if *target == nil {
		*target = new(WatchServiceAccountKeysResponse)
	}
	switch fpv.selector {
	case WatchServiceAccountKeysResponse_FieldPathSelectorServiceAccountKeyChanges:
		(*target).ServiceAccountKeyChanges = fpv.value.([]*service_account_key.ServiceAccountKeyChange)
	case WatchServiceAccountKeysResponse_FieldPathSelectorIsCurrent:
		(*target).IsCurrent = fpv.value.(bool)
	case WatchServiceAccountKeysResponse_FieldPathSelectorPageTokenChange:
		(*target).PageTokenChange = fpv.value.(*WatchServiceAccountKeysResponse_PageTokenChange)
	case WatchServiceAccountKeysResponse_FieldPathSelectorResumeToken:
		(*target).ResumeToken = fpv.value.(string)
	case WatchServiceAccountKeysResponse_FieldPathSelectorSnapshotSize:
		(*target).SnapshotSize = fpv.value.(int64)
	case WatchServiceAccountKeysResponse_FieldPathSelectorIsSoftReset:
		(*target).IsSoftReset = fpv.value.(bool)
	case WatchServiceAccountKeysResponse_FieldPathSelectorIsHardReset:
		(*target).IsHardReset = fpv.value.(bool)
	default:
		panic(fmt.Sprintf("Invalid selector for WatchServiceAccountKeysResponse: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'WatchServiceAccountKeysResponse_FieldTerminalPathValue' with the value under path in 'WatchServiceAccountKeysResponse'.
func (fpv *WatchServiceAccountKeysResponse_FieldTerminalPathValue) CompareWith(source *WatchServiceAccountKeysResponse) (int, bool) {
	switch fpv.selector {
	case WatchServiceAccountKeysResponse_FieldPathSelectorServiceAccountKeyChanges:
		return 0, false
	case WatchServiceAccountKeysResponse_FieldPathSelectorIsCurrent:
		leftValue := fpv.value.(bool)
		rightValue := source.GetIsCurrent()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if !(leftValue) && (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case WatchServiceAccountKeysResponse_FieldPathSelectorPageTokenChange:
		return 0, false
	case WatchServiceAccountKeysResponse_FieldPathSelectorResumeToken:
		leftValue := fpv.value.(string)
		rightValue := source.GetResumeToken()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case WatchServiceAccountKeysResponse_FieldPathSelectorSnapshotSize:
		leftValue := fpv.value.(int64)
		rightValue := source.GetSnapshotSize()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case WatchServiceAccountKeysResponse_FieldPathSelectorIsSoftReset:
		leftValue := fpv.value.(bool)
		rightValue := source.GetIsSoftReset()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if !(leftValue) && (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case WatchServiceAccountKeysResponse_FieldPathSelectorIsHardReset:
		leftValue := fpv.value.(bool)
		rightValue := source.GetIsHardReset()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if !(leftValue) && (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for WatchServiceAccountKeysResponse: %d", fpv.selector))
	}
}

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

type WatchServiceAccountKeysResponse_FieldSubPathValue struct {
	WatchServiceAccountKeysResponse_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ WatchServiceAccountKeysResponse_FieldPathValue = (*WatchServiceAccountKeysResponse_FieldSubPathValue)(nil)

func (fpvs *WatchServiceAccountKeysResponse_FieldSubPathValue) AsPageTokenChangePathValue() (WatchServiceAccountKeysResponsePageTokenChange_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(WatchServiceAccountKeysResponsePageTokenChange_FieldPathValue)
	return res, ok
}

func (fpvs *WatchServiceAccountKeysResponse_FieldSubPathValue) SetTo(target **WatchServiceAccountKeysResponse) {
	if *target == nil {
		*target = new(WatchServiceAccountKeysResponse)
	}
	switch fpvs.Selector() {
	case WatchServiceAccountKeysResponse_FieldPathSelectorPageTokenChange:
		fpvs.subPathValue.(WatchServiceAccountKeysResponsePageTokenChange_FieldPathValue).SetTo(&(*target).PageTokenChange)
	default:
		panic(fmt.Sprintf("Invalid selector for WatchServiceAccountKeysResponse: %d", fpvs.Selector()))
	}
}

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

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

func (fpvs *WatchServiceAccountKeysResponse_FieldSubPathValue) CompareWith(source *WatchServiceAccountKeysResponse) (int, bool) {
	switch fpvs.Selector() {
	case WatchServiceAccountKeysResponse_FieldPathSelectorPageTokenChange:
		return fpvs.subPathValue.(WatchServiceAccountKeysResponsePageTokenChange_FieldPathValue).CompareWith(source.GetPageTokenChange())
	default:
		panic(fmt.Sprintf("Invalid selector for WatchServiceAccountKeysResponse: %d", fpvs.Selector()))
	}
}

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

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

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

func MustParseWatchServiceAccountKeysResponse_FieldPathArrayItemValue(pathStr, valueStr string) WatchServiceAccountKeysResponse_FieldPathArrayItemValue {
	fpaiv, err := ParseWatchServiceAccountKeysResponse_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type WatchServiceAccountKeysResponse_FieldTerminalPathArrayItemValue struct {
	WatchServiceAccountKeysResponse_FieldTerminalPath
	value interface{}
}

var _ WatchServiceAccountKeysResponse_FieldPathArrayItemValue = (*WatchServiceAccountKeysResponse_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object WatchServiceAccountKeysResponse as interface{}
func (fpaiv *WatchServiceAccountKeysResponse_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}
func (fpaiv *WatchServiceAccountKeysResponse_FieldTerminalPathArrayItemValue) AsServiceAccountKeyChangesItemValue() (*service_account_key.ServiceAccountKeyChange, bool) {
	res, ok := fpaiv.value.(*service_account_key.ServiceAccountKeyChange)
	return res, ok
}

func (fpaiv *WatchServiceAccountKeysResponse_FieldTerminalPathArrayItemValue) GetSingle(source *WatchServiceAccountKeysResponse) (interface{}, bool) {
	return nil, false
}

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

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

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

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

// WatchServiceAccountKeysResponse_FieldPathArrayOfValues allows storing slice of values for WatchServiceAccountKeysResponse fields according to their type
type WatchServiceAccountKeysResponse_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	WatchServiceAccountKeysResponse_FieldPath
}

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

func MustParseWatchServiceAccountKeysResponse_FieldPathArrayOfValues(pathStr, valuesStr string) WatchServiceAccountKeysResponse_FieldPathArrayOfValues {
	fpaov, err := ParseWatchServiceAccountKeysResponse_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type WatchServiceAccountKeysResponse_FieldTerminalPathArrayOfValues struct {
	WatchServiceAccountKeysResponse_FieldTerminalPath
	values interface{}
}

var _ WatchServiceAccountKeysResponse_FieldPathArrayOfValues = (*WatchServiceAccountKeysResponse_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *WatchServiceAccountKeysResponse_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case WatchServiceAccountKeysResponse_FieldPathSelectorServiceAccountKeyChanges:
		for _, v := range fpaov.values.([][]*service_account_key.ServiceAccountKeyChange) {
			values = append(values, v)
		}
	case WatchServiceAccountKeysResponse_FieldPathSelectorIsCurrent:
		for _, v := range fpaov.values.([]bool) {
			values = append(values, v)
		}
	case WatchServiceAccountKeysResponse_FieldPathSelectorPageTokenChange:
		for _, v := range fpaov.values.([]*WatchServiceAccountKeysResponse_PageTokenChange) {
			values = append(values, v)
		}
	case WatchServiceAccountKeysResponse_FieldPathSelectorResumeToken:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case WatchServiceAccountKeysResponse_FieldPathSelectorSnapshotSize:
		for _, v := range fpaov.values.([]int64) {
			values = append(values, v)
		}
	case WatchServiceAccountKeysResponse_FieldPathSelectorIsSoftReset:
		for _, v := range fpaov.values.([]bool) {
			values = append(values, v)
		}
	case WatchServiceAccountKeysResponse_FieldPathSelectorIsHardReset:
		for _, v := range fpaov.values.([]bool) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *WatchServiceAccountKeysResponse_FieldTerminalPathArrayOfValues) AsServiceAccountKeyChangesArrayOfValues() ([][]*service_account_key.ServiceAccountKeyChange, bool) {
	res, ok := fpaov.values.([][]*service_account_key.ServiceAccountKeyChange)
	return res, ok
}
func (fpaov *WatchServiceAccountKeysResponse_FieldTerminalPathArrayOfValues) AsIsCurrentArrayOfValues() ([]bool, bool) {
	res, ok := fpaov.values.([]bool)
	return res, ok
}
func (fpaov *WatchServiceAccountKeysResponse_FieldTerminalPathArrayOfValues) AsPageTokenChangeArrayOfValues() ([]*WatchServiceAccountKeysResponse_PageTokenChange, bool) {
	res, ok := fpaov.values.([]*WatchServiceAccountKeysResponse_PageTokenChange)
	return res, ok
}
func (fpaov *WatchServiceAccountKeysResponse_FieldTerminalPathArrayOfValues) AsResumeTokenArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *WatchServiceAccountKeysResponse_FieldTerminalPathArrayOfValues) AsSnapshotSizeArrayOfValues() ([]int64, bool) {
	res, ok := fpaov.values.([]int64)
	return res, ok
}
func (fpaov *WatchServiceAccountKeysResponse_FieldTerminalPathArrayOfValues) AsIsSoftResetArrayOfValues() ([]bool, bool) {
	res, ok := fpaov.values.([]bool)
	return res, ok
}
func (fpaov *WatchServiceAccountKeysResponse_FieldTerminalPathArrayOfValues) AsIsHardResetArrayOfValues() ([]bool, bool) {
	res, ok := fpaov.values.([]bool)
	return res, ok
}

type WatchServiceAccountKeysResponse_FieldSubPathArrayOfValues struct {
	WatchServiceAccountKeysResponse_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ WatchServiceAccountKeysResponse_FieldPathArrayOfValues = (*WatchServiceAccountKeysResponse_FieldSubPathArrayOfValues)(nil)

func (fpsaov *WatchServiceAccountKeysResponse_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *WatchServiceAccountKeysResponse_FieldSubPathArrayOfValues) AsPageTokenChangePathArrayOfValues() (WatchServiceAccountKeysResponsePageTokenChange_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(WatchServiceAccountKeysResponsePageTokenChange_FieldPathArrayOfValues)
	return res, ok
}

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

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

type WatchServiceAccountKeysResponsePageTokenChange_FieldPathSelector int32

const (
	WatchServiceAccountKeysResponsePageTokenChange_FieldPathSelectorPrevPageToken WatchServiceAccountKeysResponsePageTokenChange_FieldPathSelector = 0
	WatchServiceAccountKeysResponsePageTokenChange_FieldPathSelectorNextPageToken WatchServiceAccountKeysResponsePageTokenChange_FieldPathSelector = 1
)

func (s WatchServiceAccountKeysResponsePageTokenChange_FieldPathSelector) String() string {
	switch s {
	case WatchServiceAccountKeysResponsePageTokenChange_FieldPathSelectorPrevPageToken:
		return "prev_page_token"
	case WatchServiceAccountKeysResponsePageTokenChange_FieldPathSelectorNextPageToken:
		return "next_page_token"
	default:
		panic(fmt.Sprintf("Invalid selector for WatchServiceAccountKeysResponse_PageTokenChange: %d", s))
	}
}

func BuildWatchServiceAccountKeysResponsePageTokenChange_FieldPath(fp gotenobject.RawFieldPath) (WatchServiceAccountKeysResponsePageTokenChange_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object WatchServiceAccountKeysResponse_PageTokenChange")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "prev_page_token", "prevPageToken", "prev-page-token":
			return &WatchServiceAccountKeysResponsePageTokenChange_FieldTerminalPath{selector: WatchServiceAccountKeysResponsePageTokenChange_FieldPathSelectorPrevPageToken}, nil
		case "next_page_token", "nextPageToken", "next-page-token":
			return &WatchServiceAccountKeysResponsePageTokenChange_FieldTerminalPath{selector: WatchServiceAccountKeysResponsePageTokenChange_FieldPathSelectorNextPageToken}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object WatchServiceAccountKeysResponse_PageTokenChange", fp)
}

func ParseWatchServiceAccountKeysResponsePageTokenChange_FieldPath(rawField string) (WatchServiceAccountKeysResponsePageTokenChange_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildWatchServiceAccountKeysResponsePageTokenChange_FieldPath(fp)
}

func MustParseWatchServiceAccountKeysResponsePageTokenChange_FieldPath(rawField string) WatchServiceAccountKeysResponsePageTokenChange_FieldPath {
	fp, err := ParseWatchServiceAccountKeysResponsePageTokenChange_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type WatchServiceAccountKeysResponsePageTokenChange_FieldTerminalPath struct {
	selector WatchServiceAccountKeysResponsePageTokenChange_FieldPathSelector
}

var _ WatchServiceAccountKeysResponsePageTokenChange_FieldPath = (*WatchServiceAccountKeysResponsePageTokenChange_FieldTerminalPath)(nil)

func (fp *WatchServiceAccountKeysResponsePageTokenChange_FieldTerminalPath) Selector() WatchServiceAccountKeysResponsePageTokenChange_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source WatchServiceAccountKeysResponse_PageTokenChange
func (fp *WatchServiceAccountKeysResponsePageTokenChange_FieldTerminalPath) Get(source *WatchServiceAccountKeysResponse_PageTokenChange) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case WatchServiceAccountKeysResponsePageTokenChange_FieldPathSelectorPrevPageToken:
			if source.PrevPageToken != nil {
				values = append(values, source.PrevPageToken)
			}
		case WatchServiceAccountKeysResponsePageTokenChange_FieldPathSelectorNextPageToken:
			if source.NextPageToken != nil {
				values = append(values, source.NextPageToken)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for WatchServiceAccountKeysResponse_PageTokenChange: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source WatchServiceAccountKeysResponse_PageTokenChange
func (fp *WatchServiceAccountKeysResponsePageTokenChange_FieldTerminalPath) GetSingle(source *WatchServiceAccountKeysResponse_PageTokenChange) (interface{}, bool) {
	switch fp.selector {
	case WatchServiceAccountKeysResponsePageTokenChange_FieldPathSelectorPrevPageToken:
		res := source.GetPrevPageToken()
		return res, res != nil
	case WatchServiceAccountKeysResponsePageTokenChange_FieldPathSelectorNextPageToken:
		res := source.GetNextPageToken()
		return res, res != nil
	default:
		panic(fmt.Sprintf("Invalid selector for WatchServiceAccountKeysResponse_PageTokenChange: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *WatchServiceAccountKeysResponsePageTokenChange_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case WatchServiceAccountKeysResponsePageTokenChange_FieldPathSelectorPrevPageToken:
		return (*service_account_key.PagerCursor)(nil)
	case WatchServiceAccountKeysResponsePageTokenChange_FieldPathSelectorNextPageToken:
		return (*service_account_key.PagerCursor)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for WatchServiceAccountKeysResponse_PageTokenChange: %d", fp.selector))
	}
}

func (fp *WatchServiceAccountKeysResponsePageTokenChange_FieldTerminalPath) ClearValue(item *WatchServiceAccountKeysResponse_PageTokenChange) {
	if item != nil {
		switch fp.selector {
		case WatchServiceAccountKeysResponsePageTokenChange_FieldPathSelectorPrevPageToken:
			item.PrevPageToken = nil
		case WatchServiceAccountKeysResponsePageTokenChange_FieldPathSelectorNextPageToken:
			item.NextPageToken = nil
		default:
			panic(fmt.Sprintf("Invalid selector for WatchServiceAccountKeysResponse_PageTokenChange: %d", fp.selector))
		}
	}
}

func (fp *WatchServiceAccountKeysResponsePageTokenChange_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*WatchServiceAccountKeysResponse_PageTokenChange))
}

// IsLeaf - whether field path is holds simple value
func (fp *WatchServiceAccountKeysResponsePageTokenChange_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == WatchServiceAccountKeysResponsePageTokenChange_FieldPathSelectorPrevPageToken ||
		fp.selector == WatchServiceAccountKeysResponsePageTokenChange_FieldPathSelectorNextPageToken
}

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

func (fp *WatchServiceAccountKeysResponsePageTokenChange_FieldTerminalPath) WithIValue(value interface{}) WatchServiceAccountKeysResponsePageTokenChange_FieldPathValue {
	switch fp.selector {
	case WatchServiceAccountKeysResponsePageTokenChange_FieldPathSelectorPrevPageToken:
		return &WatchServiceAccountKeysResponsePageTokenChange_FieldTerminalPathValue{WatchServiceAccountKeysResponsePageTokenChange_FieldTerminalPath: *fp, value: value.(*service_account_key.PagerCursor)}
	case WatchServiceAccountKeysResponsePageTokenChange_FieldPathSelectorNextPageToken:
		return &WatchServiceAccountKeysResponsePageTokenChange_FieldTerminalPathValue{WatchServiceAccountKeysResponsePageTokenChange_FieldTerminalPath: *fp, value: value.(*service_account_key.PagerCursor)}
	default:
		panic(fmt.Sprintf("Invalid selector for WatchServiceAccountKeysResponse_PageTokenChange: %d", fp.selector))
	}
}

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

func (fp *WatchServiceAccountKeysResponsePageTokenChange_FieldTerminalPath) WithIArrayOfValues(values interface{}) WatchServiceAccountKeysResponsePageTokenChange_FieldPathArrayOfValues {
	fpaov := &WatchServiceAccountKeysResponsePageTokenChange_FieldTerminalPathArrayOfValues{WatchServiceAccountKeysResponsePageTokenChange_FieldTerminalPath: *fp}
	switch fp.selector {
	case WatchServiceAccountKeysResponsePageTokenChange_FieldPathSelectorPrevPageToken:
		return &WatchServiceAccountKeysResponsePageTokenChange_FieldTerminalPathArrayOfValues{WatchServiceAccountKeysResponsePageTokenChange_FieldTerminalPath: *fp, values: values.([]*service_account_key.PagerCursor)}
	case WatchServiceAccountKeysResponsePageTokenChange_FieldPathSelectorNextPageToken:
		return &WatchServiceAccountKeysResponsePageTokenChange_FieldTerminalPathArrayOfValues{WatchServiceAccountKeysResponsePageTokenChange_FieldTerminalPath: *fp, values: values.([]*service_account_key.PagerCursor)}
	default:
		panic(fmt.Sprintf("Invalid selector for WatchServiceAccountKeysResponse_PageTokenChange: %d", fp.selector))
	}
	return fpaov
}

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

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

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

// WatchServiceAccountKeysResponsePageTokenChange_FieldPathValue allows storing values for PageTokenChange fields according to their type
type WatchServiceAccountKeysResponsePageTokenChange_FieldPathValue interface {
	WatchServiceAccountKeysResponsePageTokenChange_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **WatchServiceAccountKeysResponse_PageTokenChange)
	CompareWith(*WatchServiceAccountKeysResponse_PageTokenChange) (cmp int, comparable bool)
}

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

func MustParseWatchServiceAccountKeysResponsePageTokenChange_FieldPathValue(pathStr, valueStr string) WatchServiceAccountKeysResponsePageTokenChange_FieldPathValue {
	fpv, err := ParseWatchServiceAccountKeysResponsePageTokenChange_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type WatchServiceAccountKeysResponsePageTokenChange_FieldTerminalPathValue struct {
	WatchServiceAccountKeysResponsePageTokenChange_FieldTerminalPath
	value interface{}
}

var _ WatchServiceAccountKeysResponsePageTokenChange_FieldPathValue = (*WatchServiceAccountKeysResponsePageTokenChange_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'PageTokenChange' as interface{}
func (fpv *WatchServiceAccountKeysResponsePageTokenChange_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *WatchServiceAccountKeysResponsePageTokenChange_FieldTerminalPathValue) AsPrevPageTokenValue() (*service_account_key.PagerCursor, bool) {
	res, ok := fpv.value.(*service_account_key.PagerCursor)
	return res, ok
}
func (fpv *WatchServiceAccountKeysResponsePageTokenChange_FieldTerminalPathValue) AsNextPageTokenValue() (*service_account_key.PagerCursor, bool) {
	res, ok := fpv.value.(*service_account_key.PagerCursor)
	return res, ok
}

// SetTo stores value for selected field for object PageTokenChange
func (fpv *WatchServiceAccountKeysResponsePageTokenChange_FieldTerminalPathValue) SetTo(target **WatchServiceAccountKeysResponse_PageTokenChange) {
	if *target == nil {
		*target = new(WatchServiceAccountKeysResponse_PageTokenChange)
	}
	switch fpv.selector {
	case WatchServiceAccountKeysResponsePageTokenChange_FieldPathSelectorPrevPageToken:
		(*target).PrevPageToken = fpv.value.(*service_account_key.PagerCursor)
	case WatchServiceAccountKeysResponsePageTokenChange_FieldPathSelectorNextPageToken:
		(*target).NextPageToken = fpv.value.(*service_account_key.PagerCursor)
	default:
		panic(fmt.Sprintf("Invalid selector for WatchServiceAccountKeysResponse_PageTokenChange: %d", fpv.selector))
	}
}

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

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

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

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

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

func MustParseWatchServiceAccountKeysResponsePageTokenChange_FieldPathArrayItemValue(pathStr, valueStr string) WatchServiceAccountKeysResponsePageTokenChange_FieldPathArrayItemValue {
	fpaiv, err := ParseWatchServiceAccountKeysResponsePageTokenChange_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type WatchServiceAccountKeysResponsePageTokenChange_FieldTerminalPathArrayItemValue struct {
	WatchServiceAccountKeysResponsePageTokenChange_FieldTerminalPath
	value interface{}
}

var _ WatchServiceAccountKeysResponsePageTokenChange_FieldPathArrayItemValue = (*WatchServiceAccountKeysResponsePageTokenChange_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *WatchServiceAccountKeysResponsePageTokenChange_FieldTerminalPathArrayItemValue) GetSingle(source *WatchServiceAccountKeysResponse_PageTokenChange) (interface{}, bool) {
	return nil, false
}

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

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

// WatchServiceAccountKeysResponsePageTokenChange_FieldPathArrayOfValues allows storing slice of values for PageTokenChange fields according to their type
type WatchServiceAccountKeysResponsePageTokenChange_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	WatchServiceAccountKeysResponsePageTokenChange_FieldPath
}

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

func MustParseWatchServiceAccountKeysResponsePageTokenChange_FieldPathArrayOfValues(pathStr, valuesStr string) WatchServiceAccountKeysResponsePageTokenChange_FieldPathArrayOfValues {
	fpaov, err := ParseWatchServiceAccountKeysResponsePageTokenChange_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type WatchServiceAccountKeysResponsePageTokenChange_FieldTerminalPathArrayOfValues struct {
	WatchServiceAccountKeysResponsePageTokenChange_FieldTerminalPath
	values interface{}
}

var _ WatchServiceAccountKeysResponsePageTokenChange_FieldPathArrayOfValues = (*WatchServiceAccountKeysResponsePageTokenChange_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *WatchServiceAccountKeysResponsePageTokenChange_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case WatchServiceAccountKeysResponsePageTokenChange_FieldPathSelectorPrevPageToken:
		for _, v := range fpaov.values.([]*service_account_key.PagerCursor) {
			values = append(values, v)
		}
	case WatchServiceAccountKeysResponsePageTokenChange_FieldPathSelectorNextPageToken:
		for _, v := range fpaov.values.([]*service_account_key.PagerCursor) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *WatchServiceAccountKeysResponsePageTokenChange_FieldTerminalPathArrayOfValues) AsPrevPageTokenArrayOfValues() ([]*service_account_key.PagerCursor, bool) {
	res, ok := fpaov.values.([]*service_account_key.PagerCursor)
	return res, ok
}
func (fpaov *WatchServiceAccountKeysResponsePageTokenChange_FieldTerminalPathArrayOfValues) AsNextPageTokenArrayOfValues() ([]*service_account_key.PagerCursor, bool) {
	res, ok := fpaov.values.([]*service_account_key.PagerCursor)
	return res, ok
}

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

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

type CreateServiceAccountKeyRequest_FieldPathSelector int32

const (
	CreateServiceAccountKeyRequest_FieldPathSelectorParent            CreateServiceAccountKeyRequest_FieldPathSelector = 0
	CreateServiceAccountKeyRequest_FieldPathSelectorServiceAccountKey CreateServiceAccountKeyRequest_FieldPathSelector = 1
)

func (s CreateServiceAccountKeyRequest_FieldPathSelector) String() string {
	switch s {
	case CreateServiceAccountKeyRequest_FieldPathSelectorParent:
		return "parent"
	case CreateServiceAccountKeyRequest_FieldPathSelectorServiceAccountKey:
		return "service_account_key"
	default:
		panic(fmt.Sprintf("Invalid selector for CreateServiceAccountKeyRequest: %d", s))
	}
}

func BuildCreateServiceAccountKeyRequest_FieldPath(fp gotenobject.RawFieldPath) (CreateServiceAccountKeyRequest_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object CreateServiceAccountKeyRequest")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "parent":
			return &CreateServiceAccountKeyRequest_FieldTerminalPath{selector: CreateServiceAccountKeyRequest_FieldPathSelectorParent}, nil
		case "service_account_key", "serviceAccountKey", "service-account-key":
			return &CreateServiceAccountKeyRequest_FieldTerminalPath{selector: CreateServiceAccountKeyRequest_FieldPathSelectorServiceAccountKey}, nil
		}
	} else {
		switch fp[0] {
		case "service_account_key", "serviceAccountKey", "service-account-key":
			if subpath, err := service_account_key.BuildServiceAccountKey_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &CreateServiceAccountKeyRequest_FieldSubPath{selector: CreateServiceAccountKeyRequest_FieldPathSelectorServiceAccountKey, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object CreateServiceAccountKeyRequest", fp)
}

func ParseCreateServiceAccountKeyRequest_FieldPath(rawField string) (CreateServiceAccountKeyRequest_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildCreateServiceAccountKeyRequest_FieldPath(fp)
}

func MustParseCreateServiceAccountKeyRequest_FieldPath(rawField string) CreateServiceAccountKeyRequest_FieldPath {
	fp, err := ParseCreateServiceAccountKeyRequest_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type CreateServiceAccountKeyRequest_FieldTerminalPath struct {
	selector CreateServiceAccountKeyRequest_FieldPathSelector
}

var _ CreateServiceAccountKeyRequest_FieldPath = (*CreateServiceAccountKeyRequest_FieldTerminalPath)(nil)

func (fp *CreateServiceAccountKeyRequest_FieldTerminalPath) Selector() CreateServiceAccountKeyRequest_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source CreateServiceAccountKeyRequest
func (fp *CreateServiceAccountKeyRequest_FieldTerminalPath) Get(source *CreateServiceAccountKeyRequest) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case CreateServiceAccountKeyRequest_FieldPathSelectorParent:
			if source.Parent != nil {
				values = append(values, source.Parent)
			}
		case CreateServiceAccountKeyRequest_FieldPathSelectorServiceAccountKey:
			if source.ServiceAccountKey != nil {
				values = append(values, source.ServiceAccountKey)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for CreateServiceAccountKeyRequest: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source CreateServiceAccountKeyRequest
func (fp *CreateServiceAccountKeyRequest_FieldTerminalPath) GetSingle(source *CreateServiceAccountKeyRequest) (interface{}, bool) {
	switch fp.selector {
	case CreateServiceAccountKeyRequest_FieldPathSelectorParent:
		res := source.GetParent()
		return res, res != nil
	case CreateServiceAccountKeyRequest_FieldPathSelectorServiceAccountKey:
		res := source.GetServiceAccountKey()
		return res, res != nil
	default:
		panic(fmt.Sprintf("Invalid selector for CreateServiceAccountKeyRequest: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *CreateServiceAccountKeyRequest_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case CreateServiceAccountKeyRequest_FieldPathSelectorParent:
		return (*service_account_key.ParentReference)(nil)
	case CreateServiceAccountKeyRequest_FieldPathSelectorServiceAccountKey:
		return (*service_account_key.ServiceAccountKey)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for CreateServiceAccountKeyRequest: %d", fp.selector))
	}
}

func (fp *CreateServiceAccountKeyRequest_FieldTerminalPath) ClearValue(item *CreateServiceAccountKeyRequest) {
	if item != nil {
		switch fp.selector {
		case CreateServiceAccountKeyRequest_FieldPathSelectorParent:
			item.Parent = nil
		case CreateServiceAccountKeyRequest_FieldPathSelectorServiceAccountKey:
			item.ServiceAccountKey = nil
		default:
			panic(fmt.Sprintf("Invalid selector for CreateServiceAccountKeyRequest: %d", fp.selector))
		}
	}
}

func (fp *CreateServiceAccountKeyRequest_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*CreateServiceAccountKeyRequest))
}

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

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

func (fp *CreateServiceAccountKeyRequest_FieldTerminalPath) WithIValue(value interface{}) CreateServiceAccountKeyRequest_FieldPathValue {
	switch fp.selector {
	case CreateServiceAccountKeyRequest_FieldPathSelectorParent:
		return &CreateServiceAccountKeyRequest_FieldTerminalPathValue{CreateServiceAccountKeyRequest_FieldTerminalPath: *fp, value: value.(*service_account_key.ParentReference)}
	case CreateServiceAccountKeyRequest_FieldPathSelectorServiceAccountKey:
		return &CreateServiceAccountKeyRequest_FieldTerminalPathValue{CreateServiceAccountKeyRequest_FieldTerminalPath: *fp, value: value.(*service_account_key.ServiceAccountKey)}
	default:
		panic(fmt.Sprintf("Invalid selector for CreateServiceAccountKeyRequest: %d", fp.selector))
	}
}

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

func (fp *CreateServiceAccountKeyRequest_FieldTerminalPath) WithIArrayOfValues(values interface{}) CreateServiceAccountKeyRequest_FieldPathArrayOfValues {
	fpaov := &CreateServiceAccountKeyRequest_FieldTerminalPathArrayOfValues{CreateServiceAccountKeyRequest_FieldTerminalPath: *fp}
	switch fp.selector {
	case CreateServiceAccountKeyRequest_FieldPathSelectorParent:
		return &CreateServiceAccountKeyRequest_FieldTerminalPathArrayOfValues{CreateServiceAccountKeyRequest_FieldTerminalPath: *fp, values: values.([]*service_account_key.ParentReference)}
	case CreateServiceAccountKeyRequest_FieldPathSelectorServiceAccountKey:
		return &CreateServiceAccountKeyRequest_FieldTerminalPathArrayOfValues{CreateServiceAccountKeyRequest_FieldTerminalPath: *fp, values: values.([]*service_account_key.ServiceAccountKey)}
	default:
		panic(fmt.Sprintf("Invalid selector for CreateServiceAccountKeyRequest: %d", fp.selector))
	}
	return fpaov
}

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

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

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

type CreateServiceAccountKeyRequest_FieldSubPath struct {
	selector CreateServiceAccountKeyRequest_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ CreateServiceAccountKeyRequest_FieldPath = (*CreateServiceAccountKeyRequest_FieldSubPath)(nil)

func (fps *CreateServiceAccountKeyRequest_FieldSubPath) Selector() CreateServiceAccountKeyRequest_FieldPathSelector {
	return fps.selector
}
func (fps *CreateServiceAccountKeyRequest_FieldSubPath) AsServiceAccountKeySubPath() (service_account_key.ServiceAccountKey_FieldPath, bool) {
	res, ok := fps.subPath.(service_account_key.ServiceAccountKey_FieldPath)
	return res, ok
}

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

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

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

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

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

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

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

func (fps *CreateServiceAccountKeyRequest_FieldSubPath) ClearValue(item *CreateServiceAccountKeyRequest) {
	if item != nil {
		switch fps.selector {
		case CreateServiceAccountKeyRequest_FieldPathSelectorServiceAccountKey:
			fps.subPath.ClearValueRaw(item.ServiceAccountKey)
		default:
			panic(fmt.Sprintf("Invalid selector for CreateServiceAccountKeyRequest: %d", fps.selector))
		}
	}
}

func (fps *CreateServiceAccountKeyRequest_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*CreateServiceAccountKeyRequest))
}

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

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

func (fps *CreateServiceAccountKeyRequest_FieldSubPath) WithIValue(value interface{}) CreateServiceAccountKeyRequest_FieldPathValue {
	return &CreateServiceAccountKeyRequest_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *CreateServiceAccountKeyRequest_FieldSubPath) WithIArrayOfValues(values interface{}) CreateServiceAccountKeyRequest_FieldPathArrayOfValues {
	return &CreateServiceAccountKeyRequest_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *CreateServiceAccountKeyRequest_FieldSubPath) WithIArrayItemValue(value interface{}) CreateServiceAccountKeyRequest_FieldPathArrayItemValue {
	return &CreateServiceAccountKeyRequest_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

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

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

func MustParseCreateServiceAccountKeyRequest_FieldPathValue(pathStr, valueStr string) CreateServiceAccountKeyRequest_FieldPathValue {
	fpv, err := ParseCreateServiceAccountKeyRequest_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type CreateServiceAccountKeyRequest_FieldTerminalPathValue struct {
	CreateServiceAccountKeyRequest_FieldTerminalPath
	value interface{}
}

var _ CreateServiceAccountKeyRequest_FieldPathValue = (*CreateServiceAccountKeyRequest_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'CreateServiceAccountKeyRequest' as interface{}
func (fpv *CreateServiceAccountKeyRequest_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *CreateServiceAccountKeyRequest_FieldTerminalPathValue) AsParentValue() (*service_account_key.ParentReference, bool) {
	res, ok := fpv.value.(*service_account_key.ParentReference)
	return res, ok
}
func (fpv *CreateServiceAccountKeyRequest_FieldTerminalPathValue) AsServiceAccountKeyValue() (*service_account_key.ServiceAccountKey, bool) {
	res, ok := fpv.value.(*service_account_key.ServiceAccountKey)
	return res, ok
}

// SetTo stores value for selected field for object CreateServiceAccountKeyRequest
func (fpv *CreateServiceAccountKeyRequest_FieldTerminalPathValue) SetTo(target **CreateServiceAccountKeyRequest) {
	if *target == nil {
		*target = new(CreateServiceAccountKeyRequest)
	}
	switch fpv.selector {
	case CreateServiceAccountKeyRequest_FieldPathSelectorParent:
		(*target).Parent = fpv.value.(*service_account_key.ParentReference)
	case CreateServiceAccountKeyRequest_FieldPathSelectorServiceAccountKey:
		(*target).ServiceAccountKey = fpv.value.(*service_account_key.ServiceAccountKey)
	default:
		panic(fmt.Sprintf("Invalid selector for CreateServiceAccountKeyRequest: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'CreateServiceAccountKeyRequest_FieldTerminalPathValue' with the value under path in 'CreateServiceAccountKeyRequest'.
func (fpv *CreateServiceAccountKeyRequest_FieldTerminalPathValue) CompareWith(source *CreateServiceAccountKeyRequest) (int, bool) {
	switch fpv.selector {
	case CreateServiceAccountKeyRequest_FieldPathSelectorParent:
		leftValue := fpv.value.(*service_account_key.ParentReference)
		rightValue := source.GetParent()
		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 CreateServiceAccountKeyRequest_FieldPathSelectorServiceAccountKey:
		return 0, false
	default:
		panic(fmt.Sprintf("Invalid selector for CreateServiceAccountKeyRequest: %d", fpv.selector))
	}
}

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

type CreateServiceAccountKeyRequest_FieldSubPathValue struct {
	CreateServiceAccountKeyRequest_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ CreateServiceAccountKeyRequest_FieldPathValue = (*CreateServiceAccountKeyRequest_FieldSubPathValue)(nil)

func (fpvs *CreateServiceAccountKeyRequest_FieldSubPathValue) AsServiceAccountKeyPathValue() (service_account_key.ServiceAccountKey_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(service_account_key.ServiceAccountKey_FieldPathValue)
	return res, ok
}

func (fpvs *CreateServiceAccountKeyRequest_FieldSubPathValue) SetTo(target **CreateServiceAccountKeyRequest) {
	if *target == nil {
		*target = new(CreateServiceAccountKeyRequest)
	}
	switch fpvs.Selector() {
	case CreateServiceAccountKeyRequest_FieldPathSelectorServiceAccountKey:
		fpvs.subPathValue.(service_account_key.ServiceAccountKey_FieldPathValue).SetTo(&(*target).ServiceAccountKey)
	default:
		panic(fmt.Sprintf("Invalid selector for CreateServiceAccountKeyRequest: %d", fpvs.Selector()))
	}
}

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

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

func (fpvs *CreateServiceAccountKeyRequest_FieldSubPathValue) CompareWith(source *CreateServiceAccountKeyRequest) (int, bool) {
	switch fpvs.Selector() {
	case CreateServiceAccountKeyRequest_FieldPathSelectorServiceAccountKey:
		return fpvs.subPathValue.(service_account_key.ServiceAccountKey_FieldPathValue).CompareWith(source.GetServiceAccountKey())
	default:
		panic(fmt.Sprintf("Invalid selector for CreateServiceAccountKeyRequest: %d", fpvs.Selector()))
	}
}

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

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

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

func MustParseCreateServiceAccountKeyRequest_FieldPathArrayItemValue(pathStr, valueStr string) CreateServiceAccountKeyRequest_FieldPathArrayItemValue {
	fpaiv, err := ParseCreateServiceAccountKeyRequest_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type CreateServiceAccountKeyRequest_FieldTerminalPathArrayItemValue struct {
	CreateServiceAccountKeyRequest_FieldTerminalPath
	value interface{}
}

var _ CreateServiceAccountKeyRequest_FieldPathArrayItemValue = (*CreateServiceAccountKeyRequest_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *CreateServiceAccountKeyRequest_FieldTerminalPathArrayItemValue) GetSingle(source *CreateServiceAccountKeyRequest) (interface{}, bool) {
	return nil, false
}

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

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

// GetRawValue returns stored array item value
func (fpaivs *CreateServiceAccountKeyRequest_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *CreateServiceAccountKeyRequest_FieldSubPathArrayItemValue) AsServiceAccountKeyPathItemValue() (service_account_key.ServiceAccountKey_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(service_account_key.ServiceAccountKey_FieldPathArrayItemValue)
	return res, ok
}

// Contains returns a boolean indicating if value that is being held is present in given 'CreateServiceAccountKeyRequest'
func (fpaivs *CreateServiceAccountKeyRequest_FieldSubPathArrayItemValue) ContainsValue(source *CreateServiceAccountKeyRequest) bool {
	switch fpaivs.Selector() {
	case CreateServiceAccountKeyRequest_FieldPathSelectorServiceAccountKey:
		return fpaivs.subPathItemValue.(service_account_key.ServiceAccountKey_FieldPathArrayItemValue).ContainsValue(source.GetServiceAccountKey())
	default:
		panic(fmt.Sprintf("Invalid selector for CreateServiceAccountKeyRequest: %d", fpaivs.Selector()))
	}
}

// CreateServiceAccountKeyRequest_FieldPathArrayOfValues allows storing slice of values for CreateServiceAccountKeyRequest fields according to their type
type CreateServiceAccountKeyRequest_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	CreateServiceAccountKeyRequest_FieldPath
}

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

func MustParseCreateServiceAccountKeyRequest_FieldPathArrayOfValues(pathStr, valuesStr string) CreateServiceAccountKeyRequest_FieldPathArrayOfValues {
	fpaov, err := ParseCreateServiceAccountKeyRequest_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type CreateServiceAccountKeyRequest_FieldTerminalPathArrayOfValues struct {
	CreateServiceAccountKeyRequest_FieldTerminalPath
	values interface{}
}

var _ CreateServiceAccountKeyRequest_FieldPathArrayOfValues = (*CreateServiceAccountKeyRequest_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *CreateServiceAccountKeyRequest_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case CreateServiceAccountKeyRequest_FieldPathSelectorParent:
		for _, v := range fpaov.values.([]*service_account_key.ParentReference) {
			values = append(values, v)
		}
	case CreateServiceAccountKeyRequest_FieldPathSelectorServiceAccountKey:
		for _, v := range fpaov.values.([]*service_account_key.ServiceAccountKey) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *CreateServiceAccountKeyRequest_FieldTerminalPathArrayOfValues) AsParentArrayOfValues() ([]*service_account_key.ParentReference, bool) {
	res, ok := fpaov.values.([]*service_account_key.ParentReference)
	return res, ok
}
func (fpaov *CreateServiceAccountKeyRequest_FieldTerminalPathArrayOfValues) AsServiceAccountKeyArrayOfValues() ([]*service_account_key.ServiceAccountKey, bool) {
	res, ok := fpaov.values.([]*service_account_key.ServiceAccountKey)
	return res, ok
}

type CreateServiceAccountKeyRequest_FieldSubPathArrayOfValues struct {
	CreateServiceAccountKeyRequest_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ CreateServiceAccountKeyRequest_FieldPathArrayOfValues = (*CreateServiceAccountKeyRequest_FieldSubPathArrayOfValues)(nil)

func (fpsaov *CreateServiceAccountKeyRequest_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *CreateServiceAccountKeyRequest_FieldSubPathArrayOfValues) AsServiceAccountKeyPathArrayOfValues() (service_account_key.ServiceAccountKey_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(service_account_key.ServiceAccountKey_FieldPathArrayOfValues)
	return res, ok
}

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

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

type UpdateServiceAccountKeyRequest_FieldPathSelector int32

const (
	UpdateServiceAccountKeyRequest_FieldPathSelectorServiceAccountKey UpdateServiceAccountKeyRequest_FieldPathSelector = 0
	UpdateServiceAccountKeyRequest_FieldPathSelectorUpdateMask        UpdateServiceAccountKeyRequest_FieldPathSelector = 1
	UpdateServiceAccountKeyRequest_FieldPathSelectorCas               UpdateServiceAccountKeyRequest_FieldPathSelector = 2
)

func (s UpdateServiceAccountKeyRequest_FieldPathSelector) String() string {
	switch s {
	case UpdateServiceAccountKeyRequest_FieldPathSelectorServiceAccountKey:
		return "service_account_key"
	case UpdateServiceAccountKeyRequest_FieldPathSelectorUpdateMask:
		return "update_mask"
	case UpdateServiceAccountKeyRequest_FieldPathSelectorCas:
		return "cas"
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateServiceAccountKeyRequest: %d", s))
	}
}

func BuildUpdateServiceAccountKeyRequest_FieldPath(fp gotenobject.RawFieldPath) (UpdateServiceAccountKeyRequest_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object UpdateServiceAccountKeyRequest")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "service_account_key", "serviceAccountKey", "service-account-key":
			return &UpdateServiceAccountKeyRequest_FieldTerminalPath{selector: UpdateServiceAccountKeyRequest_FieldPathSelectorServiceAccountKey}, nil
		case "update_mask", "updateMask", "update-mask":
			return &UpdateServiceAccountKeyRequest_FieldTerminalPath{selector: UpdateServiceAccountKeyRequest_FieldPathSelectorUpdateMask}, nil
		case "cas":
			return &UpdateServiceAccountKeyRequest_FieldTerminalPath{selector: UpdateServiceAccountKeyRequest_FieldPathSelectorCas}, nil
		}
	} else {
		switch fp[0] {
		case "service_account_key", "serviceAccountKey", "service-account-key":
			if subpath, err := service_account_key.BuildServiceAccountKey_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &UpdateServiceAccountKeyRequest_FieldSubPath{selector: UpdateServiceAccountKeyRequest_FieldPathSelectorServiceAccountKey, subPath: subpath}, nil
			}
		case "cas":
			if subpath, err := BuildUpdateServiceAccountKeyRequestCAS_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &UpdateServiceAccountKeyRequest_FieldSubPath{selector: UpdateServiceAccountKeyRequest_FieldPathSelectorCas, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object UpdateServiceAccountKeyRequest", fp)
}

func ParseUpdateServiceAccountKeyRequest_FieldPath(rawField string) (UpdateServiceAccountKeyRequest_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildUpdateServiceAccountKeyRequest_FieldPath(fp)
}

func MustParseUpdateServiceAccountKeyRequest_FieldPath(rawField string) UpdateServiceAccountKeyRequest_FieldPath {
	fp, err := ParseUpdateServiceAccountKeyRequest_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type UpdateServiceAccountKeyRequest_FieldTerminalPath struct {
	selector UpdateServiceAccountKeyRequest_FieldPathSelector
}

var _ UpdateServiceAccountKeyRequest_FieldPath = (*UpdateServiceAccountKeyRequest_FieldTerminalPath)(nil)

func (fp *UpdateServiceAccountKeyRequest_FieldTerminalPath) Selector() UpdateServiceAccountKeyRequest_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source UpdateServiceAccountKeyRequest
func (fp *UpdateServiceAccountKeyRequest_FieldTerminalPath) Get(source *UpdateServiceAccountKeyRequest) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case UpdateServiceAccountKeyRequest_FieldPathSelectorServiceAccountKey:
			if source.ServiceAccountKey != nil {
				values = append(values, source.ServiceAccountKey)
			}
		case UpdateServiceAccountKeyRequest_FieldPathSelectorUpdateMask:
			if source.UpdateMask != nil {
				values = append(values, source.UpdateMask)
			}
		case UpdateServiceAccountKeyRequest_FieldPathSelectorCas:
			if source.Cas != nil {
				values = append(values, source.Cas)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for UpdateServiceAccountKeyRequest: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source UpdateServiceAccountKeyRequest
func (fp *UpdateServiceAccountKeyRequest_FieldTerminalPath) GetSingle(source *UpdateServiceAccountKeyRequest) (interface{}, bool) {
	switch fp.selector {
	case UpdateServiceAccountKeyRequest_FieldPathSelectorServiceAccountKey:
		res := source.GetServiceAccountKey()
		return res, res != nil
	case UpdateServiceAccountKeyRequest_FieldPathSelectorUpdateMask:
		res := source.GetUpdateMask()
		return res, res != nil
	case UpdateServiceAccountKeyRequest_FieldPathSelectorCas:
		res := source.GetCas()
		return res, res != nil
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateServiceAccountKeyRequest: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *UpdateServiceAccountKeyRequest_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case UpdateServiceAccountKeyRequest_FieldPathSelectorServiceAccountKey:
		return (*service_account_key.ServiceAccountKey)(nil)
	case UpdateServiceAccountKeyRequest_FieldPathSelectorUpdateMask:
		return (*service_account_key.ServiceAccountKey_FieldMask)(nil)
	case UpdateServiceAccountKeyRequest_FieldPathSelectorCas:
		return (*UpdateServiceAccountKeyRequest_CAS)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateServiceAccountKeyRequest: %d", fp.selector))
	}
}

func (fp *UpdateServiceAccountKeyRequest_FieldTerminalPath) ClearValue(item *UpdateServiceAccountKeyRequest) {
	if item != nil {
		switch fp.selector {
		case UpdateServiceAccountKeyRequest_FieldPathSelectorServiceAccountKey:
			item.ServiceAccountKey = nil
		case UpdateServiceAccountKeyRequest_FieldPathSelectorUpdateMask:
			item.UpdateMask = nil
		case UpdateServiceAccountKeyRequest_FieldPathSelectorCas:
			item.Cas = nil
		default:
			panic(fmt.Sprintf("Invalid selector for UpdateServiceAccountKeyRequest: %d", fp.selector))
		}
	}
}

func (fp *UpdateServiceAccountKeyRequest_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*UpdateServiceAccountKeyRequest))
}

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

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

func (fp *UpdateServiceAccountKeyRequest_FieldTerminalPath) WithIValue(value interface{}) UpdateServiceAccountKeyRequest_FieldPathValue {
	switch fp.selector {
	case UpdateServiceAccountKeyRequest_FieldPathSelectorServiceAccountKey:
		return &UpdateServiceAccountKeyRequest_FieldTerminalPathValue{UpdateServiceAccountKeyRequest_FieldTerminalPath: *fp, value: value.(*service_account_key.ServiceAccountKey)}
	case UpdateServiceAccountKeyRequest_FieldPathSelectorUpdateMask:
		return &UpdateServiceAccountKeyRequest_FieldTerminalPathValue{UpdateServiceAccountKeyRequest_FieldTerminalPath: *fp, value: value.(*service_account_key.ServiceAccountKey_FieldMask)}
	case UpdateServiceAccountKeyRequest_FieldPathSelectorCas:
		return &UpdateServiceAccountKeyRequest_FieldTerminalPathValue{UpdateServiceAccountKeyRequest_FieldTerminalPath: *fp, value: value.(*UpdateServiceAccountKeyRequest_CAS)}
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateServiceAccountKeyRequest: %d", fp.selector))
	}
}

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

func (fp *UpdateServiceAccountKeyRequest_FieldTerminalPath) WithIArrayOfValues(values interface{}) UpdateServiceAccountKeyRequest_FieldPathArrayOfValues {
	fpaov := &UpdateServiceAccountKeyRequest_FieldTerminalPathArrayOfValues{UpdateServiceAccountKeyRequest_FieldTerminalPath: *fp}
	switch fp.selector {
	case UpdateServiceAccountKeyRequest_FieldPathSelectorServiceAccountKey:
		return &UpdateServiceAccountKeyRequest_FieldTerminalPathArrayOfValues{UpdateServiceAccountKeyRequest_FieldTerminalPath: *fp, values: values.([]*service_account_key.ServiceAccountKey)}
	case UpdateServiceAccountKeyRequest_FieldPathSelectorUpdateMask:
		return &UpdateServiceAccountKeyRequest_FieldTerminalPathArrayOfValues{UpdateServiceAccountKeyRequest_FieldTerminalPath: *fp, values: values.([]*service_account_key.ServiceAccountKey_FieldMask)}
	case UpdateServiceAccountKeyRequest_FieldPathSelectorCas:
		return &UpdateServiceAccountKeyRequest_FieldTerminalPathArrayOfValues{UpdateServiceAccountKeyRequest_FieldTerminalPath: *fp, values: values.([]*UpdateServiceAccountKeyRequest_CAS)}
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateServiceAccountKeyRequest: %d", fp.selector))
	}
	return fpaov
}

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

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

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

type UpdateServiceAccountKeyRequest_FieldSubPath struct {
	selector UpdateServiceAccountKeyRequest_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ UpdateServiceAccountKeyRequest_FieldPath = (*UpdateServiceAccountKeyRequest_FieldSubPath)(nil)

func (fps *UpdateServiceAccountKeyRequest_FieldSubPath) Selector() UpdateServiceAccountKeyRequest_FieldPathSelector {
	return fps.selector
}
func (fps *UpdateServiceAccountKeyRequest_FieldSubPath) AsServiceAccountKeySubPath() (service_account_key.ServiceAccountKey_FieldPath, bool) {
	res, ok := fps.subPath.(service_account_key.ServiceAccountKey_FieldPath)
	return res, ok
}
func (fps *UpdateServiceAccountKeyRequest_FieldSubPath) AsCasSubPath() (UpdateServiceAccountKeyRequestCAS_FieldPath, bool) {
	res, ok := fps.subPath.(UpdateServiceAccountKeyRequestCAS_FieldPath)
	return res, ok
}

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

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

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

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

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

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

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

func (fps *UpdateServiceAccountKeyRequest_FieldSubPath) ClearValue(item *UpdateServiceAccountKeyRequest) {
	if item != nil {
		switch fps.selector {
		case UpdateServiceAccountKeyRequest_FieldPathSelectorServiceAccountKey:
			fps.subPath.ClearValueRaw(item.ServiceAccountKey)
		case UpdateServiceAccountKeyRequest_FieldPathSelectorCas:
			fps.subPath.ClearValueRaw(item.Cas)
		default:
			panic(fmt.Sprintf("Invalid selector for UpdateServiceAccountKeyRequest: %d", fps.selector))
		}
	}
}

func (fps *UpdateServiceAccountKeyRequest_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*UpdateServiceAccountKeyRequest))
}

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

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

func (fps *UpdateServiceAccountKeyRequest_FieldSubPath) WithIValue(value interface{}) UpdateServiceAccountKeyRequest_FieldPathValue {
	return &UpdateServiceAccountKeyRequest_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *UpdateServiceAccountKeyRequest_FieldSubPath) WithIArrayOfValues(values interface{}) UpdateServiceAccountKeyRequest_FieldPathArrayOfValues {
	return &UpdateServiceAccountKeyRequest_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *UpdateServiceAccountKeyRequest_FieldSubPath) WithIArrayItemValue(value interface{}) UpdateServiceAccountKeyRequest_FieldPathArrayItemValue {
	return &UpdateServiceAccountKeyRequest_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

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

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

func MustParseUpdateServiceAccountKeyRequest_FieldPathValue(pathStr, valueStr string) UpdateServiceAccountKeyRequest_FieldPathValue {
	fpv, err := ParseUpdateServiceAccountKeyRequest_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type UpdateServiceAccountKeyRequest_FieldTerminalPathValue struct {
	UpdateServiceAccountKeyRequest_FieldTerminalPath
	value interface{}
}

var _ UpdateServiceAccountKeyRequest_FieldPathValue = (*UpdateServiceAccountKeyRequest_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'UpdateServiceAccountKeyRequest' as interface{}
func (fpv *UpdateServiceAccountKeyRequest_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *UpdateServiceAccountKeyRequest_FieldTerminalPathValue) AsServiceAccountKeyValue() (*service_account_key.ServiceAccountKey, bool) {
	res, ok := fpv.value.(*service_account_key.ServiceAccountKey)
	return res, ok
}
func (fpv *UpdateServiceAccountKeyRequest_FieldTerminalPathValue) AsUpdateMaskValue() (*service_account_key.ServiceAccountKey_FieldMask, bool) {
	res, ok := fpv.value.(*service_account_key.ServiceAccountKey_FieldMask)
	return res, ok
}
func (fpv *UpdateServiceAccountKeyRequest_FieldTerminalPathValue) AsCasValue() (*UpdateServiceAccountKeyRequest_CAS, bool) {
	res, ok := fpv.value.(*UpdateServiceAccountKeyRequest_CAS)
	return res, ok
}

// SetTo stores value for selected field for object UpdateServiceAccountKeyRequest
func (fpv *UpdateServiceAccountKeyRequest_FieldTerminalPathValue) SetTo(target **UpdateServiceAccountKeyRequest) {
	if *target == nil {
		*target = new(UpdateServiceAccountKeyRequest)
	}
	switch fpv.selector {
	case UpdateServiceAccountKeyRequest_FieldPathSelectorServiceAccountKey:
		(*target).ServiceAccountKey = fpv.value.(*service_account_key.ServiceAccountKey)
	case UpdateServiceAccountKeyRequest_FieldPathSelectorUpdateMask:
		(*target).UpdateMask = fpv.value.(*service_account_key.ServiceAccountKey_FieldMask)
	case UpdateServiceAccountKeyRequest_FieldPathSelectorCas:
		(*target).Cas = fpv.value.(*UpdateServiceAccountKeyRequest_CAS)
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateServiceAccountKeyRequest: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'UpdateServiceAccountKeyRequest_FieldTerminalPathValue' with the value under path in 'UpdateServiceAccountKeyRequest'.
func (fpv *UpdateServiceAccountKeyRequest_FieldTerminalPathValue) CompareWith(source *UpdateServiceAccountKeyRequest) (int, bool) {
	switch fpv.selector {
	case UpdateServiceAccountKeyRequest_FieldPathSelectorServiceAccountKey:
		return 0, false
	case UpdateServiceAccountKeyRequest_FieldPathSelectorUpdateMask:
		return 0, false
	case UpdateServiceAccountKeyRequest_FieldPathSelectorCas:
		return 0, false
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateServiceAccountKeyRequest: %d", fpv.selector))
	}
}

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

type UpdateServiceAccountKeyRequest_FieldSubPathValue struct {
	UpdateServiceAccountKeyRequest_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ UpdateServiceAccountKeyRequest_FieldPathValue = (*UpdateServiceAccountKeyRequest_FieldSubPathValue)(nil)

func (fpvs *UpdateServiceAccountKeyRequest_FieldSubPathValue) AsServiceAccountKeyPathValue() (service_account_key.ServiceAccountKey_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(service_account_key.ServiceAccountKey_FieldPathValue)
	return res, ok
}
func (fpvs *UpdateServiceAccountKeyRequest_FieldSubPathValue) AsCasPathValue() (UpdateServiceAccountKeyRequestCAS_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(UpdateServiceAccountKeyRequestCAS_FieldPathValue)
	return res, ok
}

func (fpvs *UpdateServiceAccountKeyRequest_FieldSubPathValue) SetTo(target **UpdateServiceAccountKeyRequest) {
	if *target == nil {
		*target = new(UpdateServiceAccountKeyRequest)
	}
	switch fpvs.Selector() {
	case UpdateServiceAccountKeyRequest_FieldPathSelectorServiceAccountKey:
		fpvs.subPathValue.(service_account_key.ServiceAccountKey_FieldPathValue).SetTo(&(*target).ServiceAccountKey)
	case UpdateServiceAccountKeyRequest_FieldPathSelectorCas:
		fpvs.subPathValue.(UpdateServiceAccountKeyRequestCAS_FieldPathValue).SetTo(&(*target).Cas)
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateServiceAccountKeyRequest: %d", fpvs.Selector()))
	}
}

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

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

func (fpvs *UpdateServiceAccountKeyRequest_FieldSubPathValue) CompareWith(source *UpdateServiceAccountKeyRequest) (int, bool) {
	switch fpvs.Selector() {
	case UpdateServiceAccountKeyRequest_FieldPathSelectorServiceAccountKey:
		return fpvs.subPathValue.(service_account_key.ServiceAccountKey_FieldPathValue).CompareWith(source.GetServiceAccountKey())
	case UpdateServiceAccountKeyRequest_FieldPathSelectorCas:
		return fpvs.subPathValue.(UpdateServiceAccountKeyRequestCAS_FieldPathValue).CompareWith(source.GetCas())
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateServiceAccountKeyRequest: %d", fpvs.Selector()))
	}
}

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

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

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

func MustParseUpdateServiceAccountKeyRequest_FieldPathArrayItemValue(pathStr, valueStr string) UpdateServiceAccountKeyRequest_FieldPathArrayItemValue {
	fpaiv, err := ParseUpdateServiceAccountKeyRequest_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type UpdateServiceAccountKeyRequest_FieldTerminalPathArrayItemValue struct {
	UpdateServiceAccountKeyRequest_FieldTerminalPath
	value interface{}
}

var _ UpdateServiceAccountKeyRequest_FieldPathArrayItemValue = (*UpdateServiceAccountKeyRequest_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *UpdateServiceAccountKeyRequest_FieldTerminalPathArrayItemValue) GetSingle(source *UpdateServiceAccountKeyRequest) (interface{}, bool) {
	return nil, false
}

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

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

// GetRawValue returns stored array item value
func (fpaivs *UpdateServiceAccountKeyRequest_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *UpdateServiceAccountKeyRequest_FieldSubPathArrayItemValue) AsServiceAccountKeyPathItemValue() (service_account_key.ServiceAccountKey_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(service_account_key.ServiceAccountKey_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *UpdateServiceAccountKeyRequest_FieldSubPathArrayItemValue) AsCasPathItemValue() (UpdateServiceAccountKeyRequestCAS_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(UpdateServiceAccountKeyRequestCAS_FieldPathArrayItemValue)
	return res, ok
}

// Contains returns a boolean indicating if value that is being held is present in given 'UpdateServiceAccountKeyRequest'
func (fpaivs *UpdateServiceAccountKeyRequest_FieldSubPathArrayItemValue) ContainsValue(source *UpdateServiceAccountKeyRequest) bool {
	switch fpaivs.Selector() {
	case UpdateServiceAccountKeyRequest_FieldPathSelectorServiceAccountKey:
		return fpaivs.subPathItemValue.(service_account_key.ServiceAccountKey_FieldPathArrayItemValue).ContainsValue(source.GetServiceAccountKey())
	case UpdateServiceAccountKeyRequest_FieldPathSelectorCas:
		return fpaivs.subPathItemValue.(UpdateServiceAccountKeyRequestCAS_FieldPathArrayItemValue).ContainsValue(source.GetCas())
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateServiceAccountKeyRequest: %d", fpaivs.Selector()))
	}
}

// UpdateServiceAccountKeyRequest_FieldPathArrayOfValues allows storing slice of values for UpdateServiceAccountKeyRequest fields according to their type
type UpdateServiceAccountKeyRequest_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	UpdateServiceAccountKeyRequest_FieldPath
}

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

func MustParseUpdateServiceAccountKeyRequest_FieldPathArrayOfValues(pathStr, valuesStr string) UpdateServiceAccountKeyRequest_FieldPathArrayOfValues {
	fpaov, err := ParseUpdateServiceAccountKeyRequest_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type UpdateServiceAccountKeyRequest_FieldTerminalPathArrayOfValues struct {
	UpdateServiceAccountKeyRequest_FieldTerminalPath
	values interface{}
}

var _ UpdateServiceAccountKeyRequest_FieldPathArrayOfValues = (*UpdateServiceAccountKeyRequest_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *UpdateServiceAccountKeyRequest_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case UpdateServiceAccountKeyRequest_FieldPathSelectorServiceAccountKey:
		for _, v := range fpaov.values.([]*service_account_key.ServiceAccountKey) {
			values = append(values, v)
		}
	case UpdateServiceAccountKeyRequest_FieldPathSelectorUpdateMask:
		for _, v := range fpaov.values.([]*service_account_key.ServiceAccountKey_FieldMask) {
			values = append(values, v)
		}
	case UpdateServiceAccountKeyRequest_FieldPathSelectorCas:
		for _, v := range fpaov.values.([]*UpdateServiceAccountKeyRequest_CAS) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *UpdateServiceAccountKeyRequest_FieldTerminalPathArrayOfValues) AsServiceAccountKeyArrayOfValues() ([]*service_account_key.ServiceAccountKey, bool) {
	res, ok := fpaov.values.([]*service_account_key.ServiceAccountKey)
	return res, ok
}
func (fpaov *UpdateServiceAccountKeyRequest_FieldTerminalPathArrayOfValues) AsUpdateMaskArrayOfValues() ([]*service_account_key.ServiceAccountKey_FieldMask, bool) {
	res, ok := fpaov.values.([]*service_account_key.ServiceAccountKey_FieldMask)
	return res, ok
}
func (fpaov *UpdateServiceAccountKeyRequest_FieldTerminalPathArrayOfValues) AsCasArrayOfValues() ([]*UpdateServiceAccountKeyRequest_CAS, bool) {
	res, ok := fpaov.values.([]*UpdateServiceAccountKeyRequest_CAS)
	return res, ok
}

type UpdateServiceAccountKeyRequest_FieldSubPathArrayOfValues struct {
	UpdateServiceAccountKeyRequest_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ UpdateServiceAccountKeyRequest_FieldPathArrayOfValues = (*UpdateServiceAccountKeyRequest_FieldSubPathArrayOfValues)(nil)

func (fpsaov *UpdateServiceAccountKeyRequest_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *UpdateServiceAccountKeyRequest_FieldSubPathArrayOfValues) AsServiceAccountKeyPathArrayOfValues() (service_account_key.ServiceAccountKey_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(service_account_key.ServiceAccountKey_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *UpdateServiceAccountKeyRequest_FieldSubPathArrayOfValues) AsCasPathArrayOfValues() (UpdateServiceAccountKeyRequestCAS_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(UpdateServiceAccountKeyRequestCAS_FieldPathArrayOfValues)
	return res, ok
}

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

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

type UpdateServiceAccountKeyRequestCAS_FieldPathSelector int32

const (
	UpdateServiceAccountKeyRequestCAS_FieldPathSelectorConditionalState UpdateServiceAccountKeyRequestCAS_FieldPathSelector = 0
	UpdateServiceAccountKeyRequestCAS_FieldPathSelectorFieldMask        UpdateServiceAccountKeyRequestCAS_FieldPathSelector = 1
)

func (s UpdateServiceAccountKeyRequestCAS_FieldPathSelector) String() string {
	switch s {
	case UpdateServiceAccountKeyRequestCAS_FieldPathSelectorConditionalState:
		return "conditional_state"
	case UpdateServiceAccountKeyRequestCAS_FieldPathSelectorFieldMask:
		return "field_mask"
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateServiceAccountKeyRequest_CAS: %d", s))
	}
}

func BuildUpdateServiceAccountKeyRequestCAS_FieldPath(fp gotenobject.RawFieldPath) (UpdateServiceAccountKeyRequestCAS_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object UpdateServiceAccountKeyRequest_CAS")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "conditional_state", "conditionalState", "conditional-state":
			return &UpdateServiceAccountKeyRequestCAS_FieldTerminalPath{selector: UpdateServiceAccountKeyRequestCAS_FieldPathSelectorConditionalState}, nil
		case "field_mask", "fieldMask", "field-mask":
			return &UpdateServiceAccountKeyRequestCAS_FieldTerminalPath{selector: UpdateServiceAccountKeyRequestCAS_FieldPathSelectorFieldMask}, nil
		}
	} else {
		switch fp[0] {
		case "conditional_state", "conditionalState", "conditional-state":
			if subpath, err := service_account_key.BuildServiceAccountKey_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &UpdateServiceAccountKeyRequestCAS_FieldSubPath{selector: UpdateServiceAccountKeyRequestCAS_FieldPathSelectorConditionalState, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object UpdateServiceAccountKeyRequest_CAS", fp)
}

func ParseUpdateServiceAccountKeyRequestCAS_FieldPath(rawField string) (UpdateServiceAccountKeyRequestCAS_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildUpdateServiceAccountKeyRequestCAS_FieldPath(fp)
}

func MustParseUpdateServiceAccountKeyRequestCAS_FieldPath(rawField string) UpdateServiceAccountKeyRequestCAS_FieldPath {
	fp, err := ParseUpdateServiceAccountKeyRequestCAS_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type UpdateServiceAccountKeyRequestCAS_FieldTerminalPath struct {
	selector UpdateServiceAccountKeyRequestCAS_FieldPathSelector
}

var _ UpdateServiceAccountKeyRequestCAS_FieldPath = (*UpdateServiceAccountKeyRequestCAS_FieldTerminalPath)(nil)

func (fp *UpdateServiceAccountKeyRequestCAS_FieldTerminalPath) Selector() UpdateServiceAccountKeyRequestCAS_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source UpdateServiceAccountKeyRequest_CAS
func (fp *UpdateServiceAccountKeyRequestCAS_FieldTerminalPath) Get(source *UpdateServiceAccountKeyRequest_CAS) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case UpdateServiceAccountKeyRequestCAS_FieldPathSelectorConditionalState:
			if source.ConditionalState != nil {
				values = append(values, source.ConditionalState)
			}
		case UpdateServiceAccountKeyRequestCAS_FieldPathSelectorFieldMask:
			if source.FieldMask != nil {
				values = append(values, source.FieldMask)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for UpdateServiceAccountKeyRequest_CAS: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source UpdateServiceAccountKeyRequest_CAS
func (fp *UpdateServiceAccountKeyRequestCAS_FieldTerminalPath) GetSingle(source *UpdateServiceAccountKeyRequest_CAS) (interface{}, bool) {
	switch fp.selector {
	case UpdateServiceAccountKeyRequestCAS_FieldPathSelectorConditionalState:
		res := source.GetConditionalState()
		return res, res != nil
	case UpdateServiceAccountKeyRequestCAS_FieldPathSelectorFieldMask:
		res := source.GetFieldMask()
		return res, res != nil
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateServiceAccountKeyRequest_CAS: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *UpdateServiceAccountKeyRequestCAS_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case UpdateServiceAccountKeyRequestCAS_FieldPathSelectorConditionalState:
		return (*service_account_key.ServiceAccountKey)(nil)
	case UpdateServiceAccountKeyRequestCAS_FieldPathSelectorFieldMask:
		return (*service_account_key.ServiceAccountKey_FieldMask)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateServiceAccountKeyRequest_CAS: %d", fp.selector))
	}
}

func (fp *UpdateServiceAccountKeyRequestCAS_FieldTerminalPath) ClearValue(item *UpdateServiceAccountKeyRequest_CAS) {
	if item != nil {
		switch fp.selector {
		case UpdateServiceAccountKeyRequestCAS_FieldPathSelectorConditionalState:
			item.ConditionalState = nil
		case UpdateServiceAccountKeyRequestCAS_FieldPathSelectorFieldMask:
			item.FieldMask = nil
		default:
			panic(fmt.Sprintf("Invalid selector for UpdateServiceAccountKeyRequest_CAS: %d", fp.selector))
		}
	}
}

func (fp *UpdateServiceAccountKeyRequestCAS_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*UpdateServiceAccountKeyRequest_CAS))
}

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

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

func (fp *UpdateServiceAccountKeyRequestCAS_FieldTerminalPath) WithIValue(value interface{}) UpdateServiceAccountKeyRequestCAS_FieldPathValue {
	switch fp.selector {
	case UpdateServiceAccountKeyRequestCAS_FieldPathSelectorConditionalState:
		return &UpdateServiceAccountKeyRequestCAS_FieldTerminalPathValue{UpdateServiceAccountKeyRequestCAS_FieldTerminalPath: *fp, value: value.(*service_account_key.ServiceAccountKey)}
	case UpdateServiceAccountKeyRequestCAS_FieldPathSelectorFieldMask:
		return &UpdateServiceAccountKeyRequestCAS_FieldTerminalPathValue{UpdateServiceAccountKeyRequestCAS_FieldTerminalPath: *fp, value: value.(*service_account_key.ServiceAccountKey_FieldMask)}
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateServiceAccountKeyRequest_CAS: %d", fp.selector))
	}
}

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

func (fp *UpdateServiceAccountKeyRequestCAS_FieldTerminalPath) WithIArrayOfValues(values interface{}) UpdateServiceAccountKeyRequestCAS_FieldPathArrayOfValues {
	fpaov := &UpdateServiceAccountKeyRequestCAS_FieldTerminalPathArrayOfValues{UpdateServiceAccountKeyRequestCAS_FieldTerminalPath: *fp}
	switch fp.selector {
	case UpdateServiceAccountKeyRequestCAS_FieldPathSelectorConditionalState:
		return &UpdateServiceAccountKeyRequestCAS_FieldTerminalPathArrayOfValues{UpdateServiceAccountKeyRequestCAS_FieldTerminalPath: *fp, values: values.([]*service_account_key.ServiceAccountKey)}
	case UpdateServiceAccountKeyRequestCAS_FieldPathSelectorFieldMask:
		return &UpdateServiceAccountKeyRequestCAS_FieldTerminalPathArrayOfValues{UpdateServiceAccountKeyRequestCAS_FieldTerminalPath: *fp, values: values.([]*service_account_key.ServiceAccountKey_FieldMask)}
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateServiceAccountKeyRequest_CAS: %d", fp.selector))
	}
	return fpaov
}

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

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

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

type UpdateServiceAccountKeyRequestCAS_FieldSubPath struct {
	selector UpdateServiceAccountKeyRequestCAS_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ UpdateServiceAccountKeyRequestCAS_FieldPath = (*UpdateServiceAccountKeyRequestCAS_FieldSubPath)(nil)

func (fps *UpdateServiceAccountKeyRequestCAS_FieldSubPath) Selector() UpdateServiceAccountKeyRequestCAS_FieldPathSelector {
	return fps.selector
}
func (fps *UpdateServiceAccountKeyRequestCAS_FieldSubPath) AsConditionalStateSubPath() (service_account_key.ServiceAccountKey_FieldPath, bool) {
	res, ok := fps.subPath.(service_account_key.ServiceAccountKey_FieldPath)
	return res, ok
}

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

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

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

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

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

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

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

func (fps *UpdateServiceAccountKeyRequestCAS_FieldSubPath) ClearValue(item *UpdateServiceAccountKeyRequest_CAS) {
	if item != nil {
		switch fps.selector {
		case UpdateServiceAccountKeyRequestCAS_FieldPathSelectorConditionalState:
			fps.subPath.ClearValueRaw(item.ConditionalState)
		default:
			panic(fmt.Sprintf("Invalid selector for UpdateServiceAccountKeyRequest_CAS: %d", fps.selector))
		}
	}
}

func (fps *UpdateServiceAccountKeyRequestCAS_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*UpdateServiceAccountKeyRequest_CAS))
}

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

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

func (fps *UpdateServiceAccountKeyRequestCAS_FieldSubPath) WithIValue(value interface{}) UpdateServiceAccountKeyRequestCAS_FieldPathValue {
	return &UpdateServiceAccountKeyRequestCAS_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *UpdateServiceAccountKeyRequestCAS_FieldSubPath) WithIArrayOfValues(values interface{}) UpdateServiceAccountKeyRequestCAS_FieldPathArrayOfValues {
	return &UpdateServiceAccountKeyRequestCAS_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *UpdateServiceAccountKeyRequestCAS_FieldSubPath) WithIArrayItemValue(value interface{}) UpdateServiceAccountKeyRequestCAS_FieldPathArrayItemValue {
	return &UpdateServiceAccountKeyRequestCAS_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

// UpdateServiceAccountKeyRequestCAS_FieldPathValue allows storing values for CAS fields according to their type
type UpdateServiceAccountKeyRequestCAS_FieldPathValue interface {
	UpdateServiceAccountKeyRequestCAS_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **UpdateServiceAccountKeyRequest_CAS)
	CompareWith(*UpdateServiceAccountKeyRequest_CAS) (cmp int, comparable bool)
}

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

func MustParseUpdateServiceAccountKeyRequestCAS_FieldPathValue(pathStr, valueStr string) UpdateServiceAccountKeyRequestCAS_FieldPathValue {
	fpv, err := ParseUpdateServiceAccountKeyRequestCAS_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type UpdateServiceAccountKeyRequestCAS_FieldTerminalPathValue struct {
	UpdateServiceAccountKeyRequestCAS_FieldTerminalPath
	value interface{}
}

var _ UpdateServiceAccountKeyRequestCAS_FieldPathValue = (*UpdateServiceAccountKeyRequestCAS_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'CAS' as interface{}
func (fpv *UpdateServiceAccountKeyRequestCAS_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *UpdateServiceAccountKeyRequestCAS_FieldTerminalPathValue) AsConditionalStateValue() (*service_account_key.ServiceAccountKey, bool) {
	res, ok := fpv.value.(*service_account_key.ServiceAccountKey)
	return res, ok
}
func (fpv *UpdateServiceAccountKeyRequestCAS_FieldTerminalPathValue) AsFieldMaskValue() (*service_account_key.ServiceAccountKey_FieldMask, bool) {
	res, ok := fpv.value.(*service_account_key.ServiceAccountKey_FieldMask)
	return res, ok
}

// SetTo stores value for selected field for object CAS
func (fpv *UpdateServiceAccountKeyRequestCAS_FieldTerminalPathValue) SetTo(target **UpdateServiceAccountKeyRequest_CAS) {
	if *target == nil {
		*target = new(UpdateServiceAccountKeyRequest_CAS)
	}
	switch fpv.selector {
	case UpdateServiceAccountKeyRequestCAS_FieldPathSelectorConditionalState:
		(*target).ConditionalState = fpv.value.(*service_account_key.ServiceAccountKey)
	case UpdateServiceAccountKeyRequestCAS_FieldPathSelectorFieldMask:
		(*target).FieldMask = fpv.value.(*service_account_key.ServiceAccountKey_FieldMask)
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateServiceAccountKeyRequest_CAS: %d", fpv.selector))
	}
}

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

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

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

type UpdateServiceAccountKeyRequestCAS_FieldSubPathValue struct {
	UpdateServiceAccountKeyRequestCAS_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ UpdateServiceAccountKeyRequestCAS_FieldPathValue = (*UpdateServiceAccountKeyRequestCAS_FieldSubPathValue)(nil)

func (fpvs *UpdateServiceAccountKeyRequestCAS_FieldSubPathValue) AsConditionalStatePathValue() (service_account_key.ServiceAccountKey_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(service_account_key.ServiceAccountKey_FieldPathValue)
	return res, ok
}

func (fpvs *UpdateServiceAccountKeyRequestCAS_FieldSubPathValue) SetTo(target **UpdateServiceAccountKeyRequest_CAS) {
	if *target == nil {
		*target = new(UpdateServiceAccountKeyRequest_CAS)
	}
	switch fpvs.Selector() {
	case UpdateServiceAccountKeyRequestCAS_FieldPathSelectorConditionalState:
		fpvs.subPathValue.(service_account_key.ServiceAccountKey_FieldPathValue).SetTo(&(*target).ConditionalState)
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateServiceAccountKeyRequest_CAS: %d", fpvs.Selector()))
	}
}

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

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

func (fpvs *UpdateServiceAccountKeyRequestCAS_FieldSubPathValue) CompareWith(source *UpdateServiceAccountKeyRequest_CAS) (int, bool) {
	switch fpvs.Selector() {
	case UpdateServiceAccountKeyRequestCAS_FieldPathSelectorConditionalState:
		return fpvs.subPathValue.(service_account_key.ServiceAccountKey_FieldPathValue).CompareWith(source.GetConditionalState())
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateServiceAccountKeyRequest_CAS: %d", fpvs.Selector()))
	}
}

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

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

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

func MustParseUpdateServiceAccountKeyRequestCAS_FieldPathArrayItemValue(pathStr, valueStr string) UpdateServiceAccountKeyRequestCAS_FieldPathArrayItemValue {
	fpaiv, err := ParseUpdateServiceAccountKeyRequestCAS_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type UpdateServiceAccountKeyRequestCAS_FieldTerminalPathArrayItemValue struct {
	UpdateServiceAccountKeyRequestCAS_FieldTerminalPath
	value interface{}
}

var _ UpdateServiceAccountKeyRequestCAS_FieldPathArrayItemValue = (*UpdateServiceAccountKeyRequestCAS_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *UpdateServiceAccountKeyRequestCAS_FieldTerminalPathArrayItemValue) GetSingle(source *UpdateServiceAccountKeyRequest_CAS) (interface{}, bool) {
	return nil, false
}

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

// Contains returns a boolean indicating if value that is being held is present in given 'CAS'
func (fpaiv *UpdateServiceAccountKeyRequestCAS_FieldTerminalPathArrayItemValue) ContainsValue(source *UpdateServiceAccountKeyRequest_CAS) bool {
	slice := fpaiv.UpdateServiceAccountKeyRequestCAS_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 UpdateServiceAccountKeyRequestCAS_FieldSubPathArrayItemValue struct {
	UpdateServiceAccountKeyRequestCAS_FieldPath
	subPathItemValue gotenobject.FieldPathArrayItemValue
}

// GetRawValue returns stored array item value
func (fpaivs *UpdateServiceAccountKeyRequestCAS_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *UpdateServiceAccountKeyRequestCAS_FieldSubPathArrayItemValue) AsConditionalStatePathItemValue() (service_account_key.ServiceAccountKey_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(service_account_key.ServiceAccountKey_FieldPathArrayItemValue)
	return res, ok
}

// Contains returns a boolean indicating if value that is being held is present in given 'CAS'
func (fpaivs *UpdateServiceAccountKeyRequestCAS_FieldSubPathArrayItemValue) ContainsValue(source *UpdateServiceAccountKeyRequest_CAS) bool {
	switch fpaivs.Selector() {
	case UpdateServiceAccountKeyRequestCAS_FieldPathSelectorConditionalState:
		return fpaivs.subPathItemValue.(service_account_key.ServiceAccountKey_FieldPathArrayItemValue).ContainsValue(source.GetConditionalState())
	default:
		panic(fmt.Sprintf("Invalid selector for UpdateServiceAccountKeyRequest_CAS: %d", fpaivs.Selector()))
	}
}

// UpdateServiceAccountKeyRequestCAS_FieldPathArrayOfValues allows storing slice of values for CAS fields according to their type
type UpdateServiceAccountKeyRequestCAS_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	UpdateServiceAccountKeyRequestCAS_FieldPath
}

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

func MustParseUpdateServiceAccountKeyRequestCAS_FieldPathArrayOfValues(pathStr, valuesStr string) UpdateServiceAccountKeyRequestCAS_FieldPathArrayOfValues {
	fpaov, err := ParseUpdateServiceAccountKeyRequestCAS_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type UpdateServiceAccountKeyRequestCAS_FieldTerminalPathArrayOfValues struct {
	UpdateServiceAccountKeyRequestCAS_FieldTerminalPath
	values interface{}
}

var _ UpdateServiceAccountKeyRequestCAS_FieldPathArrayOfValues = (*UpdateServiceAccountKeyRequestCAS_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *UpdateServiceAccountKeyRequestCAS_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case UpdateServiceAccountKeyRequestCAS_FieldPathSelectorConditionalState:
		for _, v := range fpaov.values.([]*service_account_key.ServiceAccountKey) {
			values = append(values, v)
		}
	case UpdateServiceAccountKeyRequestCAS_FieldPathSelectorFieldMask:
		for _, v := range fpaov.values.([]*service_account_key.ServiceAccountKey_FieldMask) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *UpdateServiceAccountKeyRequestCAS_FieldTerminalPathArrayOfValues) AsConditionalStateArrayOfValues() ([]*service_account_key.ServiceAccountKey, bool) {
	res, ok := fpaov.values.([]*service_account_key.ServiceAccountKey)
	return res, ok
}
func (fpaov *UpdateServiceAccountKeyRequestCAS_FieldTerminalPathArrayOfValues) AsFieldMaskArrayOfValues() ([]*service_account_key.ServiceAccountKey_FieldMask, bool) {
	res, ok := fpaov.values.([]*service_account_key.ServiceAccountKey_FieldMask)
	return res, ok
}

type UpdateServiceAccountKeyRequestCAS_FieldSubPathArrayOfValues struct {
	UpdateServiceAccountKeyRequestCAS_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ UpdateServiceAccountKeyRequestCAS_FieldPathArrayOfValues = (*UpdateServiceAccountKeyRequestCAS_FieldSubPathArrayOfValues)(nil)

func (fpsaov *UpdateServiceAccountKeyRequestCAS_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *UpdateServiceAccountKeyRequestCAS_FieldSubPathArrayOfValues) AsConditionalStatePathArrayOfValues() (service_account_key.ServiceAccountKey_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(service_account_key.ServiceAccountKey_FieldPathArrayOfValues)
	return res, ok
}

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

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

type DeleteServiceAccountKeyRequest_FieldPathSelector int32

const (
	DeleteServiceAccountKeyRequest_FieldPathSelectorName DeleteServiceAccountKeyRequest_FieldPathSelector = 0
)

func (s DeleteServiceAccountKeyRequest_FieldPathSelector) String() string {
	switch s {
	case DeleteServiceAccountKeyRequest_FieldPathSelectorName:
		return "name"
	default:
		panic(fmt.Sprintf("Invalid selector for DeleteServiceAccountKeyRequest: %d", s))
	}
}

func BuildDeleteServiceAccountKeyRequest_FieldPath(fp gotenobject.RawFieldPath) (DeleteServiceAccountKeyRequest_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object DeleteServiceAccountKeyRequest")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "name":
			return &DeleteServiceAccountKeyRequest_FieldTerminalPath{selector: DeleteServiceAccountKeyRequest_FieldPathSelectorName}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object DeleteServiceAccountKeyRequest", fp)
}

func ParseDeleteServiceAccountKeyRequest_FieldPath(rawField string) (DeleteServiceAccountKeyRequest_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildDeleteServiceAccountKeyRequest_FieldPath(fp)
}

func MustParseDeleteServiceAccountKeyRequest_FieldPath(rawField string) DeleteServiceAccountKeyRequest_FieldPath {
	fp, err := ParseDeleteServiceAccountKeyRequest_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type DeleteServiceAccountKeyRequest_FieldTerminalPath struct {
	selector DeleteServiceAccountKeyRequest_FieldPathSelector
}

var _ DeleteServiceAccountKeyRequest_FieldPath = (*DeleteServiceAccountKeyRequest_FieldTerminalPath)(nil)

func (fp *DeleteServiceAccountKeyRequest_FieldTerminalPath) Selector() DeleteServiceAccountKeyRequest_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

// GetDefault returns a default value of the field type
func (fp *DeleteServiceAccountKeyRequest_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case DeleteServiceAccountKeyRequest_FieldPathSelectorName:
		return (*service_account_key.Reference)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for DeleteServiceAccountKeyRequest: %d", fp.selector))
	}
}

func (fp *DeleteServiceAccountKeyRequest_FieldTerminalPath) ClearValue(item *DeleteServiceAccountKeyRequest) {
	if item != nil {
		switch fp.selector {
		case DeleteServiceAccountKeyRequest_FieldPathSelectorName:
			item.Name = nil
		default:
			panic(fmt.Sprintf("Invalid selector for DeleteServiceAccountKeyRequest: %d", fp.selector))
		}
	}
}

func (fp *DeleteServiceAccountKeyRequest_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*DeleteServiceAccountKeyRequest))
}

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

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

func (fp *DeleteServiceAccountKeyRequest_FieldTerminalPath) WithIValue(value interface{}) DeleteServiceAccountKeyRequest_FieldPathValue {
	switch fp.selector {
	case DeleteServiceAccountKeyRequest_FieldPathSelectorName:
		return &DeleteServiceAccountKeyRequest_FieldTerminalPathValue{DeleteServiceAccountKeyRequest_FieldTerminalPath: *fp, value: value.(*service_account_key.Reference)}
	default:
		panic(fmt.Sprintf("Invalid selector for DeleteServiceAccountKeyRequest: %d", fp.selector))
	}
}

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

func (fp *DeleteServiceAccountKeyRequest_FieldTerminalPath) WithIArrayOfValues(values interface{}) DeleteServiceAccountKeyRequest_FieldPathArrayOfValues {
	fpaov := &DeleteServiceAccountKeyRequest_FieldTerminalPathArrayOfValues{DeleteServiceAccountKeyRequest_FieldTerminalPath: *fp}
	switch fp.selector {
	case DeleteServiceAccountKeyRequest_FieldPathSelectorName:
		return &DeleteServiceAccountKeyRequest_FieldTerminalPathArrayOfValues{DeleteServiceAccountKeyRequest_FieldTerminalPath: *fp, values: values.([]*service_account_key.Reference)}
	default:
		panic(fmt.Sprintf("Invalid selector for DeleteServiceAccountKeyRequest: %d", fp.selector))
	}
	return fpaov
}

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

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

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

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

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

func MustParseDeleteServiceAccountKeyRequest_FieldPathValue(pathStr, valueStr string) DeleteServiceAccountKeyRequest_FieldPathValue {
	fpv, err := ParseDeleteServiceAccountKeyRequest_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type DeleteServiceAccountKeyRequest_FieldTerminalPathValue struct {
	DeleteServiceAccountKeyRequest_FieldTerminalPath
	value interface{}
}

var _ DeleteServiceAccountKeyRequest_FieldPathValue = (*DeleteServiceAccountKeyRequest_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'DeleteServiceAccountKeyRequest' as interface{}
func (fpv *DeleteServiceAccountKeyRequest_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *DeleteServiceAccountKeyRequest_FieldTerminalPathValue) AsNameValue() (*service_account_key.Reference, bool) {
	res, ok := fpv.value.(*service_account_key.Reference)
	return res, ok
}

// SetTo stores value for selected field for object DeleteServiceAccountKeyRequest
func (fpv *DeleteServiceAccountKeyRequest_FieldTerminalPathValue) SetTo(target **DeleteServiceAccountKeyRequest) {
	if *target == nil {
		*target = new(DeleteServiceAccountKeyRequest)
	}
	switch fpv.selector {
	case DeleteServiceAccountKeyRequest_FieldPathSelectorName:
		(*target).Name = fpv.value.(*service_account_key.Reference)
	default:
		panic(fmt.Sprintf("Invalid selector for DeleteServiceAccountKeyRequest: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'DeleteServiceAccountKeyRequest_FieldTerminalPathValue' with the value under path in 'DeleteServiceAccountKeyRequest'.
func (fpv *DeleteServiceAccountKeyRequest_FieldTerminalPathValue) CompareWith(source *DeleteServiceAccountKeyRequest) (int, bool) {
	switch fpv.selector {
	case DeleteServiceAccountKeyRequest_FieldPathSelectorName:
		leftValue := fpv.value.(*service_account_key.Reference)
		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
		}
	default:
		panic(fmt.Sprintf("Invalid selector for DeleteServiceAccountKeyRequest: %d", fpv.selector))
	}
}

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

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

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

func MustParseDeleteServiceAccountKeyRequest_FieldPathArrayItemValue(pathStr, valueStr string) DeleteServiceAccountKeyRequest_FieldPathArrayItemValue {
	fpaiv, err := ParseDeleteServiceAccountKeyRequest_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type DeleteServiceAccountKeyRequest_FieldTerminalPathArrayItemValue struct {
	DeleteServiceAccountKeyRequest_FieldTerminalPath
	value interface{}
}

var _ DeleteServiceAccountKeyRequest_FieldPathArrayItemValue = (*DeleteServiceAccountKeyRequest_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *DeleteServiceAccountKeyRequest_FieldTerminalPathArrayItemValue) GetSingle(source *DeleteServiceAccountKeyRequest) (interface{}, bool) {
	return nil, false
}

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

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

// DeleteServiceAccountKeyRequest_FieldPathArrayOfValues allows storing slice of values for DeleteServiceAccountKeyRequest fields according to their type
type DeleteServiceAccountKeyRequest_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	DeleteServiceAccountKeyRequest_FieldPath
}

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

func MustParseDeleteServiceAccountKeyRequest_FieldPathArrayOfValues(pathStr, valuesStr string) DeleteServiceAccountKeyRequest_FieldPathArrayOfValues {
	fpaov, err := ParseDeleteServiceAccountKeyRequest_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type DeleteServiceAccountKeyRequest_FieldTerminalPathArrayOfValues struct {
	DeleteServiceAccountKeyRequest_FieldTerminalPath
	values interface{}
}

var _ DeleteServiceAccountKeyRequest_FieldPathArrayOfValues = (*DeleteServiceAccountKeyRequest_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *DeleteServiceAccountKeyRequest_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case DeleteServiceAccountKeyRequest_FieldPathSelectorName:
		for _, v := range fpaov.values.([]*service_account_key.Reference) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *DeleteServiceAccountKeyRequest_FieldTerminalPathArrayOfValues) AsNameArrayOfValues() ([]*service_account_key.Reference, bool) {
	res, ok := fpaov.values.([]*service_account_key.Reference)
	return res, ok
}