speed_test_custom.pb.fieldpath.go

// Code generated by protoc-gen-goten-object
// File: watchdog/proto/v1alpha2/speed_test_custom.proto
// DO NOT EDIT!!!

package speed_test_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 (
	probe "github.com/cloudwan/watchdog-sdk/resources/v1alpha2/probe"
	probing_session "github.com/cloudwan/watchdog-sdk/resources/v1alpha2/probing_session"
	probing_target "github.com/cloudwan/watchdog-sdk/resources/v1alpha2/probing_target"
)

// 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 (
	_ = &probe.Probe{}
	_ = &probing_session.ProbingSession{}
	_ = &probing_target.ProbingTarget{}
)

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

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

type RunSpeedTestRequest_FieldPathSelector int32

const (
	RunSpeedTestRequest_FieldPathSelectorName           RunSpeedTestRequest_FieldPathSelector = 0
	RunSpeedTestRequest_FieldPathSelectorDirection      RunSpeedTestRequest_FieldPathSelector = 1
	RunSpeedTestRequest_FieldPathSelectorProbingSession RunSpeedTestRequest_FieldPathSelector = 2
	RunSpeedTestRequest_FieldPathSelectorProbingTarget  RunSpeedTestRequest_FieldPathSelector = 3
)

func (s RunSpeedTestRequest_FieldPathSelector) String() string {
	switch s {
	case RunSpeedTestRequest_FieldPathSelectorName:
		return "name"
	case RunSpeedTestRequest_FieldPathSelectorDirection:
		return "direction"
	case RunSpeedTestRequest_FieldPathSelectorProbingSession:
		return "probing_session"
	case RunSpeedTestRequest_FieldPathSelectorProbingTarget:
		return "probing_target"
	default:
		panic(fmt.Sprintf("Invalid selector for RunSpeedTestRequest: %d", s))
	}
}

func BuildRunSpeedTestRequest_FieldPath(fp gotenobject.RawFieldPath) (RunSpeedTestRequest_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object RunSpeedTestRequest")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "name":
			return &RunSpeedTestRequest_FieldTerminalPath{selector: RunSpeedTestRequest_FieldPathSelectorName}, nil
		case "direction":
			return &RunSpeedTestRequest_FieldTerminalPath{selector: RunSpeedTestRequest_FieldPathSelectorDirection}, nil
		case "probing_session", "probingSession", "probing-session":
			return &RunSpeedTestRequest_FieldTerminalPath{selector: RunSpeedTestRequest_FieldPathSelectorProbingSession}, nil
		case "probing_target", "probingTarget", "probing-target":
			return &RunSpeedTestRequest_FieldTerminalPath{selector: RunSpeedTestRequest_FieldPathSelectorProbingTarget}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object RunSpeedTestRequest", fp)
}

func ParseRunSpeedTestRequest_FieldPath(rawField string) (RunSpeedTestRequest_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildRunSpeedTestRequest_FieldPath(fp)
}

func MustParseRunSpeedTestRequest_FieldPath(rawField string) RunSpeedTestRequest_FieldPath {
	fp, err := ParseRunSpeedTestRequest_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type RunSpeedTestRequest_FieldTerminalPath struct {
	selector RunSpeedTestRequest_FieldPathSelector
}

var _ RunSpeedTestRequest_FieldPath = (*RunSpeedTestRequest_FieldTerminalPath)(nil)

func (fp *RunSpeedTestRequest_FieldTerminalPath) Selector() RunSpeedTestRequest_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source RunSpeedTestRequest
func (fp *RunSpeedTestRequest_FieldTerminalPath) Get(source *RunSpeedTestRequest) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case RunSpeedTestRequest_FieldPathSelectorName:
			if source.Name != nil {
				values = append(values, source.Name)
			}
		case RunSpeedTestRequest_FieldPathSelectorDirection:
			values = append(values, source.Direction)
		case RunSpeedTestRequest_FieldPathSelectorProbingSession:
			if source.ProbingSession != nil {
				values = append(values, source.ProbingSession)
			}
		case RunSpeedTestRequest_FieldPathSelectorProbingTarget:
			if source.ProbingTarget != nil {
				values = append(values, source.ProbingTarget)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for RunSpeedTestRequest: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source RunSpeedTestRequest
func (fp *RunSpeedTestRequest_FieldTerminalPath) GetSingle(source *RunSpeedTestRequest) (interface{}, bool) {
	switch fp.selector {
	case RunSpeedTestRequest_FieldPathSelectorName:
		res := source.GetName()
		return res, res != nil
	case RunSpeedTestRequest_FieldPathSelectorDirection:
		return source.GetDirection(), source != nil
	case RunSpeedTestRequest_FieldPathSelectorProbingSession:
		res := source.GetProbingSession()
		return res, res != nil
	case RunSpeedTestRequest_FieldPathSelectorProbingTarget:
		res := source.GetProbingTarget()
		return res, res != nil
	default:
		panic(fmt.Sprintf("Invalid selector for RunSpeedTestRequest: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *RunSpeedTestRequest_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case RunSpeedTestRequest_FieldPathSelectorName:
		return (*probe.Reference)(nil)
	case RunSpeedTestRequest_FieldPathSelectorDirection:
		return SpeedTestDirection_Download
	case RunSpeedTestRequest_FieldPathSelectorProbingSession:
		return (*probing_session.Reference)(nil)
	case RunSpeedTestRequest_FieldPathSelectorProbingTarget:
		return (*probing_target.Reference)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for RunSpeedTestRequest: %d", fp.selector))
	}
}

func (fp *RunSpeedTestRequest_FieldTerminalPath) ClearValue(item *RunSpeedTestRequest) {
	if item != nil {
		switch fp.selector {
		case RunSpeedTestRequest_FieldPathSelectorName:
			item.Name = nil
		case RunSpeedTestRequest_FieldPathSelectorDirection:
			item.Direction = SpeedTestDirection_Download
		case RunSpeedTestRequest_FieldPathSelectorProbingSession:
			item.ProbingSession = nil
		case RunSpeedTestRequest_FieldPathSelectorProbingTarget:
			item.ProbingTarget = nil
		default:
			panic(fmt.Sprintf("Invalid selector for RunSpeedTestRequest: %d", fp.selector))
		}
	}
}

func (fp *RunSpeedTestRequest_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*RunSpeedTestRequest))
}

// IsLeaf - whether field path is holds simple value
func (fp *RunSpeedTestRequest_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == RunSpeedTestRequest_FieldPathSelectorName ||
		fp.selector == RunSpeedTestRequest_FieldPathSelectorDirection ||
		fp.selector == RunSpeedTestRequest_FieldPathSelectorProbingSession ||
		fp.selector == RunSpeedTestRequest_FieldPathSelectorProbingTarget
}

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

func (fp *RunSpeedTestRequest_FieldTerminalPath) WithIValue(value interface{}) RunSpeedTestRequest_FieldPathValue {
	switch fp.selector {
	case RunSpeedTestRequest_FieldPathSelectorName:
		return &RunSpeedTestRequest_FieldTerminalPathValue{RunSpeedTestRequest_FieldTerminalPath: *fp, value: value.(*probe.Reference)}
	case RunSpeedTestRequest_FieldPathSelectorDirection:
		return &RunSpeedTestRequest_FieldTerminalPathValue{RunSpeedTestRequest_FieldTerminalPath: *fp, value: value.(SpeedTestDirection)}
	case RunSpeedTestRequest_FieldPathSelectorProbingSession:
		return &RunSpeedTestRequest_FieldTerminalPathValue{RunSpeedTestRequest_FieldTerminalPath: *fp, value: value.(*probing_session.Reference)}
	case RunSpeedTestRequest_FieldPathSelectorProbingTarget:
		return &RunSpeedTestRequest_FieldTerminalPathValue{RunSpeedTestRequest_FieldTerminalPath: *fp, value: value.(*probing_target.Reference)}
	default:
		panic(fmt.Sprintf("Invalid selector for RunSpeedTestRequest: %d", fp.selector))
	}
}

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

func (fp *RunSpeedTestRequest_FieldTerminalPath) WithIArrayOfValues(values interface{}) RunSpeedTestRequest_FieldPathArrayOfValues {
	fpaov := &RunSpeedTestRequest_FieldTerminalPathArrayOfValues{RunSpeedTestRequest_FieldTerminalPath: *fp}
	switch fp.selector {
	case RunSpeedTestRequest_FieldPathSelectorName:
		return &RunSpeedTestRequest_FieldTerminalPathArrayOfValues{RunSpeedTestRequest_FieldTerminalPath: *fp, values: values.([]*probe.Reference)}
	case RunSpeedTestRequest_FieldPathSelectorDirection:
		return &RunSpeedTestRequest_FieldTerminalPathArrayOfValues{RunSpeedTestRequest_FieldTerminalPath: *fp, values: values.([]SpeedTestDirection)}
	case RunSpeedTestRequest_FieldPathSelectorProbingSession:
		return &RunSpeedTestRequest_FieldTerminalPathArrayOfValues{RunSpeedTestRequest_FieldTerminalPath: *fp, values: values.([]*probing_session.Reference)}
	case RunSpeedTestRequest_FieldPathSelectorProbingTarget:
		return &RunSpeedTestRequest_FieldTerminalPathArrayOfValues{RunSpeedTestRequest_FieldTerminalPath: *fp, values: values.([]*probing_target.Reference)}
	default:
		panic(fmt.Sprintf("Invalid selector for RunSpeedTestRequest: %d", fp.selector))
	}
	return fpaov
}

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

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

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

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

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

func MustParseRunSpeedTestRequest_FieldPathValue(pathStr, valueStr string) RunSpeedTestRequest_FieldPathValue {
	fpv, err := ParseRunSpeedTestRequest_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type RunSpeedTestRequest_FieldTerminalPathValue struct {
	RunSpeedTestRequest_FieldTerminalPath
	value interface{}
}

var _ RunSpeedTestRequest_FieldPathValue = (*RunSpeedTestRequest_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'RunSpeedTestRequest' as interface{}
func (fpv *RunSpeedTestRequest_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *RunSpeedTestRequest_FieldTerminalPathValue) AsNameValue() (*probe.Reference, bool) {
	res, ok := fpv.value.(*probe.Reference)
	return res, ok
}
func (fpv *RunSpeedTestRequest_FieldTerminalPathValue) AsDirectionValue() (SpeedTestDirection, bool) {
	res, ok := fpv.value.(SpeedTestDirection)
	return res, ok
}
func (fpv *RunSpeedTestRequest_FieldTerminalPathValue) AsProbingSessionValue() (*probing_session.Reference, bool) {
	res, ok := fpv.value.(*probing_session.Reference)
	return res, ok
}
func (fpv *RunSpeedTestRequest_FieldTerminalPathValue) AsProbingTargetValue() (*probing_target.Reference, bool) {
	res, ok := fpv.value.(*probing_target.Reference)
	return res, ok
}

// SetTo stores value for selected field for object RunSpeedTestRequest
func (fpv *RunSpeedTestRequest_FieldTerminalPathValue) SetTo(target **RunSpeedTestRequest) {
	if *target == nil {
		*target = new(RunSpeedTestRequest)
	}
	switch fpv.selector {
	case RunSpeedTestRequest_FieldPathSelectorName:
		(*target).Name = fpv.value.(*probe.Reference)
	case RunSpeedTestRequest_FieldPathSelectorDirection:
		(*target).Direction = fpv.value.(SpeedTestDirection)
	case RunSpeedTestRequest_FieldPathSelectorProbingSession:
		(*target).ProbingSession = fpv.value.(*probing_session.Reference)
	case RunSpeedTestRequest_FieldPathSelectorProbingTarget:
		(*target).ProbingTarget = fpv.value.(*probing_target.Reference)
	default:
		panic(fmt.Sprintf("Invalid selector for RunSpeedTestRequest: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'RunSpeedTestRequest_FieldTerminalPathValue' with the value under path in 'RunSpeedTestRequest'.
func (fpv *RunSpeedTestRequest_FieldTerminalPathValue) CompareWith(source *RunSpeedTestRequest) (int, bool) {
	switch fpv.selector {
	case RunSpeedTestRequest_FieldPathSelectorName:
		leftValue := fpv.value.(*probe.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 RunSpeedTestRequest_FieldPathSelectorDirection:
		leftValue := fpv.value.(SpeedTestDirection)
		rightValue := source.GetDirection()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case RunSpeedTestRequest_FieldPathSelectorProbingSession:
		leftValue := fpv.value.(*probing_session.Reference)
		rightValue := source.GetProbingSession()
		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 RunSpeedTestRequest_FieldPathSelectorProbingTarget:
		leftValue := fpv.value.(*probing_target.Reference)
		rightValue := source.GetProbingTarget()
		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 RunSpeedTestRequest: %d", fpv.selector))
	}
}

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

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

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

func MustParseRunSpeedTestRequest_FieldPathArrayItemValue(pathStr, valueStr string) RunSpeedTestRequest_FieldPathArrayItemValue {
	fpaiv, err := ParseRunSpeedTestRequest_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type RunSpeedTestRequest_FieldTerminalPathArrayItemValue struct {
	RunSpeedTestRequest_FieldTerminalPath
	value interface{}
}

var _ RunSpeedTestRequest_FieldPathArrayItemValue = (*RunSpeedTestRequest_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *RunSpeedTestRequest_FieldTerminalPathArrayItemValue) GetSingle(source *RunSpeedTestRequest) (interface{}, bool) {
	return nil, false
}

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

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

// RunSpeedTestRequest_FieldPathArrayOfValues allows storing slice of values for RunSpeedTestRequest fields according to their type
type RunSpeedTestRequest_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	RunSpeedTestRequest_FieldPath
}

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

func MustParseRunSpeedTestRequest_FieldPathArrayOfValues(pathStr, valuesStr string) RunSpeedTestRequest_FieldPathArrayOfValues {
	fpaov, err := ParseRunSpeedTestRequest_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type RunSpeedTestRequest_FieldTerminalPathArrayOfValues struct {
	RunSpeedTestRequest_FieldTerminalPath
	values interface{}
}

var _ RunSpeedTestRequest_FieldPathArrayOfValues = (*RunSpeedTestRequest_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *RunSpeedTestRequest_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case RunSpeedTestRequest_FieldPathSelectorName:
		for _, v := range fpaov.values.([]*probe.Reference) {
			values = append(values, v)
		}
	case RunSpeedTestRequest_FieldPathSelectorDirection:
		for _, v := range fpaov.values.([]SpeedTestDirection) {
			values = append(values, v)
		}
	case RunSpeedTestRequest_FieldPathSelectorProbingSession:
		for _, v := range fpaov.values.([]*probing_session.Reference) {
			values = append(values, v)
		}
	case RunSpeedTestRequest_FieldPathSelectorProbingTarget:
		for _, v := range fpaov.values.([]*probing_target.Reference) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *RunSpeedTestRequest_FieldTerminalPathArrayOfValues) AsNameArrayOfValues() ([]*probe.Reference, bool) {
	res, ok := fpaov.values.([]*probe.Reference)
	return res, ok
}
func (fpaov *RunSpeedTestRequest_FieldTerminalPathArrayOfValues) AsDirectionArrayOfValues() ([]SpeedTestDirection, bool) {
	res, ok := fpaov.values.([]SpeedTestDirection)
	return res, ok
}
func (fpaov *RunSpeedTestRequest_FieldTerminalPathArrayOfValues) AsProbingSessionArrayOfValues() ([]*probing_session.Reference, bool) {
	res, ok := fpaov.values.([]*probing_session.Reference)
	return res, ok
}
func (fpaov *RunSpeedTestRequest_FieldTerminalPathArrayOfValues) AsProbingTargetArrayOfValues() ([]*probing_target.Reference, bool) {
	res, ok := fpaov.values.([]*probing_target.Reference)
	return res, ok
}

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

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

type RunSpeedTestResponse_FieldPathSelector int32

const (
	RunSpeedTestResponse_FieldPathSelectorDirection                  RunSpeedTestResponse_FieldPathSelector = 0
	RunSpeedTestResponse_FieldPathSelectorSpeedMbps                  RunSpeedTestResponse_FieldPathSelector = 1
	RunSpeedTestResponse_FieldPathSelectorServerName                 RunSpeedTestResponse_FieldPathSelector = 2
	RunSpeedTestResponse_FieldPathSelectorServerIp                   RunSpeedTestResponse_FieldPathSelector = 3
	RunSpeedTestResponse_FieldPathSelectorServerLatency              RunSpeedTestResponse_FieldPathSelector = 4
	RunSpeedTestResponse_FieldPathSelectorServerRetransmitPercentage RunSpeedTestResponse_FieldPathSelector = 5
	RunSpeedTestResponse_FieldPathSelectorProbingSession             RunSpeedTestResponse_FieldPathSelector = 6
	RunSpeedTestResponse_FieldPathSelectorTarget                     RunSpeedTestResponse_FieldPathSelector = 7
	RunSpeedTestResponse_FieldPathSelectorLocalIp                    RunSpeedTestResponse_FieldPathSelector = 8
	RunSpeedTestResponse_FieldPathSelectorLocalInterface             RunSpeedTestResponse_FieldPathSelector = 9
	RunSpeedTestResponse_FieldPathSelectorBytesTransferred           RunSpeedTestResponse_FieldPathSelector = 10
)

func (s RunSpeedTestResponse_FieldPathSelector) String() string {
	switch s {
	case RunSpeedTestResponse_FieldPathSelectorDirection:
		return "direction"
	case RunSpeedTestResponse_FieldPathSelectorSpeedMbps:
		return "speed_mbps"
	case RunSpeedTestResponse_FieldPathSelectorServerName:
		return "server_name"
	case RunSpeedTestResponse_FieldPathSelectorServerIp:
		return "server_ip"
	case RunSpeedTestResponse_FieldPathSelectorServerLatency:
		return "server_latency"
	case RunSpeedTestResponse_FieldPathSelectorServerRetransmitPercentage:
		return "server_retransmit_percentage"
	case RunSpeedTestResponse_FieldPathSelectorProbingSession:
		return "probing_session"
	case RunSpeedTestResponse_FieldPathSelectorTarget:
		return "target"
	case RunSpeedTestResponse_FieldPathSelectorLocalIp:
		return "local_ip"
	case RunSpeedTestResponse_FieldPathSelectorLocalInterface:
		return "local_interface"
	case RunSpeedTestResponse_FieldPathSelectorBytesTransferred:
		return "bytes_transferred"
	default:
		panic(fmt.Sprintf("Invalid selector for RunSpeedTestResponse: %d", s))
	}
}

func BuildRunSpeedTestResponse_FieldPath(fp gotenobject.RawFieldPath) (RunSpeedTestResponse_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object RunSpeedTestResponse")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "direction":
			return &RunSpeedTestResponse_FieldTerminalPath{selector: RunSpeedTestResponse_FieldPathSelectorDirection}, nil
		case "speed_mbps", "speedMbps", "speed-mbps":
			return &RunSpeedTestResponse_FieldTerminalPath{selector: RunSpeedTestResponse_FieldPathSelectorSpeedMbps}, nil
		case "server_name", "serverName", "server-name":
			return &RunSpeedTestResponse_FieldTerminalPath{selector: RunSpeedTestResponse_FieldPathSelectorServerName}, nil
		case "server_ip", "serverIp", "server-ip":
			return &RunSpeedTestResponse_FieldTerminalPath{selector: RunSpeedTestResponse_FieldPathSelectorServerIp}, nil
		case "server_latency", "serverLatency", "server-latency":
			return &RunSpeedTestResponse_FieldTerminalPath{selector: RunSpeedTestResponse_FieldPathSelectorServerLatency}, nil
		case "server_retransmit_percentage", "serverRetransmitPercentage", "server-retransmit-percentage":
			return &RunSpeedTestResponse_FieldTerminalPath{selector: RunSpeedTestResponse_FieldPathSelectorServerRetransmitPercentage}, nil
		case "probing_session", "probingSession", "probing-session":
			return &RunSpeedTestResponse_FieldTerminalPath{selector: RunSpeedTestResponse_FieldPathSelectorProbingSession}, nil
		case "target":
			return &RunSpeedTestResponse_FieldTerminalPath{selector: RunSpeedTestResponse_FieldPathSelectorTarget}, nil
		case "local_ip", "localIp", "local-ip":
			return &RunSpeedTestResponse_FieldTerminalPath{selector: RunSpeedTestResponse_FieldPathSelectorLocalIp}, nil
		case "local_interface", "localInterface", "local-interface":
			return &RunSpeedTestResponse_FieldTerminalPath{selector: RunSpeedTestResponse_FieldPathSelectorLocalInterface}, nil
		case "bytes_transferred", "bytesTransferred", "bytes-transferred":
			return &RunSpeedTestResponse_FieldTerminalPath{selector: RunSpeedTestResponse_FieldPathSelectorBytesTransferred}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object RunSpeedTestResponse", fp)
}

func ParseRunSpeedTestResponse_FieldPath(rawField string) (RunSpeedTestResponse_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildRunSpeedTestResponse_FieldPath(fp)
}

func MustParseRunSpeedTestResponse_FieldPath(rawField string) RunSpeedTestResponse_FieldPath {
	fp, err := ParseRunSpeedTestResponse_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type RunSpeedTestResponse_FieldTerminalPath struct {
	selector RunSpeedTestResponse_FieldPathSelector
}

var _ RunSpeedTestResponse_FieldPath = (*RunSpeedTestResponse_FieldTerminalPath)(nil)

func (fp *RunSpeedTestResponse_FieldTerminalPath) Selector() RunSpeedTestResponse_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source RunSpeedTestResponse
func (fp *RunSpeedTestResponse_FieldTerminalPath) Get(source *RunSpeedTestResponse) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case RunSpeedTestResponse_FieldPathSelectorDirection:
			values = append(values, source.Direction)
		case RunSpeedTestResponse_FieldPathSelectorSpeedMbps:
			values = append(values, source.SpeedMbps)
		case RunSpeedTestResponse_FieldPathSelectorServerName:
			values = append(values, source.ServerName)
		case RunSpeedTestResponse_FieldPathSelectorServerIp:
			values = append(values, source.ServerIp)
		case RunSpeedTestResponse_FieldPathSelectorServerLatency:
			values = append(values, source.ServerLatency)
		case RunSpeedTestResponse_FieldPathSelectorServerRetransmitPercentage:
			values = append(values, source.ServerRetransmitPercentage)
		case RunSpeedTestResponse_FieldPathSelectorProbingSession:
			if source.ProbingSession != nil {
				values = append(values, source.ProbingSession)
			}
		case RunSpeedTestResponse_FieldPathSelectorTarget:
			if source.Target != nil {
				values = append(values, source.Target)
			}
		case RunSpeedTestResponse_FieldPathSelectorLocalIp:
			values = append(values, source.LocalIp)
		case RunSpeedTestResponse_FieldPathSelectorLocalInterface:
			values = append(values, source.LocalInterface)
		case RunSpeedTestResponse_FieldPathSelectorBytesTransferred:
			values = append(values, source.BytesTransferred)
		default:
			panic(fmt.Sprintf("Invalid selector for RunSpeedTestResponse: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source RunSpeedTestResponse
func (fp *RunSpeedTestResponse_FieldTerminalPath) GetSingle(source *RunSpeedTestResponse) (interface{}, bool) {
	switch fp.selector {
	case RunSpeedTestResponse_FieldPathSelectorDirection:
		return source.GetDirection(), source != nil
	case RunSpeedTestResponse_FieldPathSelectorSpeedMbps:
		return source.GetSpeedMbps(), source != nil
	case RunSpeedTestResponse_FieldPathSelectorServerName:
		return source.GetServerName(), source != nil
	case RunSpeedTestResponse_FieldPathSelectorServerIp:
		return source.GetServerIp(), source != nil
	case RunSpeedTestResponse_FieldPathSelectorServerLatency:
		return source.GetServerLatency(), source != nil
	case RunSpeedTestResponse_FieldPathSelectorServerRetransmitPercentage:
		return source.GetServerRetransmitPercentage(), source != nil
	case RunSpeedTestResponse_FieldPathSelectorProbingSession:
		res := source.GetProbingSession()
		return res, res != nil
	case RunSpeedTestResponse_FieldPathSelectorTarget:
		res := source.GetTarget()
		return res, res != nil
	case RunSpeedTestResponse_FieldPathSelectorLocalIp:
		return source.GetLocalIp(), source != nil
	case RunSpeedTestResponse_FieldPathSelectorLocalInterface:
		return source.GetLocalInterface(), source != nil
	case RunSpeedTestResponse_FieldPathSelectorBytesTransferred:
		return source.GetBytesTransferred(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for RunSpeedTestResponse: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *RunSpeedTestResponse_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case RunSpeedTestResponse_FieldPathSelectorDirection:
		return SpeedTestDirection_Download
	case RunSpeedTestResponse_FieldPathSelectorSpeedMbps:
		return float64(0)
	case RunSpeedTestResponse_FieldPathSelectorServerName:
		return ""
	case RunSpeedTestResponse_FieldPathSelectorServerIp:
		return ""
	case RunSpeedTestResponse_FieldPathSelectorServerLatency:
		return float64(0)
	case RunSpeedTestResponse_FieldPathSelectorServerRetransmitPercentage:
		return float64(0)
	case RunSpeedTestResponse_FieldPathSelectorProbingSession:
		return (*probing_session.Reference)(nil)
	case RunSpeedTestResponse_FieldPathSelectorTarget:
		return (*probing_target.Reference)(nil)
	case RunSpeedTestResponse_FieldPathSelectorLocalIp:
		return ""
	case RunSpeedTestResponse_FieldPathSelectorLocalInterface:
		return ""
	case RunSpeedTestResponse_FieldPathSelectorBytesTransferred:
		return int64(0)
	default:
		panic(fmt.Sprintf("Invalid selector for RunSpeedTestResponse: %d", fp.selector))
	}
}

func (fp *RunSpeedTestResponse_FieldTerminalPath) ClearValue(item *RunSpeedTestResponse) {
	if item != nil {
		switch fp.selector {
		case RunSpeedTestResponse_FieldPathSelectorDirection:
			item.Direction = SpeedTestDirection_Download
		case RunSpeedTestResponse_FieldPathSelectorSpeedMbps:
			item.SpeedMbps = float64(0)
		case RunSpeedTestResponse_FieldPathSelectorServerName:
			item.ServerName = ""
		case RunSpeedTestResponse_FieldPathSelectorServerIp:
			item.ServerIp = ""
		case RunSpeedTestResponse_FieldPathSelectorServerLatency:
			item.ServerLatency = float64(0)
		case RunSpeedTestResponse_FieldPathSelectorServerRetransmitPercentage:
			item.ServerRetransmitPercentage = float64(0)
		case RunSpeedTestResponse_FieldPathSelectorProbingSession:
			item.ProbingSession = nil
		case RunSpeedTestResponse_FieldPathSelectorTarget:
			item.Target = nil
		case RunSpeedTestResponse_FieldPathSelectorLocalIp:
			item.LocalIp = ""
		case RunSpeedTestResponse_FieldPathSelectorLocalInterface:
			item.LocalInterface = ""
		case RunSpeedTestResponse_FieldPathSelectorBytesTransferred:
			item.BytesTransferred = int64(0)
		default:
			panic(fmt.Sprintf("Invalid selector for RunSpeedTestResponse: %d", fp.selector))
		}
	}
}

func (fp *RunSpeedTestResponse_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*RunSpeedTestResponse))
}

// IsLeaf - whether field path is holds simple value
func (fp *RunSpeedTestResponse_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == RunSpeedTestResponse_FieldPathSelectorDirection ||
		fp.selector == RunSpeedTestResponse_FieldPathSelectorSpeedMbps ||
		fp.selector == RunSpeedTestResponse_FieldPathSelectorServerName ||
		fp.selector == RunSpeedTestResponse_FieldPathSelectorServerIp ||
		fp.selector == RunSpeedTestResponse_FieldPathSelectorServerLatency ||
		fp.selector == RunSpeedTestResponse_FieldPathSelectorServerRetransmitPercentage ||
		fp.selector == RunSpeedTestResponse_FieldPathSelectorProbingSession ||
		fp.selector == RunSpeedTestResponse_FieldPathSelectorTarget ||
		fp.selector == RunSpeedTestResponse_FieldPathSelectorLocalIp ||
		fp.selector == RunSpeedTestResponse_FieldPathSelectorLocalInterface ||
		fp.selector == RunSpeedTestResponse_FieldPathSelectorBytesTransferred
}

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

func (fp *RunSpeedTestResponse_FieldTerminalPath) WithIValue(value interface{}) RunSpeedTestResponse_FieldPathValue {
	switch fp.selector {
	case RunSpeedTestResponse_FieldPathSelectorDirection:
		return &RunSpeedTestResponse_FieldTerminalPathValue{RunSpeedTestResponse_FieldTerminalPath: *fp, value: value.(SpeedTestDirection)}
	case RunSpeedTestResponse_FieldPathSelectorSpeedMbps:
		return &RunSpeedTestResponse_FieldTerminalPathValue{RunSpeedTestResponse_FieldTerminalPath: *fp, value: value.(float64)}
	case RunSpeedTestResponse_FieldPathSelectorServerName:
		return &RunSpeedTestResponse_FieldTerminalPathValue{RunSpeedTestResponse_FieldTerminalPath: *fp, value: value.(string)}
	case RunSpeedTestResponse_FieldPathSelectorServerIp:
		return &RunSpeedTestResponse_FieldTerminalPathValue{RunSpeedTestResponse_FieldTerminalPath: *fp, value: value.(string)}
	case RunSpeedTestResponse_FieldPathSelectorServerLatency:
		return &RunSpeedTestResponse_FieldTerminalPathValue{RunSpeedTestResponse_FieldTerminalPath: *fp, value: value.(float64)}
	case RunSpeedTestResponse_FieldPathSelectorServerRetransmitPercentage:
		return &RunSpeedTestResponse_FieldTerminalPathValue{RunSpeedTestResponse_FieldTerminalPath: *fp, value: value.(float64)}
	case RunSpeedTestResponse_FieldPathSelectorProbingSession:
		return &RunSpeedTestResponse_FieldTerminalPathValue{RunSpeedTestResponse_FieldTerminalPath: *fp, value: value.(*probing_session.Reference)}
	case RunSpeedTestResponse_FieldPathSelectorTarget:
		return &RunSpeedTestResponse_FieldTerminalPathValue{RunSpeedTestResponse_FieldTerminalPath: *fp, value: value.(*probing_target.Reference)}
	case RunSpeedTestResponse_FieldPathSelectorLocalIp:
		return &RunSpeedTestResponse_FieldTerminalPathValue{RunSpeedTestResponse_FieldTerminalPath: *fp, value: value.(string)}
	case RunSpeedTestResponse_FieldPathSelectorLocalInterface:
		return &RunSpeedTestResponse_FieldTerminalPathValue{RunSpeedTestResponse_FieldTerminalPath: *fp, value: value.(string)}
	case RunSpeedTestResponse_FieldPathSelectorBytesTransferred:
		return &RunSpeedTestResponse_FieldTerminalPathValue{RunSpeedTestResponse_FieldTerminalPath: *fp, value: value.(int64)}
	default:
		panic(fmt.Sprintf("Invalid selector for RunSpeedTestResponse: %d", fp.selector))
	}
}

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

func (fp *RunSpeedTestResponse_FieldTerminalPath) WithIArrayOfValues(values interface{}) RunSpeedTestResponse_FieldPathArrayOfValues {
	fpaov := &RunSpeedTestResponse_FieldTerminalPathArrayOfValues{RunSpeedTestResponse_FieldTerminalPath: *fp}
	switch fp.selector {
	case RunSpeedTestResponse_FieldPathSelectorDirection:
		return &RunSpeedTestResponse_FieldTerminalPathArrayOfValues{RunSpeedTestResponse_FieldTerminalPath: *fp, values: values.([]SpeedTestDirection)}
	case RunSpeedTestResponse_FieldPathSelectorSpeedMbps:
		return &RunSpeedTestResponse_FieldTerminalPathArrayOfValues{RunSpeedTestResponse_FieldTerminalPath: *fp, values: values.([]float64)}
	case RunSpeedTestResponse_FieldPathSelectorServerName:
		return &RunSpeedTestResponse_FieldTerminalPathArrayOfValues{RunSpeedTestResponse_FieldTerminalPath: *fp, values: values.([]string)}
	case RunSpeedTestResponse_FieldPathSelectorServerIp:
		return &RunSpeedTestResponse_FieldTerminalPathArrayOfValues{RunSpeedTestResponse_FieldTerminalPath: *fp, values: values.([]string)}
	case RunSpeedTestResponse_FieldPathSelectorServerLatency:
		return &RunSpeedTestResponse_FieldTerminalPathArrayOfValues{RunSpeedTestResponse_FieldTerminalPath: *fp, values: values.([]float64)}
	case RunSpeedTestResponse_FieldPathSelectorServerRetransmitPercentage:
		return &RunSpeedTestResponse_FieldTerminalPathArrayOfValues{RunSpeedTestResponse_FieldTerminalPath: *fp, values: values.([]float64)}
	case RunSpeedTestResponse_FieldPathSelectorProbingSession:
		return &RunSpeedTestResponse_FieldTerminalPathArrayOfValues{RunSpeedTestResponse_FieldTerminalPath: *fp, values: values.([]*probing_session.Reference)}
	case RunSpeedTestResponse_FieldPathSelectorTarget:
		return &RunSpeedTestResponse_FieldTerminalPathArrayOfValues{RunSpeedTestResponse_FieldTerminalPath: *fp, values: values.([]*probing_target.Reference)}
	case RunSpeedTestResponse_FieldPathSelectorLocalIp:
		return &RunSpeedTestResponse_FieldTerminalPathArrayOfValues{RunSpeedTestResponse_FieldTerminalPath: *fp, values: values.([]string)}
	case RunSpeedTestResponse_FieldPathSelectorLocalInterface:
		return &RunSpeedTestResponse_FieldTerminalPathArrayOfValues{RunSpeedTestResponse_FieldTerminalPath: *fp, values: values.([]string)}
	case RunSpeedTestResponse_FieldPathSelectorBytesTransferred:
		return &RunSpeedTestResponse_FieldTerminalPathArrayOfValues{RunSpeedTestResponse_FieldTerminalPath: *fp, values: values.([]int64)}
	default:
		panic(fmt.Sprintf("Invalid selector for RunSpeedTestResponse: %d", fp.selector))
	}
	return fpaov
}

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

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

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

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

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

func MustParseRunSpeedTestResponse_FieldPathValue(pathStr, valueStr string) RunSpeedTestResponse_FieldPathValue {
	fpv, err := ParseRunSpeedTestResponse_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type RunSpeedTestResponse_FieldTerminalPathValue struct {
	RunSpeedTestResponse_FieldTerminalPath
	value interface{}
}

var _ RunSpeedTestResponse_FieldPathValue = (*RunSpeedTestResponse_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'RunSpeedTestResponse' as interface{}
func (fpv *RunSpeedTestResponse_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *RunSpeedTestResponse_FieldTerminalPathValue) AsDirectionValue() (SpeedTestDirection, bool) {
	res, ok := fpv.value.(SpeedTestDirection)
	return res, ok
}
func (fpv *RunSpeedTestResponse_FieldTerminalPathValue) AsSpeedMbpsValue() (float64, bool) {
	res, ok := fpv.value.(float64)
	return res, ok
}
func (fpv *RunSpeedTestResponse_FieldTerminalPathValue) AsServerNameValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *RunSpeedTestResponse_FieldTerminalPathValue) AsServerIpValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *RunSpeedTestResponse_FieldTerminalPathValue) AsServerLatencyValue() (float64, bool) {
	res, ok := fpv.value.(float64)
	return res, ok
}
func (fpv *RunSpeedTestResponse_FieldTerminalPathValue) AsServerRetransmitPercentageValue() (float64, bool) {
	res, ok := fpv.value.(float64)
	return res, ok
}
func (fpv *RunSpeedTestResponse_FieldTerminalPathValue) AsProbingSessionValue() (*probing_session.Reference, bool) {
	res, ok := fpv.value.(*probing_session.Reference)
	return res, ok
}
func (fpv *RunSpeedTestResponse_FieldTerminalPathValue) AsTargetValue() (*probing_target.Reference, bool) {
	res, ok := fpv.value.(*probing_target.Reference)
	return res, ok
}
func (fpv *RunSpeedTestResponse_FieldTerminalPathValue) AsLocalIpValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *RunSpeedTestResponse_FieldTerminalPathValue) AsLocalInterfaceValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *RunSpeedTestResponse_FieldTerminalPathValue) AsBytesTransferredValue() (int64, bool) {
	res, ok := fpv.value.(int64)
	return res, ok
}

// SetTo stores value for selected field for object RunSpeedTestResponse
func (fpv *RunSpeedTestResponse_FieldTerminalPathValue) SetTo(target **RunSpeedTestResponse) {
	if *target == nil {
		*target = new(RunSpeedTestResponse)
	}
	switch fpv.selector {
	case RunSpeedTestResponse_FieldPathSelectorDirection:
		(*target).Direction = fpv.value.(SpeedTestDirection)
	case RunSpeedTestResponse_FieldPathSelectorSpeedMbps:
		(*target).SpeedMbps = fpv.value.(float64)
	case RunSpeedTestResponse_FieldPathSelectorServerName:
		(*target).ServerName = fpv.value.(string)
	case RunSpeedTestResponse_FieldPathSelectorServerIp:
		(*target).ServerIp = fpv.value.(string)
	case RunSpeedTestResponse_FieldPathSelectorServerLatency:
		(*target).ServerLatency = fpv.value.(float64)
	case RunSpeedTestResponse_FieldPathSelectorServerRetransmitPercentage:
		(*target).ServerRetransmitPercentage = fpv.value.(float64)
	case RunSpeedTestResponse_FieldPathSelectorProbingSession:
		(*target).ProbingSession = fpv.value.(*probing_session.Reference)
	case RunSpeedTestResponse_FieldPathSelectorTarget:
		(*target).Target = fpv.value.(*probing_target.Reference)
	case RunSpeedTestResponse_FieldPathSelectorLocalIp:
		(*target).LocalIp = fpv.value.(string)
	case RunSpeedTestResponse_FieldPathSelectorLocalInterface:
		(*target).LocalInterface = fpv.value.(string)
	case RunSpeedTestResponse_FieldPathSelectorBytesTransferred:
		(*target).BytesTransferred = fpv.value.(int64)
	default:
		panic(fmt.Sprintf("Invalid selector for RunSpeedTestResponse: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'RunSpeedTestResponse_FieldTerminalPathValue' with the value under path in 'RunSpeedTestResponse'.
func (fpv *RunSpeedTestResponse_FieldTerminalPathValue) CompareWith(source *RunSpeedTestResponse) (int, bool) {
	switch fpv.selector {
	case RunSpeedTestResponse_FieldPathSelectorDirection:
		leftValue := fpv.value.(SpeedTestDirection)
		rightValue := source.GetDirection()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case RunSpeedTestResponse_FieldPathSelectorSpeedMbps:
		leftValue := fpv.value.(float64)
		rightValue := source.GetSpeedMbps()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case RunSpeedTestResponse_FieldPathSelectorServerName:
		leftValue := fpv.value.(string)
		rightValue := source.GetServerName()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case RunSpeedTestResponse_FieldPathSelectorServerIp:
		leftValue := fpv.value.(string)
		rightValue := source.GetServerIp()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case RunSpeedTestResponse_FieldPathSelectorServerLatency:
		leftValue := fpv.value.(float64)
		rightValue := source.GetServerLatency()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case RunSpeedTestResponse_FieldPathSelectorServerRetransmitPercentage:
		leftValue := fpv.value.(float64)
		rightValue := source.GetServerRetransmitPercentage()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case RunSpeedTestResponse_FieldPathSelectorProbingSession:
		leftValue := fpv.value.(*probing_session.Reference)
		rightValue := source.GetProbingSession()
		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 RunSpeedTestResponse_FieldPathSelectorTarget:
		leftValue := fpv.value.(*probing_target.Reference)
		rightValue := source.GetTarget()
		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 RunSpeedTestResponse_FieldPathSelectorLocalIp:
		leftValue := fpv.value.(string)
		rightValue := source.GetLocalIp()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case RunSpeedTestResponse_FieldPathSelectorLocalInterface:
		leftValue := fpv.value.(string)
		rightValue := source.GetLocalInterface()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case RunSpeedTestResponse_FieldPathSelectorBytesTransferred:
		leftValue := fpv.value.(int64)
		rightValue := source.GetBytesTransferred()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for RunSpeedTestResponse: %d", fpv.selector))
	}
}

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

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

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

func MustParseRunSpeedTestResponse_FieldPathArrayItemValue(pathStr, valueStr string) RunSpeedTestResponse_FieldPathArrayItemValue {
	fpaiv, err := ParseRunSpeedTestResponse_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type RunSpeedTestResponse_FieldTerminalPathArrayItemValue struct {
	RunSpeedTestResponse_FieldTerminalPath
	value interface{}
}

var _ RunSpeedTestResponse_FieldPathArrayItemValue = (*RunSpeedTestResponse_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *RunSpeedTestResponse_FieldTerminalPathArrayItemValue) GetSingle(source *RunSpeedTestResponse) (interface{}, bool) {
	return nil, false
}

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

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

// RunSpeedTestResponse_FieldPathArrayOfValues allows storing slice of values for RunSpeedTestResponse fields according to their type
type RunSpeedTestResponse_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	RunSpeedTestResponse_FieldPath
}

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

func MustParseRunSpeedTestResponse_FieldPathArrayOfValues(pathStr, valuesStr string) RunSpeedTestResponse_FieldPathArrayOfValues {
	fpaov, err := ParseRunSpeedTestResponse_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type RunSpeedTestResponse_FieldTerminalPathArrayOfValues struct {
	RunSpeedTestResponse_FieldTerminalPath
	values interface{}
}

var _ RunSpeedTestResponse_FieldPathArrayOfValues = (*RunSpeedTestResponse_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *RunSpeedTestResponse_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case RunSpeedTestResponse_FieldPathSelectorDirection:
		for _, v := range fpaov.values.([]SpeedTestDirection) {
			values = append(values, v)
		}
	case RunSpeedTestResponse_FieldPathSelectorSpeedMbps:
		for _, v := range fpaov.values.([]float64) {
			values = append(values, v)
		}
	case RunSpeedTestResponse_FieldPathSelectorServerName:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case RunSpeedTestResponse_FieldPathSelectorServerIp:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case RunSpeedTestResponse_FieldPathSelectorServerLatency:
		for _, v := range fpaov.values.([]float64) {
			values = append(values, v)
		}
	case RunSpeedTestResponse_FieldPathSelectorServerRetransmitPercentage:
		for _, v := range fpaov.values.([]float64) {
			values = append(values, v)
		}
	case RunSpeedTestResponse_FieldPathSelectorProbingSession:
		for _, v := range fpaov.values.([]*probing_session.Reference) {
			values = append(values, v)
		}
	case RunSpeedTestResponse_FieldPathSelectorTarget:
		for _, v := range fpaov.values.([]*probing_target.Reference) {
			values = append(values, v)
		}
	case RunSpeedTestResponse_FieldPathSelectorLocalIp:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case RunSpeedTestResponse_FieldPathSelectorLocalInterface:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case RunSpeedTestResponse_FieldPathSelectorBytesTransferred:
		for _, v := range fpaov.values.([]int64) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *RunSpeedTestResponse_FieldTerminalPathArrayOfValues) AsDirectionArrayOfValues() ([]SpeedTestDirection, bool) {
	res, ok := fpaov.values.([]SpeedTestDirection)
	return res, ok
}
func (fpaov *RunSpeedTestResponse_FieldTerminalPathArrayOfValues) AsSpeedMbpsArrayOfValues() ([]float64, bool) {
	res, ok := fpaov.values.([]float64)
	return res, ok
}
func (fpaov *RunSpeedTestResponse_FieldTerminalPathArrayOfValues) AsServerNameArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *RunSpeedTestResponse_FieldTerminalPathArrayOfValues) AsServerIpArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *RunSpeedTestResponse_FieldTerminalPathArrayOfValues) AsServerLatencyArrayOfValues() ([]float64, bool) {
	res, ok := fpaov.values.([]float64)
	return res, ok
}
func (fpaov *RunSpeedTestResponse_FieldTerminalPathArrayOfValues) AsServerRetransmitPercentageArrayOfValues() ([]float64, bool) {
	res, ok := fpaov.values.([]float64)
	return res, ok
}
func (fpaov *RunSpeedTestResponse_FieldTerminalPathArrayOfValues) AsProbingSessionArrayOfValues() ([]*probing_session.Reference, bool) {
	res, ok := fpaov.values.([]*probing_session.Reference)
	return res, ok
}
func (fpaov *RunSpeedTestResponse_FieldTerminalPathArrayOfValues) AsTargetArrayOfValues() ([]*probing_target.Reference, bool) {
	res, ok := fpaov.values.([]*probing_target.Reference)
	return res, ok
}
func (fpaov *RunSpeedTestResponse_FieldTerminalPathArrayOfValues) AsLocalIpArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *RunSpeedTestResponse_FieldTerminalPathArrayOfValues) AsLocalInterfaceArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *RunSpeedTestResponse_FieldTerminalPathArrayOfValues) AsBytesTransferredArrayOfValues() ([]int64, bool) {
	res, ok := fpaov.values.([]int64)
	return res, ok
}

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

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

type RunSpeedTestRequestToProbe_FieldPathSelector int32

const (
	RunSpeedTestRequestToProbe_FieldPathSelectorDirection      RunSpeedTestRequestToProbe_FieldPathSelector = 0
	RunSpeedTestRequestToProbe_FieldPathSelectorTargetName     RunSpeedTestRequestToProbe_FieldPathSelector = 1
	RunSpeedTestRequestToProbe_FieldPathSelectorProbingSession RunSpeedTestRequestToProbe_FieldPathSelector = 2
)

func (s RunSpeedTestRequestToProbe_FieldPathSelector) String() string {
	switch s {
	case RunSpeedTestRequestToProbe_FieldPathSelectorDirection:
		return "direction"
	case RunSpeedTestRequestToProbe_FieldPathSelectorTargetName:
		return "target_name"
	case RunSpeedTestRequestToProbe_FieldPathSelectorProbingSession:
		return "probing_session"
	default:
		panic(fmt.Sprintf("Invalid selector for RunSpeedTestRequestToProbe: %d", s))
	}
}

func BuildRunSpeedTestRequestToProbe_FieldPath(fp gotenobject.RawFieldPath) (RunSpeedTestRequestToProbe_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object RunSpeedTestRequestToProbe")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "direction":
			return &RunSpeedTestRequestToProbe_FieldTerminalPath{selector: RunSpeedTestRequestToProbe_FieldPathSelectorDirection}, nil
		case "target_name", "targetName", "target-name":
			return &RunSpeedTestRequestToProbe_FieldTerminalPath{selector: RunSpeedTestRequestToProbe_FieldPathSelectorTargetName}, nil
		case "probing_session", "probingSession", "probing-session":
			return &RunSpeedTestRequestToProbe_FieldTerminalPath{selector: RunSpeedTestRequestToProbe_FieldPathSelectorProbingSession}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object RunSpeedTestRequestToProbe", fp)
}

func ParseRunSpeedTestRequestToProbe_FieldPath(rawField string) (RunSpeedTestRequestToProbe_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildRunSpeedTestRequestToProbe_FieldPath(fp)
}

func MustParseRunSpeedTestRequestToProbe_FieldPath(rawField string) RunSpeedTestRequestToProbe_FieldPath {
	fp, err := ParseRunSpeedTestRequestToProbe_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type RunSpeedTestRequestToProbe_FieldTerminalPath struct {
	selector RunSpeedTestRequestToProbe_FieldPathSelector
}

var _ RunSpeedTestRequestToProbe_FieldPath = (*RunSpeedTestRequestToProbe_FieldTerminalPath)(nil)

func (fp *RunSpeedTestRequestToProbe_FieldTerminalPath) Selector() RunSpeedTestRequestToProbe_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source RunSpeedTestRequestToProbe
func (fp *RunSpeedTestRequestToProbe_FieldTerminalPath) Get(source *RunSpeedTestRequestToProbe) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case RunSpeedTestRequestToProbe_FieldPathSelectorDirection:
			values = append(values, source.Direction)
		case RunSpeedTestRequestToProbe_FieldPathSelectorTargetName:
			values = append(values, source.TargetName)
		case RunSpeedTestRequestToProbe_FieldPathSelectorProbingSession:
			values = append(values, source.ProbingSession)
		default:
			panic(fmt.Sprintf("Invalid selector for RunSpeedTestRequestToProbe: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source RunSpeedTestRequestToProbe
func (fp *RunSpeedTestRequestToProbe_FieldTerminalPath) GetSingle(source *RunSpeedTestRequestToProbe) (interface{}, bool) {
	switch fp.selector {
	case RunSpeedTestRequestToProbe_FieldPathSelectorDirection:
		return source.GetDirection(), source != nil
	case RunSpeedTestRequestToProbe_FieldPathSelectorTargetName:
		return source.GetTargetName(), source != nil
	case RunSpeedTestRequestToProbe_FieldPathSelectorProbingSession:
		return source.GetProbingSession(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for RunSpeedTestRequestToProbe: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *RunSpeedTestRequestToProbe_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case RunSpeedTestRequestToProbe_FieldPathSelectorDirection:
		return SpeedTestDirection_Download
	case RunSpeedTestRequestToProbe_FieldPathSelectorTargetName:
		return ""
	case RunSpeedTestRequestToProbe_FieldPathSelectorProbingSession:
		return ""
	default:
		panic(fmt.Sprintf("Invalid selector for RunSpeedTestRequestToProbe: %d", fp.selector))
	}
}

func (fp *RunSpeedTestRequestToProbe_FieldTerminalPath) ClearValue(item *RunSpeedTestRequestToProbe) {
	if item != nil {
		switch fp.selector {
		case RunSpeedTestRequestToProbe_FieldPathSelectorDirection:
			item.Direction = SpeedTestDirection_Download
		case RunSpeedTestRequestToProbe_FieldPathSelectorTargetName:
			item.TargetName = ""
		case RunSpeedTestRequestToProbe_FieldPathSelectorProbingSession:
			item.ProbingSession = ""
		default:
			panic(fmt.Sprintf("Invalid selector for RunSpeedTestRequestToProbe: %d", fp.selector))
		}
	}
}

func (fp *RunSpeedTestRequestToProbe_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*RunSpeedTestRequestToProbe))
}

// IsLeaf - whether field path is holds simple value
func (fp *RunSpeedTestRequestToProbe_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == RunSpeedTestRequestToProbe_FieldPathSelectorDirection ||
		fp.selector == RunSpeedTestRequestToProbe_FieldPathSelectorTargetName ||
		fp.selector == RunSpeedTestRequestToProbe_FieldPathSelectorProbingSession
}

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

func (fp *RunSpeedTestRequestToProbe_FieldTerminalPath) WithIValue(value interface{}) RunSpeedTestRequestToProbe_FieldPathValue {
	switch fp.selector {
	case RunSpeedTestRequestToProbe_FieldPathSelectorDirection:
		return &RunSpeedTestRequestToProbe_FieldTerminalPathValue{RunSpeedTestRequestToProbe_FieldTerminalPath: *fp, value: value.(SpeedTestDirection)}
	case RunSpeedTestRequestToProbe_FieldPathSelectorTargetName:
		return &RunSpeedTestRequestToProbe_FieldTerminalPathValue{RunSpeedTestRequestToProbe_FieldTerminalPath: *fp, value: value.(string)}
	case RunSpeedTestRequestToProbe_FieldPathSelectorProbingSession:
		return &RunSpeedTestRequestToProbe_FieldTerminalPathValue{RunSpeedTestRequestToProbe_FieldTerminalPath: *fp, value: value.(string)}
	default:
		panic(fmt.Sprintf("Invalid selector for RunSpeedTestRequestToProbe: %d", fp.selector))
	}
}

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

func (fp *RunSpeedTestRequestToProbe_FieldTerminalPath) WithIArrayOfValues(values interface{}) RunSpeedTestRequestToProbe_FieldPathArrayOfValues {
	fpaov := &RunSpeedTestRequestToProbe_FieldTerminalPathArrayOfValues{RunSpeedTestRequestToProbe_FieldTerminalPath: *fp}
	switch fp.selector {
	case RunSpeedTestRequestToProbe_FieldPathSelectorDirection:
		return &RunSpeedTestRequestToProbe_FieldTerminalPathArrayOfValues{RunSpeedTestRequestToProbe_FieldTerminalPath: *fp, values: values.([]SpeedTestDirection)}
	case RunSpeedTestRequestToProbe_FieldPathSelectorTargetName:
		return &RunSpeedTestRequestToProbe_FieldTerminalPathArrayOfValues{RunSpeedTestRequestToProbe_FieldTerminalPath: *fp, values: values.([]string)}
	case RunSpeedTestRequestToProbe_FieldPathSelectorProbingSession:
		return &RunSpeedTestRequestToProbe_FieldTerminalPathArrayOfValues{RunSpeedTestRequestToProbe_FieldTerminalPath: *fp, values: values.([]string)}
	default:
		panic(fmt.Sprintf("Invalid selector for RunSpeedTestRequestToProbe: %d", fp.selector))
	}
	return fpaov
}

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

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

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

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

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

func MustParseRunSpeedTestRequestToProbe_FieldPathValue(pathStr, valueStr string) RunSpeedTestRequestToProbe_FieldPathValue {
	fpv, err := ParseRunSpeedTestRequestToProbe_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type RunSpeedTestRequestToProbe_FieldTerminalPathValue struct {
	RunSpeedTestRequestToProbe_FieldTerminalPath
	value interface{}
}

var _ RunSpeedTestRequestToProbe_FieldPathValue = (*RunSpeedTestRequestToProbe_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'RunSpeedTestRequestToProbe' as interface{}
func (fpv *RunSpeedTestRequestToProbe_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *RunSpeedTestRequestToProbe_FieldTerminalPathValue) AsDirectionValue() (SpeedTestDirection, bool) {
	res, ok := fpv.value.(SpeedTestDirection)
	return res, ok
}
func (fpv *RunSpeedTestRequestToProbe_FieldTerminalPathValue) AsTargetNameValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *RunSpeedTestRequestToProbe_FieldTerminalPathValue) AsProbingSessionValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}

// SetTo stores value for selected field for object RunSpeedTestRequestToProbe
func (fpv *RunSpeedTestRequestToProbe_FieldTerminalPathValue) SetTo(target **RunSpeedTestRequestToProbe) {
	if *target == nil {
		*target = new(RunSpeedTestRequestToProbe)
	}
	switch fpv.selector {
	case RunSpeedTestRequestToProbe_FieldPathSelectorDirection:
		(*target).Direction = fpv.value.(SpeedTestDirection)
	case RunSpeedTestRequestToProbe_FieldPathSelectorTargetName:
		(*target).TargetName = fpv.value.(string)
	case RunSpeedTestRequestToProbe_FieldPathSelectorProbingSession:
		(*target).ProbingSession = fpv.value.(string)
	default:
		panic(fmt.Sprintf("Invalid selector for RunSpeedTestRequestToProbe: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'RunSpeedTestRequestToProbe_FieldTerminalPathValue' with the value under path in 'RunSpeedTestRequestToProbe'.
func (fpv *RunSpeedTestRequestToProbe_FieldTerminalPathValue) CompareWith(source *RunSpeedTestRequestToProbe) (int, bool) {
	switch fpv.selector {
	case RunSpeedTestRequestToProbe_FieldPathSelectorDirection:
		leftValue := fpv.value.(SpeedTestDirection)
		rightValue := source.GetDirection()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case RunSpeedTestRequestToProbe_FieldPathSelectorTargetName:
		leftValue := fpv.value.(string)
		rightValue := source.GetTargetName()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case RunSpeedTestRequestToProbe_FieldPathSelectorProbingSession:
		leftValue := fpv.value.(string)
		rightValue := source.GetProbingSession()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for RunSpeedTestRequestToProbe: %d", fpv.selector))
	}
}

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

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

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

func MustParseRunSpeedTestRequestToProbe_FieldPathArrayItemValue(pathStr, valueStr string) RunSpeedTestRequestToProbe_FieldPathArrayItemValue {
	fpaiv, err := ParseRunSpeedTestRequestToProbe_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type RunSpeedTestRequestToProbe_FieldTerminalPathArrayItemValue struct {
	RunSpeedTestRequestToProbe_FieldTerminalPath
	value interface{}
}

var _ RunSpeedTestRequestToProbe_FieldPathArrayItemValue = (*RunSpeedTestRequestToProbe_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *RunSpeedTestRequestToProbe_FieldTerminalPathArrayItemValue) GetSingle(source *RunSpeedTestRequestToProbe) (interface{}, bool) {
	return nil, false
}

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

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

// RunSpeedTestRequestToProbe_FieldPathArrayOfValues allows storing slice of values for RunSpeedTestRequestToProbe fields according to their type
type RunSpeedTestRequestToProbe_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	RunSpeedTestRequestToProbe_FieldPath
}

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

func MustParseRunSpeedTestRequestToProbe_FieldPathArrayOfValues(pathStr, valuesStr string) RunSpeedTestRequestToProbe_FieldPathArrayOfValues {
	fpaov, err := ParseRunSpeedTestRequestToProbe_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type RunSpeedTestRequestToProbe_FieldTerminalPathArrayOfValues struct {
	RunSpeedTestRequestToProbe_FieldTerminalPath
	values interface{}
}

var _ RunSpeedTestRequestToProbe_FieldPathArrayOfValues = (*RunSpeedTestRequestToProbe_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *RunSpeedTestRequestToProbe_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case RunSpeedTestRequestToProbe_FieldPathSelectorDirection:
		for _, v := range fpaov.values.([]SpeedTestDirection) {
			values = append(values, v)
		}
	case RunSpeedTestRequestToProbe_FieldPathSelectorTargetName:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case RunSpeedTestRequestToProbe_FieldPathSelectorProbingSession:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *RunSpeedTestRequestToProbe_FieldTerminalPathArrayOfValues) AsDirectionArrayOfValues() ([]SpeedTestDirection, bool) {
	res, ok := fpaov.values.([]SpeedTestDirection)
	return res, ok
}
func (fpaov *RunSpeedTestRequestToProbe_FieldTerminalPathArrayOfValues) AsTargetNameArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *RunSpeedTestRequestToProbe_FieldTerminalPathArrayOfValues) AsProbingSessionArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}