phantom_time_serie_service.pb.fieldpath.go

// Code generated by protoc-gen-goten-object
// File: edgelq/monitoring/proto/v3/phantom_time_serie_service.proto
// DO NOT EDIT!!!

package phantom_time_serie_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 (
	phantom_time_serie "github.com/cloudwan/edgelq-sdk/monitoring/resources/v3/phantom_time_serie"
	project "github.com/cloudwan/edgelq-sdk/monitoring/resources/v3/project"
	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 (
	_ = &phantom_time_serie.PhantomTimeSerie{}
	_ = &project.Project{}
	_ = &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 GetPhantomTimeSerieRequest_FieldPath interface {
	gotenobject.FieldPath
	Selector() GetPhantomTimeSerieRequest_FieldPathSelector
	Get(source *GetPhantomTimeSerieRequest) []interface{}
	GetSingle(source *GetPhantomTimeSerieRequest) (interface{}, bool)
	ClearValue(item *GetPhantomTimeSerieRequest)

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

type GetPhantomTimeSerieRequest_FieldPathSelector int32

const (
	GetPhantomTimeSerieRequest_FieldPathSelectorName      GetPhantomTimeSerieRequest_FieldPathSelector = 0
	GetPhantomTimeSerieRequest_FieldPathSelectorFieldMask GetPhantomTimeSerieRequest_FieldPathSelector = 1
	GetPhantomTimeSerieRequest_FieldPathSelectorView      GetPhantomTimeSerieRequest_FieldPathSelector = 2
)

func (s GetPhantomTimeSerieRequest_FieldPathSelector) String() string {
	switch s {
	case GetPhantomTimeSerieRequest_FieldPathSelectorName:
		return "name"
	case GetPhantomTimeSerieRequest_FieldPathSelectorFieldMask:
		return "field_mask"
	case GetPhantomTimeSerieRequest_FieldPathSelectorView:
		return "view"
	default:
		panic(fmt.Sprintf("Invalid selector for GetPhantomTimeSerieRequest: %d", s))
	}
}

func BuildGetPhantomTimeSerieRequest_FieldPath(fp gotenobject.RawFieldPath) (GetPhantomTimeSerieRequest_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object GetPhantomTimeSerieRequest")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "name":
			return &GetPhantomTimeSerieRequest_FieldTerminalPath{selector: GetPhantomTimeSerieRequest_FieldPathSelectorName}, nil
		case "field_mask", "fieldMask", "field-mask":
			return &GetPhantomTimeSerieRequest_FieldTerminalPath{selector: GetPhantomTimeSerieRequest_FieldPathSelectorFieldMask}, nil
		case "view":
			return &GetPhantomTimeSerieRequest_FieldTerminalPath{selector: GetPhantomTimeSerieRequest_FieldPathSelectorView}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object GetPhantomTimeSerieRequest", fp)
}

func ParseGetPhantomTimeSerieRequest_FieldPath(rawField string) (GetPhantomTimeSerieRequest_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildGetPhantomTimeSerieRequest_FieldPath(fp)
}

func MustParseGetPhantomTimeSerieRequest_FieldPath(rawField string) GetPhantomTimeSerieRequest_FieldPath {
	fp, err := ParseGetPhantomTimeSerieRequest_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type GetPhantomTimeSerieRequest_FieldTerminalPath struct {
	selector GetPhantomTimeSerieRequest_FieldPathSelector
}

var _ GetPhantomTimeSerieRequest_FieldPath = (*GetPhantomTimeSerieRequest_FieldTerminalPath)(nil)

func (fp *GetPhantomTimeSerieRequest_FieldTerminalPath) Selector() GetPhantomTimeSerieRequest_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

// GetDefault returns a default value of the field type
func (fp *GetPhantomTimeSerieRequest_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case GetPhantomTimeSerieRequest_FieldPathSelectorName:
		return (*phantom_time_serie.Reference)(nil)
	case GetPhantomTimeSerieRequest_FieldPathSelectorFieldMask:
		return (*phantom_time_serie.PhantomTimeSerie_FieldMask)(nil)
	case GetPhantomTimeSerieRequest_FieldPathSelectorView:
		return view.View_UNSPECIFIED
	default:
		panic(fmt.Sprintf("Invalid selector for GetPhantomTimeSerieRequest: %d", fp.selector))
	}
}

func (fp *GetPhantomTimeSerieRequest_FieldTerminalPath) ClearValue(item *GetPhantomTimeSerieRequest) {
	if item != nil {
		switch fp.selector {
		case GetPhantomTimeSerieRequest_FieldPathSelectorName:
			item.Name = nil
		case GetPhantomTimeSerieRequest_FieldPathSelectorFieldMask:
			item.FieldMask = nil
		case GetPhantomTimeSerieRequest_FieldPathSelectorView:
			item.View = view.View_UNSPECIFIED
		default:
			panic(fmt.Sprintf("Invalid selector for GetPhantomTimeSerieRequest: %d", fp.selector))
		}
	}
}

func (fp *GetPhantomTimeSerieRequest_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*GetPhantomTimeSerieRequest))
}

// IsLeaf - whether field path is holds simple value
func (fp *GetPhantomTimeSerieRequest_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == GetPhantomTimeSerieRequest_FieldPathSelectorName ||
		fp.selector == GetPhantomTimeSerieRequest_FieldPathSelectorFieldMask ||
		fp.selector == GetPhantomTimeSerieRequest_FieldPathSelectorView
}

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

func (fp *GetPhantomTimeSerieRequest_FieldTerminalPath) WithIValue(value interface{}) GetPhantomTimeSerieRequest_FieldPathValue {
	switch fp.selector {
	case GetPhantomTimeSerieRequest_FieldPathSelectorName:
		return &GetPhantomTimeSerieRequest_FieldTerminalPathValue{GetPhantomTimeSerieRequest_FieldTerminalPath: *fp, value: value.(*phantom_time_serie.Reference)}
	case GetPhantomTimeSerieRequest_FieldPathSelectorFieldMask:
		return &GetPhantomTimeSerieRequest_FieldTerminalPathValue{GetPhantomTimeSerieRequest_FieldTerminalPath: *fp, value: value.(*phantom_time_serie.PhantomTimeSerie_FieldMask)}
	case GetPhantomTimeSerieRequest_FieldPathSelectorView:
		return &GetPhantomTimeSerieRequest_FieldTerminalPathValue{GetPhantomTimeSerieRequest_FieldTerminalPath: *fp, value: value.(view.View)}
	default:
		panic(fmt.Sprintf("Invalid selector for GetPhantomTimeSerieRequest: %d", fp.selector))
	}
}

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

func (fp *GetPhantomTimeSerieRequest_FieldTerminalPath) WithIArrayOfValues(values interface{}) GetPhantomTimeSerieRequest_FieldPathArrayOfValues {
	fpaov := &GetPhantomTimeSerieRequest_FieldTerminalPathArrayOfValues{GetPhantomTimeSerieRequest_FieldTerminalPath: *fp}
	switch fp.selector {
	case GetPhantomTimeSerieRequest_FieldPathSelectorName:
		return &GetPhantomTimeSerieRequest_FieldTerminalPathArrayOfValues{GetPhantomTimeSerieRequest_FieldTerminalPath: *fp, values: values.([]*phantom_time_serie.Reference)}
	case GetPhantomTimeSerieRequest_FieldPathSelectorFieldMask:
		return &GetPhantomTimeSerieRequest_FieldTerminalPathArrayOfValues{GetPhantomTimeSerieRequest_FieldTerminalPath: *fp, values: values.([]*phantom_time_serie.PhantomTimeSerie_FieldMask)}
	case GetPhantomTimeSerieRequest_FieldPathSelectorView:
		return &GetPhantomTimeSerieRequest_FieldTerminalPathArrayOfValues{GetPhantomTimeSerieRequest_FieldTerminalPath: *fp, values: values.([]view.View)}
	default:
		panic(fmt.Sprintf("Invalid selector for GetPhantomTimeSerieRequest: %d", fp.selector))
	}
	return fpaov
}

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

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

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

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

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

func MustParseGetPhantomTimeSerieRequest_FieldPathValue(pathStr, valueStr string) GetPhantomTimeSerieRequest_FieldPathValue {
	fpv, err := ParseGetPhantomTimeSerieRequest_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type GetPhantomTimeSerieRequest_FieldTerminalPathValue struct {
	GetPhantomTimeSerieRequest_FieldTerminalPath
	value interface{}
}

var _ GetPhantomTimeSerieRequest_FieldPathValue = (*GetPhantomTimeSerieRequest_FieldTerminalPathValue)(nil)

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

// SetTo stores value for selected field for object GetPhantomTimeSerieRequest
func (fpv *GetPhantomTimeSerieRequest_FieldTerminalPathValue) SetTo(target **GetPhantomTimeSerieRequest) {
	if *target == nil {
		*target = new(GetPhantomTimeSerieRequest)
	}
	switch fpv.selector {
	case GetPhantomTimeSerieRequest_FieldPathSelectorName:
		(*target).Name = fpv.value.(*phantom_time_serie.Reference)
	case GetPhantomTimeSerieRequest_FieldPathSelectorFieldMask:
		(*target).FieldMask = fpv.value.(*phantom_time_serie.PhantomTimeSerie_FieldMask)
	case GetPhantomTimeSerieRequest_FieldPathSelectorView:
		(*target).View = fpv.value.(view.View)
	default:
		panic(fmt.Sprintf("Invalid selector for GetPhantomTimeSerieRequest: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'GetPhantomTimeSerieRequest_FieldTerminalPathValue' with the value under path in 'GetPhantomTimeSerieRequest'.
func (fpv *GetPhantomTimeSerieRequest_FieldTerminalPathValue) CompareWith(source *GetPhantomTimeSerieRequest) (int, bool) {
	switch fpv.selector {
	case GetPhantomTimeSerieRequest_FieldPathSelectorName:
		leftValue := fpv.value.(*phantom_time_serie.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 GetPhantomTimeSerieRequest_FieldPathSelectorFieldMask:
		return 0, false
	case GetPhantomTimeSerieRequest_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 GetPhantomTimeSerieRequest: %d", fpv.selector))
	}
}

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

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

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

func MustParseGetPhantomTimeSerieRequest_FieldPathArrayItemValue(pathStr, valueStr string) GetPhantomTimeSerieRequest_FieldPathArrayItemValue {
	fpaiv, err := ParseGetPhantomTimeSerieRequest_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type GetPhantomTimeSerieRequest_FieldTerminalPathArrayItemValue struct {
	GetPhantomTimeSerieRequest_FieldTerminalPath
	value interface{}
}

var _ GetPhantomTimeSerieRequest_FieldPathArrayItemValue = (*GetPhantomTimeSerieRequest_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *GetPhantomTimeSerieRequest_FieldTerminalPathArrayItemValue) GetSingle(source *GetPhantomTimeSerieRequest) (interface{}, bool) {
	return nil, false
}

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

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

// GetPhantomTimeSerieRequest_FieldPathArrayOfValues allows storing slice of values for GetPhantomTimeSerieRequest fields according to their type
type GetPhantomTimeSerieRequest_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	GetPhantomTimeSerieRequest_FieldPath
}

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

func MustParseGetPhantomTimeSerieRequest_FieldPathArrayOfValues(pathStr, valuesStr string) GetPhantomTimeSerieRequest_FieldPathArrayOfValues {
	fpaov, err := ParseGetPhantomTimeSerieRequest_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type GetPhantomTimeSerieRequest_FieldTerminalPathArrayOfValues struct {
	GetPhantomTimeSerieRequest_FieldTerminalPath
	values interface{}
}

var _ GetPhantomTimeSerieRequest_FieldPathArrayOfValues = (*GetPhantomTimeSerieRequest_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *GetPhantomTimeSerieRequest_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case GetPhantomTimeSerieRequest_FieldPathSelectorName:
		for _, v := range fpaov.values.([]*phantom_time_serie.Reference) {
			values = append(values, v)
		}
	case GetPhantomTimeSerieRequest_FieldPathSelectorFieldMask:
		for _, v := range fpaov.values.([]*phantom_time_serie.PhantomTimeSerie_FieldMask) {
			values = append(values, v)
		}
	case GetPhantomTimeSerieRequest_FieldPathSelectorView:
		for _, v := range fpaov.values.([]view.View) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *GetPhantomTimeSerieRequest_FieldTerminalPathArrayOfValues) AsNameArrayOfValues() ([]*phantom_time_serie.Reference, bool) {
	res, ok := fpaov.values.([]*phantom_time_serie.Reference)
	return res, ok
}
func (fpaov *GetPhantomTimeSerieRequest_FieldTerminalPathArrayOfValues) AsFieldMaskArrayOfValues() ([]*phantom_time_serie.PhantomTimeSerie_FieldMask, bool) {
	res, ok := fpaov.values.([]*phantom_time_serie.PhantomTimeSerie_FieldMask)
	return res, ok
}
func (fpaov *GetPhantomTimeSerieRequest_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 BatchGetPhantomTimeSeriesRequest_FieldPath interface {
	gotenobject.FieldPath
	Selector() BatchGetPhantomTimeSeriesRequest_FieldPathSelector
	Get(source *BatchGetPhantomTimeSeriesRequest) []interface{}
	GetSingle(source *BatchGetPhantomTimeSeriesRequest) (interface{}, bool)
	ClearValue(item *BatchGetPhantomTimeSeriesRequest)

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

type BatchGetPhantomTimeSeriesRequest_FieldPathSelector int32

const (
	BatchGetPhantomTimeSeriesRequest_FieldPathSelectorNames     BatchGetPhantomTimeSeriesRequest_FieldPathSelector = 0
	BatchGetPhantomTimeSeriesRequest_FieldPathSelectorFieldMask BatchGetPhantomTimeSeriesRequest_FieldPathSelector = 1
	BatchGetPhantomTimeSeriesRequest_FieldPathSelectorView      BatchGetPhantomTimeSeriesRequest_FieldPathSelector = 2
)

func (s BatchGetPhantomTimeSeriesRequest_FieldPathSelector) String() string {
	switch s {
	case BatchGetPhantomTimeSeriesRequest_FieldPathSelectorNames:
		return "names"
	case BatchGetPhantomTimeSeriesRequest_FieldPathSelectorFieldMask:
		return "field_mask"
	case BatchGetPhantomTimeSeriesRequest_FieldPathSelectorView:
		return "view"
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetPhantomTimeSeriesRequest: %d", s))
	}
}

func BuildBatchGetPhantomTimeSeriesRequest_FieldPath(fp gotenobject.RawFieldPath) (BatchGetPhantomTimeSeriesRequest_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object BatchGetPhantomTimeSeriesRequest")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "names":
			return &BatchGetPhantomTimeSeriesRequest_FieldTerminalPath{selector: BatchGetPhantomTimeSeriesRequest_FieldPathSelectorNames}, nil
		case "field_mask", "fieldMask", "field-mask":
			return &BatchGetPhantomTimeSeriesRequest_FieldTerminalPath{selector: BatchGetPhantomTimeSeriesRequest_FieldPathSelectorFieldMask}, nil
		case "view":
			return &BatchGetPhantomTimeSeriesRequest_FieldTerminalPath{selector: BatchGetPhantomTimeSeriesRequest_FieldPathSelectorView}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object BatchGetPhantomTimeSeriesRequest", fp)
}

func ParseBatchGetPhantomTimeSeriesRequest_FieldPath(rawField string) (BatchGetPhantomTimeSeriesRequest_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildBatchGetPhantomTimeSeriesRequest_FieldPath(fp)
}

func MustParseBatchGetPhantomTimeSeriesRequest_FieldPath(rawField string) BatchGetPhantomTimeSeriesRequest_FieldPath {
	fp, err := ParseBatchGetPhantomTimeSeriesRequest_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type BatchGetPhantomTimeSeriesRequest_FieldTerminalPath struct {
	selector BatchGetPhantomTimeSeriesRequest_FieldPathSelector
}

var _ BatchGetPhantomTimeSeriesRequest_FieldPath = (*BatchGetPhantomTimeSeriesRequest_FieldTerminalPath)(nil)

func (fp *BatchGetPhantomTimeSeriesRequest_FieldTerminalPath) Selector() BatchGetPhantomTimeSeriesRequest_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

// GetDefault returns a default value of the field type
func (fp *BatchGetPhantomTimeSeriesRequest_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case BatchGetPhantomTimeSeriesRequest_FieldPathSelectorNames:
		return ([]*phantom_time_serie.Reference)(nil)
	case BatchGetPhantomTimeSeriesRequest_FieldPathSelectorFieldMask:
		return (*phantom_time_serie.PhantomTimeSerie_FieldMask)(nil)
	case BatchGetPhantomTimeSeriesRequest_FieldPathSelectorView:
		return view.View_UNSPECIFIED
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetPhantomTimeSeriesRequest: %d", fp.selector))
	}
}

func (fp *BatchGetPhantomTimeSeriesRequest_FieldTerminalPath) ClearValue(item *BatchGetPhantomTimeSeriesRequest) {
	if item != nil {
		switch fp.selector {
		case BatchGetPhantomTimeSeriesRequest_FieldPathSelectorNames:
			item.Names = nil
		case BatchGetPhantomTimeSeriesRequest_FieldPathSelectorFieldMask:
			item.FieldMask = nil
		case BatchGetPhantomTimeSeriesRequest_FieldPathSelectorView:
			item.View = view.View_UNSPECIFIED
		default:
			panic(fmt.Sprintf("Invalid selector for BatchGetPhantomTimeSeriesRequest: %d", fp.selector))
		}
	}
}

func (fp *BatchGetPhantomTimeSeriesRequest_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*BatchGetPhantomTimeSeriesRequest))
}

// IsLeaf - whether field path is holds simple value
func (fp *BatchGetPhantomTimeSeriesRequest_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == BatchGetPhantomTimeSeriesRequest_FieldPathSelectorNames ||
		fp.selector == BatchGetPhantomTimeSeriesRequest_FieldPathSelectorFieldMask ||
		fp.selector == BatchGetPhantomTimeSeriesRequest_FieldPathSelectorView
}

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

func (fp *BatchGetPhantomTimeSeriesRequest_FieldTerminalPath) WithIValue(value interface{}) BatchGetPhantomTimeSeriesRequest_FieldPathValue {
	switch fp.selector {
	case BatchGetPhantomTimeSeriesRequest_FieldPathSelectorNames:
		return &BatchGetPhantomTimeSeriesRequest_FieldTerminalPathValue{BatchGetPhantomTimeSeriesRequest_FieldTerminalPath: *fp, value: value.([]*phantom_time_serie.Reference)}
	case BatchGetPhantomTimeSeriesRequest_FieldPathSelectorFieldMask:
		return &BatchGetPhantomTimeSeriesRequest_FieldTerminalPathValue{BatchGetPhantomTimeSeriesRequest_FieldTerminalPath: *fp, value: value.(*phantom_time_serie.PhantomTimeSerie_FieldMask)}
	case BatchGetPhantomTimeSeriesRequest_FieldPathSelectorView:
		return &BatchGetPhantomTimeSeriesRequest_FieldTerminalPathValue{BatchGetPhantomTimeSeriesRequest_FieldTerminalPath: *fp, value: value.(view.View)}
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetPhantomTimeSeriesRequest: %d", fp.selector))
	}
}

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

func (fp *BatchGetPhantomTimeSeriesRequest_FieldTerminalPath) WithIArrayOfValues(values interface{}) BatchGetPhantomTimeSeriesRequest_FieldPathArrayOfValues {
	fpaov := &BatchGetPhantomTimeSeriesRequest_FieldTerminalPathArrayOfValues{BatchGetPhantomTimeSeriesRequest_FieldTerminalPath: *fp}
	switch fp.selector {
	case BatchGetPhantomTimeSeriesRequest_FieldPathSelectorNames:
		return &BatchGetPhantomTimeSeriesRequest_FieldTerminalPathArrayOfValues{BatchGetPhantomTimeSeriesRequest_FieldTerminalPath: *fp, values: values.([][]*phantom_time_serie.Reference)}
	case BatchGetPhantomTimeSeriesRequest_FieldPathSelectorFieldMask:
		return &BatchGetPhantomTimeSeriesRequest_FieldTerminalPathArrayOfValues{BatchGetPhantomTimeSeriesRequest_FieldTerminalPath: *fp, values: values.([]*phantom_time_serie.PhantomTimeSerie_FieldMask)}
	case BatchGetPhantomTimeSeriesRequest_FieldPathSelectorView:
		return &BatchGetPhantomTimeSeriesRequest_FieldTerminalPathArrayOfValues{BatchGetPhantomTimeSeriesRequest_FieldTerminalPath: *fp, values: values.([]view.View)}
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetPhantomTimeSeriesRequest: %d", fp.selector))
	}
	return fpaov
}

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

func (fp *BatchGetPhantomTimeSeriesRequest_FieldTerminalPath) WithIArrayItemValue(value interface{}) BatchGetPhantomTimeSeriesRequest_FieldPathArrayItemValue {
	switch fp.selector {
	case BatchGetPhantomTimeSeriesRequest_FieldPathSelectorNames:
		return &BatchGetPhantomTimeSeriesRequest_FieldTerminalPathArrayItemValue{BatchGetPhantomTimeSeriesRequest_FieldTerminalPath: *fp, value: value.(*phantom_time_serie.Reference)}
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetPhantomTimeSeriesRequest: %d", fp.selector))
	}
}

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

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

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

func MustParseBatchGetPhantomTimeSeriesRequest_FieldPathValue(pathStr, valueStr string) BatchGetPhantomTimeSeriesRequest_FieldPathValue {
	fpv, err := ParseBatchGetPhantomTimeSeriesRequest_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type BatchGetPhantomTimeSeriesRequest_FieldTerminalPathValue struct {
	BatchGetPhantomTimeSeriesRequest_FieldTerminalPath
	value interface{}
}

var _ BatchGetPhantomTimeSeriesRequest_FieldPathValue = (*BatchGetPhantomTimeSeriesRequest_FieldTerminalPathValue)(nil)

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

// SetTo stores value for selected field for object BatchGetPhantomTimeSeriesRequest
func (fpv *BatchGetPhantomTimeSeriesRequest_FieldTerminalPathValue) SetTo(target **BatchGetPhantomTimeSeriesRequest) {
	if *target == nil {
		*target = new(BatchGetPhantomTimeSeriesRequest)
	}
	switch fpv.selector {
	case BatchGetPhantomTimeSeriesRequest_FieldPathSelectorNames:
		(*target).Names = fpv.value.([]*phantom_time_serie.Reference)
	case BatchGetPhantomTimeSeriesRequest_FieldPathSelectorFieldMask:
		(*target).FieldMask = fpv.value.(*phantom_time_serie.PhantomTimeSerie_FieldMask)
	case BatchGetPhantomTimeSeriesRequest_FieldPathSelectorView:
		(*target).View = fpv.value.(view.View)
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetPhantomTimeSeriesRequest: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'BatchGetPhantomTimeSeriesRequest_FieldTerminalPathValue' with the value under path in 'BatchGetPhantomTimeSeriesRequest'.
func (fpv *BatchGetPhantomTimeSeriesRequest_FieldTerminalPathValue) CompareWith(source *BatchGetPhantomTimeSeriesRequest) (int, bool) {
	switch fpv.selector {
	case BatchGetPhantomTimeSeriesRequest_FieldPathSelectorNames:
		return 0, false
	case BatchGetPhantomTimeSeriesRequest_FieldPathSelectorFieldMask:
		return 0, false
	case BatchGetPhantomTimeSeriesRequest_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 BatchGetPhantomTimeSeriesRequest: %d", fpv.selector))
	}
}

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

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

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

func MustParseBatchGetPhantomTimeSeriesRequest_FieldPathArrayItemValue(pathStr, valueStr string) BatchGetPhantomTimeSeriesRequest_FieldPathArrayItemValue {
	fpaiv, err := ParseBatchGetPhantomTimeSeriesRequest_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type BatchGetPhantomTimeSeriesRequest_FieldTerminalPathArrayItemValue struct {
	BatchGetPhantomTimeSeriesRequest_FieldTerminalPath
	value interface{}
}

var _ BatchGetPhantomTimeSeriesRequest_FieldPathArrayItemValue = (*BatchGetPhantomTimeSeriesRequest_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *BatchGetPhantomTimeSeriesRequest_FieldTerminalPathArrayItemValue) GetSingle(source *BatchGetPhantomTimeSeriesRequest) (interface{}, bool) {
	return nil, false
}

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

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

// BatchGetPhantomTimeSeriesRequest_FieldPathArrayOfValues allows storing slice of values for BatchGetPhantomTimeSeriesRequest fields according to their type
type BatchGetPhantomTimeSeriesRequest_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	BatchGetPhantomTimeSeriesRequest_FieldPath
}

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

func MustParseBatchGetPhantomTimeSeriesRequest_FieldPathArrayOfValues(pathStr, valuesStr string) BatchGetPhantomTimeSeriesRequest_FieldPathArrayOfValues {
	fpaov, err := ParseBatchGetPhantomTimeSeriesRequest_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type BatchGetPhantomTimeSeriesRequest_FieldTerminalPathArrayOfValues struct {
	BatchGetPhantomTimeSeriesRequest_FieldTerminalPath
	values interface{}
}

var _ BatchGetPhantomTimeSeriesRequest_FieldPathArrayOfValues = (*BatchGetPhantomTimeSeriesRequest_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *BatchGetPhantomTimeSeriesRequest_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case BatchGetPhantomTimeSeriesRequest_FieldPathSelectorNames:
		for _, v := range fpaov.values.([][]*phantom_time_serie.Reference) {
			values = append(values, v)
		}
	case BatchGetPhantomTimeSeriesRequest_FieldPathSelectorFieldMask:
		for _, v := range fpaov.values.([]*phantom_time_serie.PhantomTimeSerie_FieldMask) {
			values = append(values, v)
		}
	case BatchGetPhantomTimeSeriesRequest_FieldPathSelectorView:
		for _, v := range fpaov.values.([]view.View) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *BatchGetPhantomTimeSeriesRequest_FieldTerminalPathArrayOfValues) AsNamesArrayOfValues() ([][]*phantom_time_serie.Reference, bool) {
	res, ok := fpaov.values.([][]*phantom_time_serie.Reference)
	return res, ok
}
func (fpaov *BatchGetPhantomTimeSeriesRequest_FieldTerminalPathArrayOfValues) AsFieldMaskArrayOfValues() ([]*phantom_time_serie.PhantomTimeSerie_FieldMask, bool) {
	res, ok := fpaov.values.([]*phantom_time_serie.PhantomTimeSerie_FieldMask)
	return res, ok
}
func (fpaov *BatchGetPhantomTimeSeriesRequest_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 BatchGetPhantomTimeSeriesResponse_FieldPath interface {
	gotenobject.FieldPath
	Selector() BatchGetPhantomTimeSeriesResponse_FieldPathSelector
	Get(source *BatchGetPhantomTimeSeriesResponse) []interface{}
	GetSingle(source *BatchGetPhantomTimeSeriesResponse) (interface{}, bool)
	ClearValue(item *BatchGetPhantomTimeSeriesResponse)

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

type BatchGetPhantomTimeSeriesResponse_FieldPathSelector int32

const (
	BatchGetPhantomTimeSeriesResponse_FieldPathSelectorPhantomTimeSeries BatchGetPhantomTimeSeriesResponse_FieldPathSelector = 0
	BatchGetPhantomTimeSeriesResponse_FieldPathSelectorMissing           BatchGetPhantomTimeSeriesResponse_FieldPathSelector = 1
)

func (s BatchGetPhantomTimeSeriesResponse_FieldPathSelector) String() string {
	switch s {
	case BatchGetPhantomTimeSeriesResponse_FieldPathSelectorPhantomTimeSeries:
		return "phantom_time_series"
	case BatchGetPhantomTimeSeriesResponse_FieldPathSelectorMissing:
		return "missing"
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetPhantomTimeSeriesResponse: %d", s))
	}
}

func BuildBatchGetPhantomTimeSeriesResponse_FieldPath(fp gotenobject.RawFieldPath) (BatchGetPhantomTimeSeriesResponse_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object BatchGetPhantomTimeSeriesResponse")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "phantom_time_series", "phantomTimeSeries", "phantom-time-series":
			return &BatchGetPhantomTimeSeriesResponse_FieldTerminalPath{selector: BatchGetPhantomTimeSeriesResponse_FieldPathSelectorPhantomTimeSeries}, nil
		case "missing":
			return &BatchGetPhantomTimeSeriesResponse_FieldTerminalPath{selector: BatchGetPhantomTimeSeriesResponse_FieldPathSelectorMissing}, nil
		}
	} else {
		switch fp[0] {
		case "phantom_time_series", "phantomTimeSeries", "phantom-time-series":
			if subpath, err := phantom_time_serie.BuildPhantomTimeSerie_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &BatchGetPhantomTimeSeriesResponse_FieldSubPath{selector: BatchGetPhantomTimeSeriesResponse_FieldPathSelectorPhantomTimeSeries, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object BatchGetPhantomTimeSeriesResponse", fp)
}

func ParseBatchGetPhantomTimeSeriesResponse_FieldPath(rawField string) (BatchGetPhantomTimeSeriesResponse_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildBatchGetPhantomTimeSeriesResponse_FieldPath(fp)
}

func MustParseBatchGetPhantomTimeSeriesResponse_FieldPath(rawField string) BatchGetPhantomTimeSeriesResponse_FieldPath {
	fp, err := ParseBatchGetPhantomTimeSeriesResponse_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type BatchGetPhantomTimeSeriesResponse_FieldTerminalPath struct {
	selector BatchGetPhantomTimeSeriesResponse_FieldPathSelector
}

var _ BatchGetPhantomTimeSeriesResponse_FieldPath = (*BatchGetPhantomTimeSeriesResponse_FieldTerminalPath)(nil)

func (fp *BatchGetPhantomTimeSeriesResponse_FieldTerminalPath) Selector() BatchGetPhantomTimeSeriesResponse_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

// GetDefault returns a default value of the field type
func (fp *BatchGetPhantomTimeSeriesResponse_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case BatchGetPhantomTimeSeriesResponse_FieldPathSelectorPhantomTimeSeries:
		return ([]*phantom_time_serie.PhantomTimeSerie)(nil)
	case BatchGetPhantomTimeSeriesResponse_FieldPathSelectorMissing:
		return ([]*phantom_time_serie.Reference)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetPhantomTimeSeriesResponse: %d", fp.selector))
	}
}

func (fp *BatchGetPhantomTimeSeriesResponse_FieldTerminalPath) ClearValue(item *BatchGetPhantomTimeSeriesResponse) {
	if item != nil {
		switch fp.selector {
		case BatchGetPhantomTimeSeriesResponse_FieldPathSelectorPhantomTimeSeries:
			item.PhantomTimeSeries = nil
		case BatchGetPhantomTimeSeriesResponse_FieldPathSelectorMissing:
			item.Missing = nil
		default:
			panic(fmt.Sprintf("Invalid selector for BatchGetPhantomTimeSeriesResponse: %d", fp.selector))
		}
	}
}

func (fp *BatchGetPhantomTimeSeriesResponse_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*BatchGetPhantomTimeSeriesResponse))
}

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

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

func (fp *BatchGetPhantomTimeSeriesResponse_FieldTerminalPath) WithIValue(value interface{}) BatchGetPhantomTimeSeriesResponse_FieldPathValue {
	switch fp.selector {
	case BatchGetPhantomTimeSeriesResponse_FieldPathSelectorPhantomTimeSeries:
		return &BatchGetPhantomTimeSeriesResponse_FieldTerminalPathValue{BatchGetPhantomTimeSeriesResponse_FieldTerminalPath: *fp, value: value.([]*phantom_time_serie.PhantomTimeSerie)}
	case BatchGetPhantomTimeSeriesResponse_FieldPathSelectorMissing:
		return &BatchGetPhantomTimeSeriesResponse_FieldTerminalPathValue{BatchGetPhantomTimeSeriesResponse_FieldTerminalPath: *fp, value: value.([]*phantom_time_serie.Reference)}
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetPhantomTimeSeriesResponse: %d", fp.selector))
	}
}

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

func (fp *BatchGetPhantomTimeSeriesResponse_FieldTerminalPath) WithIArrayOfValues(values interface{}) BatchGetPhantomTimeSeriesResponse_FieldPathArrayOfValues {
	fpaov := &BatchGetPhantomTimeSeriesResponse_FieldTerminalPathArrayOfValues{BatchGetPhantomTimeSeriesResponse_FieldTerminalPath: *fp}
	switch fp.selector {
	case BatchGetPhantomTimeSeriesResponse_FieldPathSelectorPhantomTimeSeries:
		return &BatchGetPhantomTimeSeriesResponse_FieldTerminalPathArrayOfValues{BatchGetPhantomTimeSeriesResponse_FieldTerminalPath: *fp, values: values.([][]*phantom_time_serie.PhantomTimeSerie)}
	case BatchGetPhantomTimeSeriesResponse_FieldPathSelectorMissing:
		return &BatchGetPhantomTimeSeriesResponse_FieldTerminalPathArrayOfValues{BatchGetPhantomTimeSeriesResponse_FieldTerminalPath: *fp, values: values.([][]*phantom_time_serie.Reference)}
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetPhantomTimeSeriesResponse: %d", fp.selector))
	}
	return fpaov
}

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

func (fp *BatchGetPhantomTimeSeriesResponse_FieldTerminalPath) WithIArrayItemValue(value interface{}) BatchGetPhantomTimeSeriesResponse_FieldPathArrayItemValue {
	switch fp.selector {
	case BatchGetPhantomTimeSeriesResponse_FieldPathSelectorPhantomTimeSeries:
		return &BatchGetPhantomTimeSeriesResponse_FieldTerminalPathArrayItemValue{BatchGetPhantomTimeSeriesResponse_FieldTerminalPath: *fp, value: value.(*phantom_time_serie.PhantomTimeSerie)}
	case BatchGetPhantomTimeSeriesResponse_FieldPathSelectorMissing:
		return &BatchGetPhantomTimeSeriesResponse_FieldTerminalPathArrayItemValue{BatchGetPhantomTimeSeriesResponse_FieldTerminalPath: *fp, value: value.(*phantom_time_serie.Reference)}
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetPhantomTimeSeriesResponse: %d", fp.selector))
	}
}

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

type BatchGetPhantomTimeSeriesResponse_FieldSubPath struct {
	selector BatchGetPhantomTimeSeriesResponse_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ BatchGetPhantomTimeSeriesResponse_FieldPath = (*BatchGetPhantomTimeSeriesResponse_FieldSubPath)(nil)

func (fps *BatchGetPhantomTimeSeriesResponse_FieldSubPath) Selector() BatchGetPhantomTimeSeriesResponse_FieldPathSelector {
	return fps.selector
}
func (fps *BatchGetPhantomTimeSeriesResponse_FieldSubPath) AsPhantomTimeSeriesSubPath() (phantom_time_serie.PhantomTimeSerie_FieldPath, bool) {
	res, ok := fps.subPath.(phantom_time_serie.PhantomTimeSerie_FieldPath)
	return res, ok
}

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

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

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

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

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

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

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

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

func (fps *BatchGetPhantomTimeSeriesResponse_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*BatchGetPhantomTimeSeriesResponse))
}

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

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

func (fps *BatchGetPhantomTimeSeriesResponse_FieldSubPath) WithIValue(value interface{}) BatchGetPhantomTimeSeriesResponse_FieldPathValue {
	return &BatchGetPhantomTimeSeriesResponse_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *BatchGetPhantomTimeSeriesResponse_FieldSubPath) WithIArrayOfValues(values interface{}) BatchGetPhantomTimeSeriesResponse_FieldPathArrayOfValues {
	return &BatchGetPhantomTimeSeriesResponse_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *BatchGetPhantomTimeSeriesResponse_FieldSubPath) WithIArrayItemValue(value interface{}) BatchGetPhantomTimeSeriesResponse_FieldPathArrayItemValue {
	return &BatchGetPhantomTimeSeriesResponse_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

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

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

func MustParseBatchGetPhantomTimeSeriesResponse_FieldPathValue(pathStr, valueStr string) BatchGetPhantomTimeSeriesResponse_FieldPathValue {
	fpv, err := ParseBatchGetPhantomTimeSeriesResponse_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type BatchGetPhantomTimeSeriesResponse_FieldTerminalPathValue struct {
	BatchGetPhantomTimeSeriesResponse_FieldTerminalPath
	value interface{}
}

var _ BatchGetPhantomTimeSeriesResponse_FieldPathValue = (*BatchGetPhantomTimeSeriesResponse_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'BatchGetPhantomTimeSeriesResponse' as interface{}
func (fpv *BatchGetPhantomTimeSeriesResponse_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *BatchGetPhantomTimeSeriesResponse_FieldTerminalPathValue) AsPhantomTimeSeriesValue() ([]*phantom_time_serie.PhantomTimeSerie, bool) {
	res, ok := fpv.value.([]*phantom_time_serie.PhantomTimeSerie)
	return res, ok
}
func (fpv *BatchGetPhantomTimeSeriesResponse_FieldTerminalPathValue) AsMissingValue() ([]*phantom_time_serie.Reference, bool) {
	res, ok := fpv.value.([]*phantom_time_serie.Reference)
	return res, ok
}

// SetTo stores value for selected field for object BatchGetPhantomTimeSeriesResponse
func (fpv *BatchGetPhantomTimeSeriesResponse_FieldTerminalPathValue) SetTo(target **BatchGetPhantomTimeSeriesResponse) {
	if *target == nil {
		*target = new(BatchGetPhantomTimeSeriesResponse)
	}
	switch fpv.selector {
	case BatchGetPhantomTimeSeriesResponse_FieldPathSelectorPhantomTimeSeries:
		(*target).PhantomTimeSeries = fpv.value.([]*phantom_time_serie.PhantomTimeSerie)
	case BatchGetPhantomTimeSeriesResponse_FieldPathSelectorMissing:
		(*target).Missing = fpv.value.([]*phantom_time_serie.Reference)
	default:
		panic(fmt.Sprintf("Invalid selector for BatchGetPhantomTimeSeriesResponse: %d", fpv.selector))
	}
}

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

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

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

type BatchGetPhantomTimeSeriesResponse_FieldSubPathValue struct {
	BatchGetPhantomTimeSeriesResponse_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ BatchGetPhantomTimeSeriesResponse_FieldPathValue = (*BatchGetPhantomTimeSeriesResponse_FieldSubPathValue)(nil)

func (fpvs *BatchGetPhantomTimeSeriesResponse_FieldSubPathValue) AsPhantomTimeSeriesPathValue() (phantom_time_serie.PhantomTimeSerie_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(phantom_time_serie.PhantomTimeSerie_FieldPathValue)
	return res, ok
}

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

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

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

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

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

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

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

func MustParseBatchGetPhantomTimeSeriesResponse_FieldPathArrayItemValue(pathStr, valueStr string) BatchGetPhantomTimeSeriesResponse_FieldPathArrayItemValue {
	fpaiv, err := ParseBatchGetPhantomTimeSeriesResponse_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type BatchGetPhantomTimeSeriesResponse_FieldTerminalPathArrayItemValue struct {
	BatchGetPhantomTimeSeriesResponse_FieldTerminalPath
	value interface{}
}

var _ BatchGetPhantomTimeSeriesResponse_FieldPathArrayItemValue = (*BatchGetPhantomTimeSeriesResponse_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object BatchGetPhantomTimeSeriesResponse as interface{}
func (fpaiv *BatchGetPhantomTimeSeriesResponse_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}
func (fpaiv *BatchGetPhantomTimeSeriesResponse_FieldTerminalPathArrayItemValue) AsPhantomTimeSeriesItemValue() (*phantom_time_serie.PhantomTimeSerie, bool) {
	res, ok := fpaiv.value.(*phantom_time_serie.PhantomTimeSerie)
	return res, ok
}
func (fpaiv *BatchGetPhantomTimeSeriesResponse_FieldTerminalPathArrayItemValue) AsMissingItemValue() (*phantom_time_serie.Reference, bool) {
	res, ok := fpaiv.value.(*phantom_time_serie.Reference)
	return res, ok
}

func (fpaiv *BatchGetPhantomTimeSeriesResponse_FieldTerminalPathArrayItemValue) GetSingle(source *BatchGetPhantomTimeSeriesResponse) (interface{}, bool) {
	return nil, false
}

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

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

// GetRawValue returns stored array item value
func (fpaivs *BatchGetPhantomTimeSeriesResponse_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *BatchGetPhantomTimeSeriesResponse_FieldSubPathArrayItemValue) AsPhantomTimeSeriesPathItemValue() (phantom_time_serie.PhantomTimeSerie_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(phantom_time_serie.PhantomTimeSerie_FieldPathArrayItemValue)
	return res, ok
}

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

// BatchGetPhantomTimeSeriesResponse_FieldPathArrayOfValues allows storing slice of values for BatchGetPhantomTimeSeriesResponse fields according to their type
type BatchGetPhantomTimeSeriesResponse_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	BatchGetPhantomTimeSeriesResponse_FieldPath
}

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

func MustParseBatchGetPhantomTimeSeriesResponse_FieldPathArrayOfValues(pathStr, valuesStr string) BatchGetPhantomTimeSeriesResponse_FieldPathArrayOfValues {
	fpaov, err := ParseBatchGetPhantomTimeSeriesResponse_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type BatchGetPhantomTimeSeriesResponse_FieldTerminalPathArrayOfValues struct {
	BatchGetPhantomTimeSeriesResponse_FieldTerminalPath
	values interface{}
}

var _ BatchGetPhantomTimeSeriesResponse_FieldPathArrayOfValues = (*BatchGetPhantomTimeSeriesResponse_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *BatchGetPhantomTimeSeriesResponse_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case BatchGetPhantomTimeSeriesResponse_FieldPathSelectorPhantomTimeSeries:
		for _, v := range fpaov.values.([][]*phantom_time_serie.PhantomTimeSerie) {
			values = append(values, v)
		}
	case BatchGetPhantomTimeSeriesResponse_FieldPathSelectorMissing:
		for _, v := range fpaov.values.([][]*phantom_time_serie.Reference) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *BatchGetPhantomTimeSeriesResponse_FieldTerminalPathArrayOfValues) AsPhantomTimeSeriesArrayOfValues() ([][]*phantom_time_serie.PhantomTimeSerie, bool) {
	res, ok := fpaov.values.([][]*phantom_time_serie.PhantomTimeSerie)
	return res, ok
}
func (fpaov *BatchGetPhantomTimeSeriesResponse_FieldTerminalPathArrayOfValues) AsMissingArrayOfValues() ([][]*phantom_time_serie.Reference, bool) {
	res, ok := fpaov.values.([][]*phantom_time_serie.Reference)
	return res, ok
}

type BatchGetPhantomTimeSeriesResponse_FieldSubPathArrayOfValues struct {
	BatchGetPhantomTimeSeriesResponse_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ BatchGetPhantomTimeSeriesResponse_FieldPathArrayOfValues = (*BatchGetPhantomTimeSeriesResponse_FieldSubPathArrayOfValues)(nil)

func (fpsaov *BatchGetPhantomTimeSeriesResponse_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *BatchGetPhantomTimeSeriesResponse_FieldSubPathArrayOfValues) AsPhantomTimeSeriesPathArrayOfValues() (phantom_time_serie.PhantomTimeSerie_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(phantom_time_serie.PhantomTimeSerie_FieldPathArrayOfValues)
	return res, ok
}

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

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

type ListPhantomTimeSeriesRequest_FieldPathSelector int32

const (
	ListPhantomTimeSeriesRequest_FieldPathSelectorParent            ListPhantomTimeSeriesRequest_FieldPathSelector = 0
	ListPhantomTimeSeriesRequest_FieldPathSelectorPageSize          ListPhantomTimeSeriesRequest_FieldPathSelector = 1
	ListPhantomTimeSeriesRequest_FieldPathSelectorPageToken         ListPhantomTimeSeriesRequest_FieldPathSelector = 2
	ListPhantomTimeSeriesRequest_FieldPathSelectorOrderBy           ListPhantomTimeSeriesRequest_FieldPathSelector = 3
	ListPhantomTimeSeriesRequest_FieldPathSelectorFilter            ListPhantomTimeSeriesRequest_FieldPathSelector = 4
	ListPhantomTimeSeriesRequest_FieldPathSelectorFieldMask         ListPhantomTimeSeriesRequest_FieldPathSelector = 5
	ListPhantomTimeSeriesRequest_FieldPathSelectorView              ListPhantomTimeSeriesRequest_FieldPathSelector = 6
	ListPhantomTimeSeriesRequest_FieldPathSelectorIncludePagingInfo ListPhantomTimeSeriesRequest_FieldPathSelector = 7
)

func (s ListPhantomTimeSeriesRequest_FieldPathSelector) String() string {
	switch s {
	case ListPhantomTimeSeriesRequest_FieldPathSelectorParent:
		return "parent"
	case ListPhantomTimeSeriesRequest_FieldPathSelectorPageSize:
		return "page_size"
	case ListPhantomTimeSeriesRequest_FieldPathSelectorPageToken:
		return "page_token"
	case ListPhantomTimeSeriesRequest_FieldPathSelectorOrderBy:
		return "order_by"
	case ListPhantomTimeSeriesRequest_FieldPathSelectorFilter:
		return "filter"
	case ListPhantomTimeSeriesRequest_FieldPathSelectorFieldMask:
		return "field_mask"
	case ListPhantomTimeSeriesRequest_FieldPathSelectorView:
		return "view"
	case ListPhantomTimeSeriesRequest_FieldPathSelectorIncludePagingInfo:
		return "include_paging_info"
	default:
		panic(fmt.Sprintf("Invalid selector for ListPhantomTimeSeriesRequest: %d", s))
	}
}

func BuildListPhantomTimeSeriesRequest_FieldPath(fp gotenobject.RawFieldPath) (ListPhantomTimeSeriesRequest_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object ListPhantomTimeSeriesRequest")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "parent":
			return &ListPhantomTimeSeriesRequest_FieldTerminalPath{selector: ListPhantomTimeSeriesRequest_FieldPathSelectorParent}, nil
		case "page_size", "pageSize", "page-size":
			return &ListPhantomTimeSeriesRequest_FieldTerminalPath{selector: ListPhantomTimeSeriesRequest_FieldPathSelectorPageSize}, nil
		case "page_token", "pageToken", "page-token":
			return &ListPhantomTimeSeriesRequest_FieldTerminalPath{selector: ListPhantomTimeSeriesRequest_FieldPathSelectorPageToken}, nil
		case "order_by", "orderBy", "order-by":
			return &ListPhantomTimeSeriesRequest_FieldTerminalPath{selector: ListPhantomTimeSeriesRequest_FieldPathSelectorOrderBy}, nil
		case "filter":
			return &ListPhantomTimeSeriesRequest_FieldTerminalPath{selector: ListPhantomTimeSeriesRequest_FieldPathSelectorFilter}, nil
		case "field_mask", "fieldMask", "field-mask":
			return &ListPhantomTimeSeriesRequest_FieldTerminalPath{selector: ListPhantomTimeSeriesRequest_FieldPathSelectorFieldMask}, nil
		case "view":
			return &ListPhantomTimeSeriesRequest_FieldTerminalPath{selector: ListPhantomTimeSeriesRequest_FieldPathSelectorView}, nil
		case "include_paging_info", "includePagingInfo", "include-paging-info":
			return &ListPhantomTimeSeriesRequest_FieldTerminalPath{selector: ListPhantomTimeSeriesRequest_FieldPathSelectorIncludePagingInfo}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object ListPhantomTimeSeriesRequest", fp)
}

func ParseListPhantomTimeSeriesRequest_FieldPath(rawField string) (ListPhantomTimeSeriesRequest_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildListPhantomTimeSeriesRequest_FieldPath(fp)
}

func MustParseListPhantomTimeSeriesRequest_FieldPath(rawField string) ListPhantomTimeSeriesRequest_FieldPath {
	fp, err := ParseListPhantomTimeSeriesRequest_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type ListPhantomTimeSeriesRequest_FieldTerminalPath struct {
	selector ListPhantomTimeSeriesRequest_FieldPathSelector
}

var _ ListPhantomTimeSeriesRequest_FieldPath = (*ListPhantomTimeSeriesRequest_FieldTerminalPath)(nil)

func (fp *ListPhantomTimeSeriesRequest_FieldTerminalPath) Selector() ListPhantomTimeSeriesRequest_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source ListPhantomTimeSeriesRequest
func (fp *ListPhantomTimeSeriesRequest_FieldTerminalPath) Get(source *ListPhantomTimeSeriesRequest) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case ListPhantomTimeSeriesRequest_FieldPathSelectorParent:
			if source.Parent != nil {
				values = append(values, source.Parent)
			}
		case ListPhantomTimeSeriesRequest_FieldPathSelectorPageSize:
			values = append(values, source.PageSize)
		case ListPhantomTimeSeriesRequest_FieldPathSelectorPageToken:
			if source.PageToken != nil {
				values = append(values, source.PageToken)
			}
		case ListPhantomTimeSeriesRequest_FieldPathSelectorOrderBy:
			if source.OrderBy != nil {
				values = append(values, source.OrderBy)
			}
		case ListPhantomTimeSeriesRequest_FieldPathSelectorFilter:
			if source.Filter != nil {
				values = append(values, source.Filter)
			}
		case ListPhantomTimeSeriesRequest_FieldPathSelectorFieldMask:
			if source.FieldMask != nil {
				values = append(values, source.FieldMask)
			}
		case ListPhantomTimeSeriesRequest_FieldPathSelectorView:
			values = append(values, source.View)
		case ListPhantomTimeSeriesRequest_FieldPathSelectorIncludePagingInfo:
			values = append(values, source.IncludePagingInfo)
		default:
			panic(fmt.Sprintf("Invalid selector for ListPhantomTimeSeriesRequest: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source ListPhantomTimeSeriesRequest
func (fp *ListPhantomTimeSeriesRequest_FieldTerminalPath) GetSingle(source *ListPhantomTimeSeriesRequest) (interface{}, bool) {
	switch fp.selector {
	case ListPhantomTimeSeriesRequest_FieldPathSelectorParent:
		res := source.GetParent()
		return res, res != nil
	case ListPhantomTimeSeriesRequest_FieldPathSelectorPageSize:
		return source.GetPageSize(), source != nil
	case ListPhantomTimeSeriesRequest_FieldPathSelectorPageToken:
		res := source.GetPageToken()
		return res, res != nil
	case ListPhantomTimeSeriesRequest_FieldPathSelectorOrderBy:
		res := source.GetOrderBy()
		return res, res != nil
	case ListPhantomTimeSeriesRequest_FieldPathSelectorFilter:
		res := source.GetFilter()
		return res, res != nil
	case ListPhantomTimeSeriesRequest_FieldPathSelectorFieldMask:
		res := source.GetFieldMask()
		return res, res != nil
	case ListPhantomTimeSeriesRequest_FieldPathSelectorView:
		return source.GetView(), source != nil
	case ListPhantomTimeSeriesRequest_FieldPathSelectorIncludePagingInfo:
		return source.GetIncludePagingInfo(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for ListPhantomTimeSeriesRequest: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *ListPhantomTimeSeriesRequest_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case ListPhantomTimeSeriesRequest_FieldPathSelectorParent:
		return (*phantom_time_serie.ParentName)(nil)
	case ListPhantomTimeSeriesRequest_FieldPathSelectorPageSize:
		return int32(0)
	case ListPhantomTimeSeriesRequest_FieldPathSelectorPageToken:
		return (*phantom_time_serie.PagerCursor)(nil)
	case ListPhantomTimeSeriesRequest_FieldPathSelectorOrderBy:
		return (*phantom_time_serie.OrderBy)(nil)
	case ListPhantomTimeSeriesRequest_FieldPathSelectorFilter:
		return (*phantom_time_serie.Filter)(nil)
	case ListPhantomTimeSeriesRequest_FieldPathSelectorFieldMask:
		return (*phantom_time_serie.PhantomTimeSerie_FieldMask)(nil)
	case ListPhantomTimeSeriesRequest_FieldPathSelectorView:
		return view.View_UNSPECIFIED
	case ListPhantomTimeSeriesRequest_FieldPathSelectorIncludePagingInfo:
		return false
	default:
		panic(fmt.Sprintf("Invalid selector for ListPhantomTimeSeriesRequest: %d", fp.selector))
	}
}

func (fp *ListPhantomTimeSeriesRequest_FieldTerminalPath) ClearValue(item *ListPhantomTimeSeriesRequest) {
	if item != nil {
		switch fp.selector {
		case ListPhantomTimeSeriesRequest_FieldPathSelectorParent:
			item.Parent = nil
		case ListPhantomTimeSeriesRequest_FieldPathSelectorPageSize:
			item.PageSize = int32(0)
		case ListPhantomTimeSeriesRequest_FieldPathSelectorPageToken:
			item.PageToken = nil
		case ListPhantomTimeSeriesRequest_FieldPathSelectorOrderBy:
			item.OrderBy = nil
		case ListPhantomTimeSeriesRequest_FieldPathSelectorFilter:
			item.Filter = nil
		case ListPhantomTimeSeriesRequest_FieldPathSelectorFieldMask:
			item.FieldMask = nil
		case ListPhantomTimeSeriesRequest_FieldPathSelectorView:
			item.View = view.View_UNSPECIFIED
		case ListPhantomTimeSeriesRequest_FieldPathSelectorIncludePagingInfo:
			item.IncludePagingInfo = false
		default:
			panic(fmt.Sprintf("Invalid selector for ListPhantomTimeSeriesRequest: %d", fp.selector))
		}
	}
}

func (fp *ListPhantomTimeSeriesRequest_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*ListPhantomTimeSeriesRequest))
}

// IsLeaf - whether field path is holds simple value
func (fp *ListPhantomTimeSeriesRequest_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == ListPhantomTimeSeriesRequest_FieldPathSelectorParent ||
		fp.selector == ListPhantomTimeSeriesRequest_FieldPathSelectorPageSize ||
		fp.selector == ListPhantomTimeSeriesRequest_FieldPathSelectorPageToken ||
		fp.selector == ListPhantomTimeSeriesRequest_FieldPathSelectorOrderBy ||
		fp.selector == ListPhantomTimeSeriesRequest_FieldPathSelectorFilter ||
		fp.selector == ListPhantomTimeSeriesRequest_FieldPathSelectorFieldMask ||
		fp.selector == ListPhantomTimeSeriesRequest_FieldPathSelectorView ||
		fp.selector == ListPhantomTimeSeriesRequest_FieldPathSelectorIncludePagingInfo
}

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

func (fp *ListPhantomTimeSeriesRequest_FieldTerminalPath) WithIValue(value interface{}) ListPhantomTimeSeriesRequest_FieldPathValue {
	switch fp.selector {
	case ListPhantomTimeSeriesRequest_FieldPathSelectorParent:
		return &ListPhantomTimeSeriesRequest_FieldTerminalPathValue{ListPhantomTimeSeriesRequest_FieldTerminalPath: *fp, value: value.(*phantom_time_serie.ParentName)}
	case ListPhantomTimeSeriesRequest_FieldPathSelectorPageSize:
		return &ListPhantomTimeSeriesRequest_FieldTerminalPathValue{ListPhantomTimeSeriesRequest_FieldTerminalPath: *fp, value: value.(int32)}
	case ListPhantomTimeSeriesRequest_FieldPathSelectorPageToken:
		return &ListPhantomTimeSeriesRequest_FieldTerminalPathValue{ListPhantomTimeSeriesRequest_FieldTerminalPath: *fp, value: value.(*phantom_time_serie.PagerCursor)}
	case ListPhantomTimeSeriesRequest_FieldPathSelectorOrderBy:
		return &ListPhantomTimeSeriesRequest_FieldTerminalPathValue{ListPhantomTimeSeriesRequest_FieldTerminalPath: *fp, value: value.(*phantom_time_serie.OrderBy)}
	case ListPhantomTimeSeriesRequest_FieldPathSelectorFilter:
		return &ListPhantomTimeSeriesRequest_FieldTerminalPathValue{ListPhantomTimeSeriesRequest_FieldTerminalPath: *fp, value: value.(*phantom_time_serie.Filter)}
	case ListPhantomTimeSeriesRequest_FieldPathSelectorFieldMask:
		return &ListPhantomTimeSeriesRequest_FieldTerminalPathValue{ListPhantomTimeSeriesRequest_FieldTerminalPath: *fp, value: value.(*phantom_time_serie.PhantomTimeSerie_FieldMask)}
	case ListPhantomTimeSeriesRequest_FieldPathSelectorView:
		return &ListPhantomTimeSeriesRequest_FieldTerminalPathValue{ListPhantomTimeSeriesRequest_FieldTerminalPath: *fp, value: value.(view.View)}
	case ListPhantomTimeSeriesRequest_FieldPathSelectorIncludePagingInfo:
		return &ListPhantomTimeSeriesRequest_FieldTerminalPathValue{ListPhantomTimeSeriesRequest_FieldTerminalPath: *fp, value: value.(bool)}
	default:
		panic(fmt.Sprintf("Invalid selector for ListPhantomTimeSeriesRequest: %d", fp.selector))
	}
}

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

func (fp *ListPhantomTimeSeriesRequest_FieldTerminalPath) WithIArrayOfValues(values interface{}) ListPhantomTimeSeriesRequest_FieldPathArrayOfValues {
	fpaov := &ListPhantomTimeSeriesRequest_FieldTerminalPathArrayOfValues{ListPhantomTimeSeriesRequest_FieldTerminalPath: *fp}
	switch fp.selector {
	case ListPhantomTimeSeriesRequest_FieldPathSelectorParent:
		return &ListPhantomTimeSeriesRequest_FieldTerminalPathArrayOfValues{ListPhantomTimeSeriesRequest_FieldTerminalPath: *fp, values: values.([]*phantom_time_serie.ParentName)}
	case ListPhantomTimeSeriesRequest_FieldPathSelectorPageSize:
		return &ListPhantomTimeSeriesRequest_FieldTerminalPathArrayOfValues{ListPhantomTimeSeriesRequest_FieldTerminalPath: *fp, values: values.([]int32)}
	case ListPhantomTimeSeriesRequest_FieldPathSelectorPageToken:
		return &ListPhantomTimeSeriesRequest_FieldTerminalPathArrayOfValues{ListPhantomTimeSeriesRequest_FieldTerminalPath: *fp, values: values.([]*phantom_time_serie.PagerCursor)}
	case ListPhantomTimeSeriesRequest_FieldPathSelectorOrderBy:
		return &ListPhantomTimeSeriesRequest_FieldTerminalPathArrayOfValues{ListPhantomTimeSeriesRequest_FieldTerminalPath: *fp, values: values.([]*phantom_time_serie.OrderBy)}
	case ListPhantomTimeSeriesRequest_FieldPathSelectorFilter:
		return &ListPhantomTimeSeriesRequest_FieldTerminalPathArrayOfValues{ListPhantomTimeSeriesRequest_FieldTerminalPath: *fp, values: values.([]*phantom_time_serie.Filter)}
	case ListPhantomTimeSeriesRequest_FieldPathSelectorFieldMask:
		return &ListPhantomTimeSeriesRequest_FieldTerminalPathArrayOfValues{ListPhantomTimeSeriesRequest_FieldTerminalPath: *fp, values: values.([]*phantom_time_serie.PhantomTimeSerie_FieldMask)}
	case ListPhantomTimeSeriesRequest_FieldPathSelectorView:
		return &ListPhantomTimeSeriesRequest_FieldTerminalPathArrayOfValues{ListPhantomTimeSeriesRequest_FieldTerminalPath: *fp, values: values.([]view.View)}
	case ListPhantomTimeSeriesRequest_FieldPathSelectorIncludePagingInfo:
		return &ListPhantomTimeSeriesRequest_FieldTerminalPathArrayOfValues{ListPhantomTimeSeriesRequest_FieldTerminalPath: *fp, values: values.([]bool)}
	default:
		panic(fmt.Sprintf("Invalid selector for ListPhantomTimeSeriesRequest: %d", fp.selector))
	}
	return fpaov
}

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

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

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

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

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

func MustParseListPhantomTimeSeriesRequest_FieldPathValue(pathStr, valueStr string) ListPhantomTimeSeriesRequest_FieldPathValue {
	fpv, err := ParseListPhantomTimeSeriesRequest_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type ListPhantomTimeSeriesRequest_FieldTerminalPathValue struct {
	ListPhantomTimeSeriesRequest_FieldTerminalPath
	value interface{}
}

var _ ListPhantomTimeSeriesRequest_FieldPathValue = (*ListPhantomTimeSeriesRequest_FieldTerminalPathValue)(nil)

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

// SetTo stores value for selected field for object ListPhantomTimeSeriesRequest
func (fpv *ListPhantomTimeSeriesRequest_FieldTerminalPathValue) SetTo(target **ListPhantomTimeSeriesRequest) {
	if *target == nil {
		*target = new(ListPhantomTimeSeriesRequest)
	}
	switch fpv.selector {
	case ListPhantomTimeSeriesRequest_FieldPathSelectorParent:
		(*target).Parent = fpv.value.(*phantom_time_serie.ParentName)
	case ListPhantomTimeSeriesRequest_FieldPathSelectorPageSize:
		(*target).PageSize = fpv.value.(int32)
	case ListPhantomTimeSeriesRequest_FieldPathSelectorPageToken:
		(*target).PageToken = fpv.value.(*phantom_time_serie.PagerCursor)
	case ListPhantomTimeSeriesRequest_FieldPathSelectorOrderBy:
		(*target).OrderBy = fpv.value.(*phantom_time_serie.OrderBy)
	case ListPhantomTimeSeriesRequest_FieldPathSelectorFilter:
		(*target).Filter = fpv.value.(*phantom_time_serie.Filter)
	case ListPhantomTimeSeriesRequest_FieldPathSelectorFieldMask:
		(*target).FieldMask = fpv.value.(*phantom_time_serie.PhantomTimeSerie_FieldMask)
	case ListPhantomTimeSeriesRequest_FieldPathSelectorView:
		(*target).View = fpv.value.(view.View)
	case ListPhantomTimeSeriesRequest_FieldPathSelectorIncludePagingInfo:
		(*target).IncludePagingInfo = fpv.value.(bool)
	default:
		panic(fmt.Sprintf("Invalid selector for ListPhantomTimeSeriesRequest: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'ListPhantomTimeSeriesRequest_FieldTerminalPathValue' with the value under path in 'ListPhantomTimeSeriesRequest'.
func (fpv *ListPhantomTimeSeriesRequest_FieldTerminalPathValue) CompareWith(source *ListPhantomTimeSeriesRequest) (int, bool) {
	switch fpv.selector {
	case ListPhantomTimeSeriesRequest_FieldPathSelectorParent:
		leftValue := fpv.value.(*phantom_time_serie.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 ListPhantomTimeSeriesRequest_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 ListPhantomTimeSeriesRequest_FieldPathSelectorPageToken:
		return 0, false
	case ListPhantomTimeSeriesRequest_FieldPathSelectorOrderBy:
		return 0, false
	case ListPhantomTimeSeriesRequest_FieldPathSelectorFilter:
		return 0, false
	case ListPhantomTimeSeriesRequest_FieldPathSelectorFieldMask:
		return 0, false
	case ListPhantomTimeSeriesRequest_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 ListPhantomTimeSeriesRequest_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 ListPhantomTimeSeriesRequest: %d", fpv.selector))
	}
}

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

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

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

func MustParseListPhantomTimeSeriesRequest_FieldPathArrayItemValue(pathStr, valueStr string) ListPhantomTimeSeriesRequest_FieldPathArrayItemValue {
	fpaiv, err := ParseListPhantomTimeSeriesRequest_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type ListPhantomTimeSeriesRequest_FieldTerminalPathArrayItemValue struct {
	ListPhantomTimeSeriesRequest_FieldTerminalPath
	value interface{}
}

var _ ListPhantomTimeSeriesRequest_FieldPathArrayItemValue = (*ListPhantomTimeSeriesRequest_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *ListPhantomTimeSeriesRequest_FieldTerminalPathArrayItemValue) GetSingle(source *ListPhantomTimeSeriesRequest) (interface{}, bool) {
	return nil, false
}

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

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

// ListPhantomTimeSeriesRequest_FieldPathArrayOfValues allows storing slice of values for ListPhantomTimeSeriesRequest fields according to their type
type ListPhantomTimeSeriesRequest_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	ListPhantomTimeSeriesRequest_FieldPath
}

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

func MustParseListPhantomTimeSeriesRequest_FieldPathArrayOfValues(pathStr, valuesStr string) ListPhantomTimeSeriesRequest_FieldPathArrayOfValues {
	fpaov, err := ParseListPhantomTimeSeriesRequest_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type ListPhantomTimeSeriesRequest_FieldTerminalPathArrayOfValues struct {
	ListPhantomTimeSeriesRequest_FieldTerminalPath
	values interface{}
}

var _ ListPhantomTimeSeriesRequest_FieldPathArrayOfValues = (*ListPhantomTimeSeriesRequest_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *ListPhantomTimeSeriesRequest_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case ListPhantomTimeSeriesRequest_FieldPathSelectorParent:
		for _, v := range fpaov.values.([]*phantom_time_serie.ParentName) {
			values = append(values, v)
		}
	case ListPhantomTimeSeriesRequest_FieldPathSelectorPageSize:
		for _, v := range fpaov.values.([]int32) {
			values = append(values, v)
		}
	case ListPhantomTimeSeriesRequest_FieldPathSelectorPageToken:
		for _, v := range fpaov.values.([]*phantom_time_serie.PagerCursor) {
			values = append(values, v)
		}
	case ListPhantomTimeSeriesRequest_FieldPathSelectorOrderBy:
		for _, v := range fpaov.values.([]*phantom_time_serie.OrderBy) {
			values = append(values, v)
		}
	case ListPhantomTimeSeriesRequest_FieldPathSelectorFilter:
		for _, v := range fpaov.values.([]*phantom_time_serie.Filter) {
			values = append(values, v)
		}
	case ListPhantomTimeSeriesRequest_FieldPathSelectorFieldMask:
		for _, v := range fpaov.values.([]*phantom_time_serie.PhantomTimeSerie_FieldMask) {
			values = append(values, v)
		}
	case ListPhantomTimeSeriesRequest_FieldPathSelectorView:
		for _, v := range fpaov.values.([]view.View) {
			values = append(values, v)
		}
	case ListPhantomTimeSeriesRequest_FieldPathSelectorIncludePagingInfo:
		for _, v := range fpaov.values.([]bool) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *ListPhantomTimeSeriesRequest_FieldTerminalPathArrayOfValues) AsParentArrayOfValues() ([]*phantom_time_serie.ParentName, bool) {
	res, ok := fpaov.values.([]*phantom_time_serie.ParentName)
	return res, ok
}
func (fpaov *ListPhantomTimeSeriesRequest_FieldTerminalPathArrayOfValues) AsPageSizeArrayOfValues() ([]int32, bool) {
	res, ok := fpaov.values.([]int32)
	return res, ok
}
func (fpaov *ListPhantomTimeSeriesRequest_FieldTerminalPathArrayOfValues) AsPageTokenArrayOfValues() ([]*phantom_time_serie.PagerCursor, bool) {
	res, ok := fpaov.values.([]*phantom_time_serie.PagerCursor)
	return res, ok
}
func (fpaov *ListPhantomTimeSeriesRequest_FieldTerminalPathArrayOfValues) AsOrderByArrayOfValues() ([]*phantom_time_serie.OrderBy, bool) {
	res, ok := fpaov.values.([]*phantom_time_serie.OrderBy)
	return res, ok
}
func (fpaov *ListPhantomTimeSeriesRequest_FieldTerminalPathArrayOfValues) AsFilterArrayOfValues() ([]*phantom_time_serie.Filter, bool) {
	res, ok := fpaov.values.([]*phantom_time_serie.Filter)
	return res, ok
}
func (fpaov *ListPhantomTimeSeriesRequest_FieldTerminalPathArrayOfValues) AsFieldMaskArrayOfValues() ([]*phantom_time_serie.PhantomTimeSerie_FieldMask, bool) {
	res, ok := fpaov.values.([]*phantom_time_serie.PhantomTimeSerie_FieldMask)
	return res, ok
}
func (fpaov *ListPhantomTimeSeriesRequest_FieldTerminalPathArrayOfValues) AsViewArrayOfValues() ([]view.View, bool) {
	res, ok := fpaov.values.([]view.View)
	return res, ok
}
func (fpaov *ListPhantomTimeSeriesRequest_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 ListPhantomTimeSeriesResponse_FieldPath interface {
	gotenobject.FieldPath
	Selector() ListPhantomTimeSeriesResponse_FieldPathSelector
	Get(source *ListPhantomTimeSeriesResponse) []interface{}
	GetSingle(source *ListPhantomTimeSeriesResponse) (interface{}, bool)
	ClearValue(item *ListPhantomTimeSeriesResponse)

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

type ListPhantomTimeSeriesResponse_FieldPathSelector int32

const (
	ListPhantomTimeSeriesResponse_FieldPathSelectorPhantomTimeSeries ListPhantomTimeSeriesResponse_FieldPathSelector = 0
	ListPhantomTimeSeriesResponse_FieldPathSelectorPrevPageToken     ListPhantomTimeSeriesResponse_FieldPathSelector = 1
	ListPhantomTimeSeriesResponse_FieldPathSelectorNextPageToken     ListPhantomTimeSeriesResponse_FieldPathSelector = 2
	ListPhantomTimeSeriesResponse_FieldPathSelectorCurrentOffset     ListPhantomTimeSeriesResponse_FieldPathSelector = 3
	ListPhantomTimeSeriesResponse_FieldPathSelectorTotalResultsCount ListPhantomTimeSeriesResponse_FieldPathSelector = 4
)

func (s ListPhantomTimeSeriesResponse_FieldPathSelector) String() string {
	switch s {
	case ListPhantomTimeSeriesResponse_FieldPathSelectorPhantomTimeSeries:
		return "phantom_time_series"
	case ListPhantomTimeSeriesResponse_FieldPathSelectorPrevPageToken:
		return "prev_page_token"
	case ListPhantomTimeSeriesResponse_FieldPathSelectorNextPageToken:
		return "next_page_token"
	case ListPhantomTimeSeriesResponse_FieldPathSelectorCurrentOffset:
		return "current_offset"
	case ListPhantomTimeSeriesResponse_FieldPathSelectorTotalResultsCount:
		return "total_results_count"
	default:
		panic(fmt.Sprintf("Invalid selector for ListPhantomTimeSeriesResponse: %d", s))
	}
}

func BuildListPhantomTimeSeriesResponse_FieldPath(fp gotenobject.RawFieldPath) (ListPhantomTimeSeriesResponse_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object ListPhantomTimeSeriesResponse")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "phantom_time_series", "phantomTimeSeries", "phantom-time-series":
			return &ListPhantomTimeSeriesResponse_FieldTerminalPath{selector: ListPhantomTimeSeriesResponse_FieldPathSelectorPhantomTimeSeries}, nil
		case "prev_page_token", "prevPageToken", "prev-page-token":
			return &ListPhantomTimeSeriesResponse_FieldTerminalPath{selector: ListPhantomTimeSeriesResponse_FieldPathSelectorPrevPageToken}, nil
		case "next_page_token", "nextPageToken", "next-page-token":
			return &ListPhantomTimeSeriesResponse_FieldTerminalPath{selector: ListPhantomTimeSeriesResponse_FieldPathSelectorNextPageToken}, nil
		case "current_offset", "currentOffset", "current-offset":
			return &ListPhantomTimeSeriesResponse_FieldTerminalPath{selector: ListPhantomTimeSeriesResponse_FieldPathSelectorCurrentOffset}, nil
		case "total_results_count", "totalResultsCount", "total-results-count":
			return &ListPhantomTimeSeriesResponse_FieldTerminalPath{selector: ListPhantomTimeSeriesResponse_FieldPathSelectorTotalResultsCount}, nil
		}
	} else {
		switch fp[0] {
		case "phantom_time_series", "phantomTimeSeries", "phantom-time-series":
			if subpath, err := phantom_time_serie.BuildPhantomTimeSerie_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &ListPhantomTimeSeriesResponse_FieldSubPath{selector: ListPhantomTimeSeriesResponse_FieldPathSelectorPhantomTimeSeries, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object ListPhantomTimeSeriesResponse", fp)
}

func ParseListPhantomTimeSeriesResponse_FieldPath(rawField string) (ListPhantomTimeSeriesResponse_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildListPhantomTimeSeriesResponse_FieldPath(fp)
}

func MustParseListPhantomTimeSeriesResponse_FieldPath(rawField string) ListPhantomTimeSeriesResponse_FieldPath {
	fp, err := ParseListPhantomTimeSeriesResponse_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type ListPhantomTimeSeriesResponse_FieldTerminalPath struct {
	selector ListPhantomTimeSeriesResponse_FieldPathSelector
}

var _ ListPhantomTimeSeriesResponse_FieldPath = (*ListPhantomTimeSeriesResponse_FieldTerminalPath)(nil)

func (fp *ListPhantomTimeSeriesResponse_FieldTerminalPath) Selector() ListPhantomTimeSeriesResponse_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source ListPhantomTimeSeriesResponse
func (fp *ListPhantomTimeSeriesResponse_FieldTerminalPath) Get(source *ListPhantomTimeSeriesResponse) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case ListPhantomTimeSeriesResponse_FieldPathSelectorPhantomTimeSeries:
			for _, value := range source.GetPhantomTimeSeries() {
				values = append(values, value)
			}
		case ListPhantomTimeSeriesResponse_FieldPathSelectorPrevPageToken:
			if source.PrevPageToken != nil {
				values = append(values, source.PrevPageToken)
			}
		case ListPhantomTimeSeriesResponse_FieldPathSelectorNextPageToken:
			if source.NextPageToken != nil {
				values = append(values, source.NextPageToken)
			}
		case ListPhantomTimeSeriesResponse_FieldPathSelectorCurrentOffset:
			values = append(values, source.CurrentOffset)
		case ListPhantomTimeSeriesResponse_FieldPathSelectorTotalResultsCount:
			values = append(values, source.TotalResultsCount)
		default:
			panic(fmt.Sprintf("Invalid selector for ListPhantomTimeSeriesResponse: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source ListPhantomTimeSeriesResponse
func (fp *ListPhantomTimeSeriesResponse_FieldTerminalPath) GetSingle(source *ListPhantomTimeSeriesResponse) (interface{}, bool) {
	switch fp.selector {
	case ListPhantomTimeSeriesResponse_FieldPathSelectorPhantomTimeSeries:
		res := source.GetPhantomTimeSeries()
		return res, res != nil
	case ListPhantomTimeSeriesResponse_FieldPathSelectorPrevPageToken:
		res := source.GetPrevPageToken()
		return res, res != nil
	case ListPhantomTimeSeriesResponse_FieldPathSelectorNextPageToken:
		res := source.GetNextPageToken()
		return res, res != nil
	case ListPhantomTimeSeriesResponse_FieldPathSelectorCurrentOffset:
		return source.GetCurrentOffset(), source != nil
	case ListPhantomTimeSeriesResponse_FieldPathSelectorTotalResultsCount:
		return source.GetTotalResultsCount(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for ListPhantomTimeSeriesResponse: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *ListPhantomTimeSeriesResponse_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case ListPhantomTimeSeriesResponse_FieldPathSelectorPhantomTimeSeries:
		return ([]*phantom_time_serie.PhantomTimeSerie)(nil)
	case ListPhantomTimeSeriesResponse_FieldPathSelectorPrevPageToken:
		return (*phantom_time_serie.PagerCursor)(nil)
	case ListPhantomTimeSeriesResponse_FieldPathSelectorNextPageToken:
		return (*phantom_time_serie.PagerCursor)(nil)
	case ListPhantomTimeSeriesResponse_FieldPathSelectorCurrentOffset:
		return int32(0)
	case ListPhantomTimeSeriesResponse_FieldPathSelectorTotalResultsCount:
		return int32(0)
	default:
		panic(fmt.Sprintf("Invalid selector for ListPhantomTimeSeriesResponse: %d", fp.selector))
	}
}

func (fp *ListPhantomTimeSeriesResponse_FieldTerminalPath) ClearValue(item *ListPhantomTimeSeriesResponse) {
	if item != nil {
		switch fp.selector {
		case ListPhantomTimeSeriesResponse_FieldPathSelectorPhantomTimeSeries:
			item.PhantomTimeSeries = nil
		case ListPhantomTimeSeriesResponse_FieldPathSelectorPrevPageToken:
			item.PrevPageToken = nil
		case ListPhantomTimeSeriesResponse_FieldPathSelectorNextPageToken:
			item.NextPageToken = nil
		case ListPhantomTimeSeriesResponse_FieldPathSelectorCurrentOffset:
			item.CurrentOffset = int32(0)
		case ListPhantomTimeSeriesResponse_FieldPathSelectorTotalResultsCount:
			item.TotalResultsCount = int32(0)
		default:
			panic(fmt.Sprintf("Invalid selector for ListPhantomTimeSeriesResponse: %d", fp.selector))
		}
	}
}

func (fp *ListPhantomTimeSeriesResponse_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*ListPhantomTimeSeriesResponse))
}

// IsLeaf - whether field path is holds simple value
func (fp *ListPhantomTimeSeriesResponse_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == ListPhantomTimeSeriesResponse_FieldPathSelectorPrevPageToken ||
		fp.selector == ListPhantomTimeSeriesResponse_FieldPathSelectorNextPageToken ||
		fp.selector == ListPhantomTimeSeriesResponse_FieldPathSelectorCurrentOffset ||
		fp.selector == ListPhantomTimeSeriesResponse_FieldPathSelectorTotalResultsCount
}

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

func (fp *ListPhantomTimeSeriesResponse_FieldTerminalPath) WithIValue(value interface{}) ListPhantomTimeSeriesResponse_FieldPathValue {
	switch fp.selector {
	case ListPhantomTimeSeriesResponse_FieldPathSelectorPhantomTimeSeries:
		return &ListPhantomTimeSeriesResponse_FieldTerminalPathValue{ListPhantomTimeSeriesResponse_FieldTerminalPath: *fp, value: value.([]*phantom_time_serie.PhantomTimeSerie)}
	case ListPhantomTimeSeriesResponse_FieldPathSelectorPrevPageToken:
		return &ListPhantomTimeSeriesResponse_FieldTerminalPathValue{ListPhantomTimeSeriesResponse_FieldTerminalPath: *fp, value: value.(*phantom_time_serie.PagerCursor)}
	case ListPhantomTimeSeriesResponse_FieldPathSelectorNextPageToken:
		return &ListPhantomTimeSeriesResponse_FieldTerminalPathValue{ListPhantomTimeSeriesResponse_FieldTerminalPath: *fp, value: value.(*phantom_time_serie.PagerCursor)}
	case ListPhantomTimeSeriesResponse_FieldPathSelectorCurrentOffset:
		return &ListPhantomTimeSeriesResponse_FieldTerminalPathValue{ListPhantomTimeSeriesResponse_FieldTerminalPath: *fp, value: value.(int32)}
	case ListPhantomTimeSeriesResponse_FieldPathSelectorTotalResultsCount:
		return &ListPhantomTimeSeriesResponse_FieldTerminalPathValue{ListPhantomTimeSeriesResponse_FieldTerminalPath: *fp, value: value.(int32)}
	default:
		panic(fmt.Sprintf("Invalid selector for ListPhantomTimeSeriesResponse: %d", fp.selector))
	}
}

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

func (fp *ListPhantomTimeSeriesResponse_FieldTerminalPath) WithIArrayOfValues(values interface{}) ListPhantomTimeSeriesResponse_FieldPathArrayOfValues {
	fpaov := &ListPhantomTimeSeriesResponse_FieldTerminalPathArrayOfValues{ListPhantomTimeSeriesResponse_FieldTerminalPath: *fp}
	switch fp.selector {
	case ListPhantomTimeSeriesResponse_FieldPathSelectorPhantomTimeSeries:
		return &ListPhantomTimeSeriesResponse_FieldTerminalPathArrayOfValues{ListPhantomTimeSeriesResponse_FieldTerminalPath: *fp, values: values.([][]*phantom_time_serie.PhantomTimeSerie)}
	case ListPhantomTimeSeriesResponse_FieldPathSelectorPrevPageToken:
		return &ListPhantomTimeSeriesResponse_FieldTerminalPathArrayOfValues{ListPhantomTimeSeriesResponse_FieldTerminalPath: *fp, values: values.([]*phantom_time_serie.PagerCursor)}
	case ListPhantomTimeSeriesResponse_FieldPathSelectorNextPageToken:
		return &ListPhantomTimeSeriesResponse_FieldTerminalPathArrayOfValues{ListPhantomTimeSeriesResponse_FieldTerminalPath: *fp, values: values.([]*phantom_time_serie.PagerCursor)}
	case ListPhantomTimeSeriesResponse_FieldPathSelectorCurrentOffset:
		return &ListPhantomTimeSeriesResponse_FieldTerminalPathArrayOfValues{ListPhantomTimeSeriesResponse_FieldTerminalPath: *fp, values: values.([]int32)}
	case ListPhantomTimeSeriesResponse_FieldPathSelectorTotalResultsCount:
		return &ListPhantomTimeSeriesResponse_FieldTerminalPathArrayOfValues{ListPhantomTimeSeriesResponse_FieldTerminalPath: *fp, values: values.([]int32)}
	default:
		panic(fmt.Sprintf("Invalid selector for ListPhantomTimeSeriesResponse: %d", fp.selector))
	}
	return fpaov
}

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

func (fp *ListPhantomTimeSeriesResponse_FieldTerminalPath) WithIArrayItemValue(value interface{}) ListPhantomTimeSeriesResponse_FieldPathArrayItemValue {
	switch fp.selector {
	case ListPhantomTimeSeriesResponse_FieldPathSelectorPhantomTimeSeries:
		return &ListPhantomTimeSeriesResponse_FieldTerminalPathArrayItemValue{ListPhantomTimeSeriesResponse_FieldTerminalPath: *fp, value: value.(*phantom_time_serie.PhantomTimeSerie)}
	default:
		panic(fmt.Sprintf("Invalid selector for ListPhantomTimeSeriesResponse: %d", fp.selector))
	}
}

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

type ListPhantomTimeSeriesResponse_FieldSubPath struct {
	selector ListPhantomTimeSeriesResponse_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ ListPhantomTimeSeriesResponse_FieldPath = (*ListPhantomTimeSeriesResponse_FieldSubPath)(nil)

func (fps *ListPhantomTimeSeriesResponse_FieldSubPath) Selector() ListPhantomTimeSeriesResponse_FieldPathSelector {
	return fps.selector
}
func (fps *ListPhantomTimeSeriesResponse_FieldSubPath) AsPhantomTimeSeriesSubPath() (phantom_time_serie.PhantomTimeSerie_FieldPath, bool) {
	res, ok := fps.subPath.(phantom_time_serie.PhantomTimeSerie_FieldPath)
	return res, ok
}

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

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

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

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

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

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

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

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

func (fps *ListPhantomTimeSeriesResponse_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*ListPhantomTimeSeriesResponse))
}

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

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

func (fps *ListPhantomTimeSeriesResponse_FieldSubPath) WithIValue(value interface{}) ListPhantomTimeSeriesResponse_FieldPathValue {
	return &ListPhantomTimeSeriesResponse_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *ListPhantomTimeSeriesResponse_FieldSubPath) WithIArrayOfValues(values interface{}) ListPhantomTimeSeriesResponse_FieldPathArrayOfValues {
	return &ListPhantomTimeSeriesResponse_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *ListPhantomTimeSeriesResponse_FieldSubPath) WithIArrayItemValue(value interface{}) ListPhantomTimeSeriesResponse_FieldPathArrayItemValue {
	return &ListPhantomTimeSeriesResponse_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

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

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

func MustParseListPhantomTimeSeriesResponse_FieldPathValue(pathStr, valueStr string) ListPhantomTimeSeriesResponse_FieldPathValue {
	fpv, err := ParseListPhantomTimeSeriesResponse_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type ListPhantomTimeSeriesResponse_FieldTerminalPathValue struct {
	ListPhantomTimeSeriesResponse_FieldTerminalPath
	value interface{}
}

var _ ListPhantomTimeSeriesResponse_FieldPathValue = (*ListPhantomTimeSeriesResponse_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'ListPhantomTimeSeriesResponse' as interface{}
func (fpv *ListPhantomTimeSeriesResponse_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *ListPhantomTimeSeriesResponse_FieldTerminalPathValue) AsPhantomTimeSeriesValue() ([]*phantom_time_serie.PhantomTimeSerie, bool) {
	res, ok := fpv.value.([]*phantom_time_serie.PhantomTimeSerie)
	return res, ok
}
func (fpv *ListPhantomTimeSeriesResponse_FieldTerminalPathValue) AsPrevPageTokenValue() (*phantom_time_serie.PagerCursor, bool) {
	res, ok := fpv.value.(*phantom_time_serie.PagerCursor)
	return res, ok
}
func (fpv *ListPhantomTimeSeriesResponse_FieldTerminalPathValue) AsNextPageTokenValue() (*phantom_time_serie.PagerCursor, bool) {
	res, ok := fpv.value.(*phantom_time_serie.PagerCursor)
	return res, ok
}
func (fpv *ListPhantomTimeSeriesResponse_FieldTerminalPathValue) AsCurrentOffsetValue() (int32, bool) {
	res, ok := fpv.value.(int32)
	return res, ok
}
func (fpv *ListPhantomTimeSeriesResponse_FieldTerminalPathValue) AsTotalResultsCountValue() (int32, bool) {
	res, ok := fpv.value.(int32)
	return res, ok
}

// SetTo stores value for selected field for object ListPhantomTimeSeriesResponse
func (fpv *ListPhantomTimeSeriesResponse_FieldTerminalPathValue) SetTo(target **ListPhantomTimeSeriesResponse) {
	if *target == nil {
		*target = new(ListPhantomTimeSeriesResponse)
	}
	switch fpv.selector {
	case ListPhantomTimeSeriesResponse_FieldPathSelectorPhantomTimeSeries:
		(*target).PhantomTimeSeries = fpv.value.([]*phantom_time_serie.PhantomTimeSerie)
	case ListPhantomTimeSeriesResponse_FieldPathSelectorPrevPageToken:
		(*target).PrevPageToken = fpv.value.(*phantom_time_serie.PagerCursor)
	case ListPhantomTimeSeriesResponse_FieldPathSelectorNextPageToken:
		(*target).NextPageToken = fpv.value.(*phantom_time_serie.PagerCursor)
	case ListPhantomTimeSeriesResponse_FieldPathSelectorCurrentOffset:
		(*target).CurrentOffset = fpv.value.(int32)
	case ListPhantomTimeSeriesResponse_FieldPathSelectorTotalResultsCount:
		(*target).TotalResultsCount = fpv.value.(int32)
	default:
		panic(fmt.Sprintf("Invalid selector for ListPhantomTimeSeriesResponse: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'ListPhantomTimeSeriesResponse_FieldTerminalPathValue' with the value under path in 'ListPhantomTimeSeriesResponse'.
func (fpv *ListPhantomTimeSeriesResponse_FieldTerminalPathValue) CompareWith(source *ListPhantomTimeSeriesResponse) (int, bool) {
	switch fpv.selector {
	case ListPhantomTimeSeriesResponse_FieldPathSelectorPhantomTimeSeries:
		return 0, false
	case ListPhantomTimeSeriesResponse_FieldPathSelectorPrevPageToken:
		return 0, false
	case ListPhantomTimeSeriesResponse_FieldPathSelectorNextPageToken:
		return 0, false
	case ListPhantomTimeSeriesResponse_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 ListPhantomTimeSeriesResponse_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 ListPhantomTimeSeriesResponse: %d", fpv.selector))
	}
}

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

type ListPhantomTimeSeriesResponse_FieldSubPathValue struct {
	ListPhantomTimeSeriesResponse_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ ListPhantomTimeSeriesResponse_FieldPathValue = (*ListPhantomTimeSeriesResponse_FieldSubPathValue)(nil)

func (fpvs *ListPhantomTimeSeriesResponse_FieldSubPathValue) AsPhantomTimeSeriesPathValue() (phantom_time_serie.PhantomTimeSerie_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(phantom_time_serie.PhantomTimeSerie_FieldPathValue)
	return res, ok
}

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

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

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

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

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

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

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

func MustParseListPhantomTimeSeriesResponse_FieldPathArrayItemValue(pathStr, valueStr string) ListPhantomTimeSeriesResponse_FieldPathArrayItemValue {
	fpaiv, err := ParseListPhantomTimeSeriesResponse_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type ListPhantomTimeSeriesResponse_FieldTerminalPathArrayItemValue struct {
	ListPhantomTimeSeriesResponse_FieldTerminalPath
	value interface{}
}

var _ ListPhantomTimeSeriesResponse_FieldPathArrayItemValue = (*ListPhantomTimeSeriesResponse_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object ListPhantomTimeSeriesResponse as interface{}
func (fpaiv *ListPhantomTimeSeriesResponse_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}
func (fpaiv *ListPhantomTimeSeriesResponse_FieldTerminalPathArrayItemValue) AsPhantomTimeSeriesItemValue() (*phantom_time_serie.PhantomTimeSerie, bool) {
	res, ok := fpaiv.value.(*phantom_time_serie.PhantomTimeSerie)
	return res, ok
}

func (fpaiv *ListPhantomTimeSeriesResponse_FieldTerminalPathArrayItemValue) GetSingle(source *ListPhantomTimeSeriesResponse) (interface{}, bool) {
	return nil, false
}

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

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

// GetRawValue returns stored array item value
func (fpaivs *ListPhantomTimeSeriesResponse_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *ListPhantomTimeSeriesResponse_FieldSubPathArrayItemValue) AsPhantomTimeSeriesPathItemValue() (phantom_time_serie.PhantomTimeSerie_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(phantom_time_serie.PhantomTimeSerie_FieldPathArrayItemValue)
	return res, ok
}

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

// ListPhantomTimeSeriesResponse_FieldPathArrayOfValues allows storing slice of values for ListPhantomTimeSeriesResponse fields according to their type
type ListPhantomTimeSeriesResponse_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	ListPhantomTimeSeriesResponse_FieldPath
}

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

func MustParseListPhantomTimeSeriesResponse_FieldPathArrayOfValues(pathStr, valuesStr string) ListPhantomTimeSeriesResponse_FieldPathArrayOfValues {
	fpaov, err := ParseListPhantomTimeSeriesResponse_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type ListPhantomTimeSeriesResponse_FieldTerminalPathArrayOfValues struct {
	ListPhantomTimeSeriesResponse_FieldTerminalPath
	values interface{}
}

var _ ListPhantomTimeSeriesResponse_FieldPathArrayOfValues = (*ListPhantomTimeSeriesResponse_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *ListPhantomTimeSeriesResponse_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case ListPhantomTimeSeriesResponse_FieldPathSelectorPhantomTimeSeries:
		for _, v := range fpaov.values.([][]*phantom_time_serie.PhantomTimeSerie) {
			values = append(values, v)
		}
	case ListPhantomTimeSeriesResponse_FieldPathSelectorPrevPageToken:
		for _, v := range fpaov.values.([]*phantom_time_serie.PagerCursor) {
			values = append(values, v)
		}
	case ListPhantomTimeSeriesResponse_FieldPathSelectorNextPageToken:
		for _, v := range fpaov.values.([]*phantom_time_serie.PagerCursor) {
			values = append(values, v)
		}
	case ListPhantomTimeSeriesResponse_FieldPathSelectorCurrentOffset:
		for _, v := range fpaov.values.([]int32) {
			values = append(values, v)
		}
	case ListPhantomTimeSeriesResponse_FieldPathSelectorTotalResultsCount:
		for _, v := range fpaov.values.([]int32) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *ListPhantomTimeSeriesResponse_FieldTerminalPathArrayOfValues) AsPhantomTimeSeriesArrayOfValues() ([][]*phantom_time_serie.PhantomTimeSerie, bool) {
	res, ok := fpaov.values.([][]*phantom_time_serie.PhantomTimeSerie)
	return res, ok
}
func (fpaov *ListPhantomTimeSeriesResponse_FieldTerminalPathArrayOfValues) AsPrevPageTokenArrayOfValues() ([]*phantom_time_serie.PagerCursor, bool) {
	res, ok := fpaov.values.([]*phantom_time_serie.PagerCursor)
	return res, ok
}
func (fpaov *ListPhantomTimeSeriesResponse_FieldTerminalPathArrayOfValues) AsNextPageTokenArrayOfValues() ([]*phantom_time_serie.PagerCursor, bool) {
	res, ok := fpaov.values.([]*phantom_time_serie.PagerCursor)
	return res, ok
}
func (fpaov *ListPhantomTimeSeriesResponse_FieldTerminalPathArrayOfValues) AsCurrentOffsetArrayOfValues() ([]int32, bool) {
	res, ok := fpaov.values.([]int32)
	return res, ok
}
func (fpaov *ListPhantomTimeSeriesResponse_FieldTerminalPathArrayOfValues) AsTotalResultsCountArrayOfValues() ([]int32, bool) {
	res, ok := fpaov.values.([]int32)
	return res, ok
}

type ListPhantomTimeSeriesResponse_FieldSubPathArrayOfValues struct {
	ListPhantomTimeSeriesResponse_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ ListPhantomTimeSeriesResponse_FieldPathArrayOfValues = (*ListPhantomTimeSeriesResponse_FieldSubPathArrayOfValues)(nil)

func (fpsaov *ListPhantomTimeSeriesResponse_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *ListPhantomTimeSeriesResponse_FieldSubPathArrayOfValues) AsPhantomTimeSeriesPathArrayOfValues() (phantom_time_serie.PhantomTimeSerie_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(phantom_time_serie.PhantomTimeSerie_FieldPathArrayOfValues)
	return res, ok
}

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

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

type WatchPhantomTimeSerieRequest_FieldPathSelector int32

const (
	WatchPhantomTimeSerieRequest_FieldPathSelectorName      WatchPhantomTimeSerieRequest_FieldPathSelector = 0
	WatchPhantomTimeSerieRequest_FieldPathSelectorFieldMask WatchPhantomTimeSerieRequest_FieldPathSelector = 1
	WatchPhantomTimeSerieRequest_FieldPathSelectorView      WatchPhantomTimeSerieRequest_FieldPathSelector = 2
)

func (s WatchPhantomTimeSerieRequest_FieldPathSelector) String() string {
	switch s {
	case WatchPhantomTimeSerieRequest_FieldPathSelectorName:
		return "name"
	case WatchPhantomTimeSerieRequest_FieldPathSelectorFieldMask:
		return "field_mask"
	case WatchPhantomTimeSerieRequest_FieldPathSelectorView:
		return "view"
	default:
		panic(fmt.Sprintf("Invalid selector for WatchPhantomTimeSerieRequest: %d", s))
	}
}

func BuildWatchPhantomTimeSerieRequest_FieldPath(fp gotenobject.RawFieldPath) (WatchPhantomTimeSerieRequest_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object WatchPhantomTimeSerieRequest")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "name":
			return &WatchPhantomTimeSerieRequest_FieldTerminalPath{selector: WatchPhantomTimeSerieRequest_FieldPathSelectorName}, nil
		case "field_mask", "fieldMask", "field-mask":
			return &WatchPhantomTimeSerieRequest_FieldTerminalPath{selector: WatchPhantomTimeSerieRequest_FieldPathSelectorFieldMask}, nil
		case "view":
			return &WatchPhantomTimeSerieRequest_FieldTerminalPath{selector: WatchPhantomTimeSerieRequest_FieldPathSelectorView}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object WatchPhantomTimeSerieRequest", fp)
}

func ParseWatchPhantomTimeSerieRequest_FieldPath(rawField string) (WatchPhantomTimeSerieRequest_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildWatchPhantomTimeSerieRequest_FieldPath(fp)
}

func MustParseWatchPhantomTimeSerieRequest_FieldPath(rawField string) WatchPhantomTimeSerieRequest_FieldPath {
	fp, err := ParseWatchPhantomTimeSerieRequest_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type WatchPhantomTimeSerieRequest_FieldTerminalPath struct {
	selector WatchPhantomTimeSerieRequest_FieldPathSelector
}

var _ WatchPhantomTimeSerieRequest_FieldPath = (*WatchPhantomTimeSerieRequest_FieldTerminalPath)(nil)

func (fp *WatchPhantomTimeSerieRequest_FieldTerminalPath) Selector() WatchPhantomTimeSerieRequest_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

// GetDefault returns a default value of the field type
func (fp *WatchPhantomTimeSerieRequest_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case WatchPhantomTimeSerieRequest_FieldPathSelectorName:
		return (*phantom_time_serie.Reference)(nil)
	case WatchPhantomTimeSerieRequest_FieldPathSelectorFieldMask:
		return (*phantom_time_serie.PhantomTimeSerie_FieldMask)(nil)
	case WatchPhantomTimeSerieRequest_FieldPathSelectorView:
		return view.View_UNSPECIFIED
	default:
		panic(fmt.Sprintf("Invalid selector for WatchPhantomTimeSerieRequest: %d", fp.selector))
	}
}

func (fp *WatchPhantomTimeSerieRequest_FieldTerminalPath) ClearValue(item *WatchPhantomTimeSerieRequest) {
	if item != nil {
		switch fp.selector {
		case WatchPhantomTimeSerieRequest_FieldPathSelectorName:
			item.Name = nil
		case WatchPhantomTimeSerieRequest_FieldPathSelectorFieldMask:
			item.FieldMask = nil
		case WatchPhantomTimeSerieRequest_FieldPathSelectorView:
			item.View = view.View_UNSPECIFIED
		default:
			panic(fmt.Sprintf("Invalid selector for WatchPhantomTimeSerieRequest: %d", fp.selector))
		}
	}
}

func (fp *WatchPhantomTimeSerieRequest_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*WatchPhantomTimeSerieRequest))
}

// IsLeaf - whether field path is holds simple value
func (fp *WatchPhantomTimeSerieRequest_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == WatchPhantomTimeSerieRequest_FieldPathSelectorName ||
		fp.selector == WatchPhantomTimeSerieRequest_FieldPathSelectorFieldMask ||
		fp.selector == WatchPhantomTimeSerieRequest_FieldPathSelectorView
}

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

func (fp *WatchPhantomTimeSerieRequest_FieldTerminalPath) WithIValue(value interface{}) WatchPhantomTimeSerieRequest_FieldPathValue {
	switch fp.selector {
	case WatchPhantomTimeSerieRequest_FieldPathSelectorName:
		return &WatchPhantomTimeSerieRequest_FieldTerminalPathValue{WatchPhantomTimeSerieRequest_FieldTerminalPath: *fp, value: value.(*phantom_time_serie.Reference)}
	case WatchPhantomTimeSerieRequest_FieldPathSelectorFieldMask:
		return &WatchPhantomTimeSerieRequest_FieldTerminalPathValue{WatchPhantomTimeSerieRequest_FieldTerminalPath: *fp, value: value.(*phantom_time_serie.PhantomTimeSerie_FieldMask)}
	case WatchPhantomTimeSerieRequest_FieldPathSelectorView:
		return &WatchPhantomTimeSerieRequest_FieldTerminalPathValue{WatchPhantomTimeSerieRequest_FieldTerminalPath: *fp, value: value.(view.View)}
	default:
		panic(fmt.Sprintf("Invalid selector for WatchPhantomTimeSerieRequest: %d", fp.selector))
	}
}

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

func (fp *WatchPhantomTimeSerieRequest_FieldTerminalPath) WithIArrayOfValues(values interface{}) WatchPhantomTimeSerieRequest_FieldPathArrayOfValues {
	fpaov := &WatchPhantomTimeSerieRequest_FieldTerminalPathArrayOfValues{WatchPhantomTimeSerieRequest_FieldTerminalPath: *fp}
	switch fp.selector {
	case WatchPhantomTimeSerieRequest_FieldPathSelectorName:
		return &WatchPhantomTimeSerieRequest_FieldTerminalPathArrayOfValues{WatchPhantomTimeSerieRequest_FieldTerminalPath: *fp, values: values.([]*phantom_time_serie.Reference)}
	case WatchPhantomTimeSerieRequest_FieldPathSelectorFieldMask:
		return &WatchPhantomTimeSerieRequest_FieldTerminalPathArrayOfValues{WatchPhantomTimeSerieRequest_FieldTerminalPath: *fp, values: values.([]*phantom_time_serie.PhantomTimeSerie_FieldMask)}
	case WatchPhantomTimeSerieRequest_FieldPathSelectorView:
		return &WatchPhantomTimeSerieRequest_FieldTerminalPathArrayOfValues{WatchPhantomTimeSerieRequest_FieldTerminalPath: *fp, values: values.([]view.View)}
	default:
		panic(fmt.Sprintf("Invalid selector for WatchPhantomTimeSerieRequest: %d", fp.selector))
	}
	return fpaov
}

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

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

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

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

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

func MustParseWatchPhantomTimeSerieRequest_FieldPathValue(pathStr, valueStr string) WatchPhantomTimeSerieRequest_FieldPathValue {
	fpv, err := ParseWatchPhantomTimeSerieRequest_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type WatchPhantomTimeSerieRequest_FieldTerminalPathValue struct {
	WatchPhantomTimeSerieRequest_FieldTerminalPath
	value interface{}
}

var _ WatchPhantomTimeSerieRequest_FieldPathValue = (*WatchPhantomTimeSerieRequest_FieldTerminalPathValue)(nil)

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

// SetTo stores value for selected field for object WatchPhantomTimeSerieRequest
func (fpv *WatchPhantomTimeSerieRequest_FieldTerminalPathValue) SetTo(target **WatchPhantomTimeSerieRequest) {
	if *target == nil {
		*target = new(WatchPhantomTimeSerieRequest)
	}
	switch fpv.selector {
	case WatchPhantomTimeSerieRequest_FieldPathSelectorName:
		(*target).Name = fpv.value.(*phantom_time_serie.Reference)
	case WatchPhantomTimeSerieRequest_FieldPathSelectorFieldMask:
		(*target).FieldMask = fpv.value.(*phantom_time_serie.PhantomTimeSerie_FieldMask)
	case WatchPhantomTimeSerieRequest_FieldPathSelectorView:
		(*target).View = fpv.value.(view.View)
	default:
		panic(fmt.Sprintf("Invalid selector for WatchPhantomTimeSerieRequest: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'WatchPhantomTimeSerieRequest_FieldTerminalPathValue' with the value under path in 'WatchPhantomTimeSerieRequest'.
func (fpv *WatchPhantomTimeSerieRequest_FieldTerminalPathValue) CompareWith(source *WatchPhantomTimeSerieRequest) (int, bool) {
	switch fpv.selector {
	case WatchPhantomTimeSerieRequest_FieldPathSelectorName:
		leftValue := fpv.value.(*phantom_time_serie.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 WatchPhantomTimeSerieRequest_FieldPathSelectorFieldMask:
		return 0, false
	case WatchPhantomTimeSerieRequest_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 WatchPhantomTimeSerieRequest: %d", fpv.selector))
	}
}

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

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

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

func MustParseWatchPhantomTimeSerieRequest_FieldPathArrayItemValue(pathStr, valueStr string) WatchPhantomTimeSerieRequest_FieldPathArrayItemValue {
	fpaiv, err := ParseWatchPhantomTimeSerieRequest_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type WatchPhantomTimeSerieRequest_FieldTerminalPathArrayItemValue struct {
	WatchPhantomTimeSerieRequest_FieldTerminalPath
	value interface{}
}

var _ WatchPhantomTimeSerieRequest_FieldPathArrayItemValue = (*WatchPhantomTimeSerieRequest_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *WatchPhantomTimeSerieRequest_FieldTerminalPathArrayItemValue) GetSingle(source *WatchPhantomTimeSerieRequest) (interface{}, bool) {
	return nil, false
}

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

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

// WatchPhantomTimeSerieRequest_FieldPathArrayOfValues allows storing slice of values for WatchPhantomTimeSerieRequest fields according to their type
type WatchPhantomTimeSerieRequest_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	WatchPhantomTimeSerieRequest_FieldPath
}

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

func MustParseWatchPhantomTimeSerieRequest_FieldPathArrayOfValues(pathStr, valuesStr string) WatchPhantomTimeSerieRequest_FieldPathArrayOfValues {
	fpaov, err := ParseWatchPhantomTimeSerieRequest_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type WatchPhantomTimeSerieRequest_FieldTerminalPathArrayOfValues struct {
	WatchPhantomTimeSerieRequest_FieldTerminalPath
	values interface{}
}

var _ WatchPhantomTimeSerieRequest_FieldPathArrayOfValues = (*WatchPhantomTimeSerieRequest_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *WatchPhantomTimeSerieRequest_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case WatchPhantomTimeSerieRequest_FieldPathSelectorName:
		for _, v := range fpaov.values.([]*phantom_time_serie.Reference) {
			values = append(values, v)
		}
	case WatchPhantomTimeSerieRequest_FieldPathSelectorFieldMask:
		for _, v := range fpaov.values.([]*phantom_time_serie.PhantomTimeSerie_FieldMask) {
			values = append(values, v)
		}
	case WatchPhantomTimeSerieRequest_FieldPathSelectorView:
		for _, v := range fpaov.values.([]view.View) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *WatchPhantomTimeSerieRequest_FieldTerminalPathArrayOfValues) AsNameArrayOfValues() ([]*phantom_time_serie.Reference, bool) {
	res, ok := fpaov.values.([]*phantom_time_serie.Reference)
	return res, ok
}
func (fpaov *WatchPhantomTimeSerieRequest_FieldTerminalPathArrayOfValues) AsFieldMaskArrayOfValues() ([]*phantom_time_serie.PhantomTimeSerie_FieldMask, bool) {
	res, ok := fpaov.values.([]*phantom_time_serie.PhantomTimeSerie_FieldMask)
	return res, ok
}
func (fpaov *WatchPhantomTimeSerieRequest_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 WatchPhantomTimeSerieResponse_FieldPath interface {
	gotenobject.FieldPath
	Selector() WatchPhantomTimeSerieResponse_FieldPathSelector
	Get(source *WatchPhantomTimeSerieResponse) []interface{}
	GetSingle(source *WatchPhantomTimeSerieResponse) (interface{}, bool)
	ClearValue(item *WatchPhantomTimeSerieResponse)

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

type WatchPhantomTimeSerieResponse_FieldPathSelector int32

const (
	WatchPhantomTimeSerieResponse_FieldPathSelectorChange WatchPhantomTimeSerieResponse_FieldPathSelector = 0
)

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

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

func ParseWatchPhantomTimeSerieResponse_FieldPath(rawField string) (WatchPhantomTimeSerieResponse_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildWatchPhantomTimeSerieResponse_FieldPath(fp)
}

func MustParseWatchPhantomTimeSerieResponse_FieldPath(rawField string) WatchPhantomTimeSerieResponse_FieldPath {
	fp, err := ParseWatchPhantomTimeSerieResponse_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type WatchPhantomTimeSerieResponse_FieldTerminalPath struct {
	selector WatchPhantomTimeSerieResponse_FieldPathSelector
}

var _ WatchPhantomTimeSerieResponse_FieldPath = (*WatchPhantomTimeSerieResponse_FieldTerminalPath)(nil)

func (fp *WatchPhantomTimeSerieResponse_FieldTerminalPath) Selector() WatchPhantomTimeSerieResponse_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

// GetDefault returns a default value of the field type
func (fp *WatchPhantomTimeSerieResponse_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case WatchPhantomTimeSerieResponse_FieldPathSelectorChange:
		return (*phantom_time_serie.PhantomTimeSerieChange)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for WatchPhantomTimeSerieResponse: %d", fp.selector))
	}
}

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

func (fp *WatchPhantomTimeSerieResponse_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*WatchPhantomTimeSerieResponse))
}

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

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

func (fp *WatchPhantomTimeSerieResponse_FieldTerminalPath) WithIValue(value interface{}) WatchPhantomTimeSerieResponse_FieldPathValue {
	switch fp.selector {
	case WatchPhantomTimeSerieResponse_FieldPathSelectorChange:
		return &WatchPhantomTimeSerieResponse_FieldTerminalPathValue{WatchPhantomTimeSerieResponse_FieldTerminalPath: *fp, value: value.(*phantom_time_serie.PhantomTimeSerieChange)}
	default:
		panic(fmt.Sprintf("Invalid selector for WatchPhantomTimeSerieResponse: %d", fp.selector))
	}
}

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

func (fp *WatchPhantomTimeSerieResponse_FieldTerminalPath) WithIArrayOfValues(values interface{}) WatchPhantomTimeSerieResponse_FieldPathArrayOfValues {
	fpaov := &WatchPhantomTimeSerieResponse_FieldTerminalPathArrayOfValues{WatchPhantomTimeSerieResponse_FieldTerminalPath: *fp}
	switch fp.selector {
	case WatchPhantomTimeSerieResponse_FieldPathSelectorChange:
		return &WatchPhantomTimeSerieResponse_FieldTerminalPathArrayOfValues{WatchPhantomTimeSerieResponse_FieldTerminalPath: *fp, values: values.([]*phantom_time_serie.PhantomTimeSerieChange)}
	default:
		panic(fmt.Sprintf("Invalid selector for WatchPhantomTimeSerieResponse: %d", fp.selector))
	}
	return fpaov
}

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

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

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

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

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

func MustParseWatchPhantomTimeSerieResponse_FieldPathValue(pathStr, valueStr string) WatchPhantomTimeSerieResponse_FieldPathValue {
	fpv, err := ParseWatchPhantomTimeSerieResponse_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type WatchPhantomTimeSerieResponse_FieldTerminalPathValue struct {
	WatchPhantomTimeSerieResponse_FieldTerminalPath
	value interface{}
}

var _ WatchPhantomTimeSerieResponse_FieldPathValue = (*WatchPhantomTimeSerieResponse_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'WatchPhantomTimeSerieResponse' as interface{}
func (fpv *WatchPhantomTimeSerieResponse_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *WatchPhantomTimeSerieResponse_FieldTerminalPathValue) AsChangeValue() (*phantom_time_serie.PhantomTimeSerieChange, bool) {
	res, ok := fpv.value.(*phantom_time_serie.PhantomTimeSerieChange)
	return res, ok
}

// SetTo stores value for selected field for object WatchPhantomTimeSerieResponse
func (fpv *WatchPhantomTimeSerieResponse_FieldTerminalPathValue) SetTo(target **WatchPhantomTimeSerieResponse) {
	if *target == nil {
		*target = new(WatchPhantomTimeSerieResponse)
	}
	switch fpv.selector {
	case WatchPhantomTimeSerieResponse_FieldPathSelectorChange:
		(*target).Change = fpv.value.(*phantom_time_serie.PhantomTimeSerieChange)
	default:
		panic(fmt.Sprintf("Invalid selector for WatchPhantomTimeSerieResponse: %d", fpv.selector))
	}
}

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

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

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

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

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

func MustParseWatchPhantomTimeSerieResponse_FieldPathArrayItemValue(pathStr, valueStr string) WatchPhantomTimeSerieResponse_FieldPathArrayItemValue {
	fpaiv, err := ParseWatchPhantomTimeSerieResponse_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type WatchPhantomTimeSerieResponse_FieldTerminalPathArrayItemValue struct {
	WatchPhantomTimeSerieResponse_FieldTerminalPath
	value interface{}
}

var _ WatchPhantomTimeSerieResponse_FieldPathArrayItemValue = (*WatchPhantomTimeSerieResponse_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *WatchPhantomTimeSerieResponse_FieldTerminalPathArrayItemValue) GetSingle(source *WatchPhantomTimeSerieResponse) (interface{}, bool) {
	return nil, false
}

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

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

// WatchPhantomTimeSerieResponse_FieldPathArrayOfValues allows storing slice of values for WatchPhantomTimeSerieResponse fields according to their type
type WatchPhantomTimeSerieResponse_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	WatchPhantomTimeSerieResponse_FieldPath
}

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

func MustParseWatchPhantomTimeSerieResponse_FieldPathArrayOfValues(pathStr, valuesStr string) WatchPhantomTimeSerieResponse_FieldPathArrayOfValues {
	fpaov, err := ParseWatchPhantomTimeSerieResponse_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type WatchPhantomTimeSerieResponse_FieldTerminalPathArrayOfValues struct {
	WatchPhantomTimeSerieResponse_FieldTerminalPath
	values interface{}
}

var _ WatchPhantomTimeSerieResponse_FieldPathArrayOfValues = (*WatchPhantomTimeSerieResponse_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *WatchPhantomTimeSerieResponse_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case WatchPhantomTimeSerieResponse_FieldPathSelectorChange:
		for _, v := range fpaov.values.([]*phantom_time_serie.PhantomTimeSerieChange) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *WatchPhantomTimeSerieResponse_FieldTerminalPathArrayOfValues) AsChangeArrayOfValues() ([]*phantom_time_serie.PhantomTimeSerieChange, bool) {
	res, ok := fpaov.values.([]*phantom_time_serie.PhantomTimeSerieChange)
	return res, ok
}

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

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

type WatchPhantomTimeSeriesRequest_FieldPathSelector int32

const (
	WatchPhantomTimeSeriesRequest_FieldPathSelectorType         WatchPhantomTimeSeriesRequest_FieldPathSelector = 0
	WatchPhantomTimeSeriesRequest_FieldPathSelectorParent       WatchPhantomTimeSeriesRequest_FieldPathSelector = 1
	WatchPhantomTimeSeriesRequest_FieldPathSelectorPageSize     WatchPhantomTimeSeriesRequest_FieldPathSelector = 2
	WatchPhantomTimeSeriesRequest_FieldPathSelectorPageToken    WatchPhantomTimeSeriesRequest_FieldPathSelector = 3
	WatchPhantomTimeSeriesRequest_FieldPathSelectorOrderBy      WatchPhantomTimeSeriesRequest_FieldPathSelector = 4
	WatchPhantomTimeSeriesRequest_FieldPathSelectorResumeToken  WatchPhantomTimeSeriesRequest_FieldPathSelector = 5
	WatchPhantomTimeSeriesRequest_FieldPathSelectorStartingTime WatchPhantomTimeSeriesRequest_FieldPathSelector = 6
	WatchPhantomTimeSeriesRequest_FieldPathSelectorFilter       WatchPhantomTimeSeriesRequest_FieldPathSelector = 7
	WatchPhantomTimeSeriesRequest_FieldPathSelectorFieldMask    WatchPhantomTimeSeriesRequest_FieldPathSelector = 8
	WatchPhantomTimeSeriesRequest_FieldPathSelectorView         WatchPhantomTimeSeriesRequest_FieldPathSelector = 9
	WatchPhantomTimeSeriesRequest_FieldPathSelectorMaxChunkSize WatchPhantomTimeSeriesRequest_FieldPathSelector = 10
)

func (s WatchPhantomTimeSeriesRequest_FieldPathSelector) String() string {
	switch s {
	case WatchPhantomTimeSeriesRequest_FieldPathSelectorType:
		return "type"
	case WatchPhantomTimeSeriesRequest_FieldPathSelectorParent:
		return "parent"
	case WatchPhantomTimeSeriesRequest_FieldPathSelectorPageSize:
		return "page_size"
	case WatchPhantomTimeSeriesRequest_FieldPathSelectorPageToken:
		return "page_token"
	case WatchPhantomTimeSeriesRequest_FieldPathSelectorOrderBy:
		return "order_by"
	case WatchPhantomTimeSeriesRequest_FieldPathSelectorResumeToken:
		return "resume_token"
	case WatchPhantomTimeSeriesRequest_FieldPathSelectorStartingTime:
		return "starting_time"
	case WatchPhantomTimeSeriesRequest_FieldPathSelectorFilter:
		return "filter"
	case WatchPhantomTimeSeriesRequest_FieldPathSelectorFieldMask:
		return "field_mask"
	case WatchPhantomTimeSeriesRequest_FieldPathSelectorView:
		return "view"
	case WatchPhantomTimeSeriesRequest_FieldPathSelectorMaxChunkSize:
		return "max_chunk_size"
	default:
		panic(fmt.Sprintf("Invalid selector for WatchPhantomTimeSeriesRequest: %d", s))
	}
}

func BuildWatchPhantomTimeSeriesRequest_FieldPath(fp gotenobject.RawFieldPath) (WatchPhantomTimeSeriesRequest_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object WatchPhantomTimeSeriesRequest")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "type":
			return &WatchPhantomTimeSeriesRequest_FieldTerminalPath{selector: WatchPhantomTimeSeriesRequest_FieldPathSelectorType}, nil
		case "parent":
			return &WatchPhantomTimeSeriesRequest_FieldTerminalPath{selector: WatchPhantomTimeSeriesRequest_FieldPathSelectorParent}, nil
		case "page_size", "pageSize", "page-size":
			return &WatchPhantomTimeSeriesRequest_FieldTerminalPath{selector: WatchPhantomTimeSeriesRequest_FieldPathSelectorPageSize}, nil
		case "page_token", "pageToken", "page-token":
			return &WatchPhantomTimeSeriesRequest_FieldTerminalPath{selector: WatchPhantomTimeSeriesRequest_FieldPathSelectorPageToken}, nil
		case "order_by", "orderBy", "order-by":
			return &WatchPhantomTimeSeriesRequest_FieldTerminalPath{selector: WatchPhantomTimeSeriesRequest_FieldPathSelectorOrderBy}, nil
		case "resume_token", "resumeToken", "resume-token":
			return &WatchPhantomTimeSeriesRequest_FieldTerminalPath{selector: WatchPhantomTimeSeriesRequest_FieldPathSelectorResumeToken}, nil
		case "starting_time", "startingTime", "starting-time":
			return &WatchPhantomTimeSeriesRequest_FieldTerminalPath{selector: WatchPhantomTimeSeriesRequest_FieldPathSelectorStartingTime}, nil
		case "filter":
			return &WatchPhantomTimeSeriesRequest_FieldTerminalPath{selector: WatchPhantomTimeSeriesRequest_FieldPathSelectorFilter}, nil
		case "field_mask", "fieldMask", "field-mask":
			return &WatchPhantomTimeSeriesRequest_FieldTerminalPath{selector: WatchPhantomTimeSeriesRequest_FieldPathSelectorFieldMask}, nil
		case "view":
			return &WatchPhantomTimeSeriesRequest_FieldTerminalPath{selector: WatchPhantomTimeSeriesRequest_FieldPathSelectorView}, nil
		case "max_chunk_size", "maxChunkSize", "max-chunk-size":
			return &WatchPhantomTimeSeriesRequest_FieldTerminalPath{selector: WatchPhantomTimeSeriesRequest_FieldPathSelectorMaxChunkSize}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object WatchPhantomTimeSeriesRequest", fp)
}

func ParseWatchPhantomTimeSeriesRequest_FieldPath(rawField string) (WatchPhantomTimeSeriesRequest_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildWatchPhantomTimeSeriesRequest_FieldPath(fp)
}

func MustParseWatchPhantomTimeSeriesRequest_FieldPath(rawField string) WatchPhantomTimeSeriesRequest_FieldPath {
	fp, err := ParseWatchPhantomTimeSeriesRequest_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type WatchPhantomTimeSeriesRequest_FieldTerminalPath struct {
	selector WatchPhantomTimeSeriesRequest_FieldPathSelector
}

var _ WatchPhantomTimeSeriesRequest_FieldPath = (*WatchPhantomTimeSeriesRequest_FieldTerminalPath)(nil)

func (fp *WatchPhantomTimeSeriesRequest_FieldTerminalPath) Selector() WatchPhantomTimeSeriesRequest_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source WatchPhantomTimeSeriesRequest
func (fp *WatchPhantomTimeSeriesRequest_FieldTerminalPath) Get(source *WatchPhantomTimeSeriesRequest) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case WatchPhantomTimeSeriesRequest_FieldPathSelectorType:
			values = append(values, source.Type)
		case WatchPhantomTimeSeriesRequest_FieldPathSelectorParent:
			if source.Parent != nil {
				values = append(values, source.Parent)
			}
		case WatchPhantomTimeSeriesRequest_FieldPathSelectorPageSize:
			values = append(values, source.PageSize)
		case WatchPhantomTimeSeriesRequest_FieldPathSelectorPageToken:
			if source.PageToken != nil {
				values = append(values, source.PageToken)
			}
		case WatchPhantomTimeSeriesRequest_FieldPathSelectorOrderBy:
			if source.OrderBy != nil {
				values = append(values, source.OrderBy)
			}
		case WatchPhantomTimeSeriesRequest_FieldPathSelectorResumeToken:
			values = append(values, source.ResumeToken)
		case WatchPhantomTimeSeriesRequest_FieldPathSelectorStartingTime:
			if source.StartingTime != nil {
				values = append(values, source.StartingTime)
			}
		case WatchPhantomTimeSeriesRequest_FieldPathSelectorFilter:
			if source.Filter != nil {
				values = append(values, source.Filter)
			}
		case WatchPhantomTimeSeriesRequest_FieldPathSelectorFieldMask:
			if source.FieldMask != nil {
				values = append(values, source.FieldMask)
			}
		case WatchPhantomTimeSeriesRequest_FieldPathSelectorView:
			values = append(values, source.View)
		case WatchPhantomTimeSeriesRequest_FieldPathSelectorMaxChunkSize:
			values = append(values, source.MaxChunkSize)
		default:
			panic(fmt.Sprintf("Invalid selector for WatchPhantomTimeSeriesRequest: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source WatchPhantomTimeSeriesRequest
func (fp *WatchPhantomTimeSeriesRequest_FieldTerminalPath) GetSingle(source *WatchPhantomTimeSeriesRequest) (interface{}, bool) {
	switch fp.selector {
	case WatchPhantomTimeSeriesRequest_FieldPathSelectorType:
		return source.GetType(), source != nil
	case WatchPhantomTimeSeriesRequest_FieldPathSelectorParent:
		res := source.GetParent()
		return res, res != nil
	case WatchPhantomTimeSeriesRequest_FieldPathSelectorPageSize:
		return source.GetPageSize(), source != nil
	case WatchPhantomTimeSeriesRequest_FieldPathSelectorPageToken:
		res := source.GetPageToken()
		return res, res != nil
	case WatchPhantomTimeSeriesRequest_FieldPathSelectorOrderBy:
		res := source.GetOrderBy()
		return res, res != nil
	case WatchPhantomTimeSeriesRequest_FieldPathSelectorResumeToken:
		return source.GetResumeToken(), source != nil
	case WatchPhantomTimeSeriesRequest_FieldPathSelectorStartingTime:
		res := source.GetStartingTime()
		return res, res != nil
	case WatchPhantomTimeSeriesRequest_FieldPathSelectorFilter:
		res := source.GetFilter()
		return res, res != nil
	case WatchPhantomTimeSeriesRequest_FieldPathSelectorFieldMask:
		res := source.GetFieldMask()
		return res, res != nil
	case WatchPhantomTimeSeriesRequest_FieldPathSelectorView:
		return source.GetView(), source != nil
	case WatchPhantomTimeSeriesRequest_FieldPathSelectorMaxChunkSize:
		return source.GetMaxChunkSize(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for WatchPhantomTimeSeriesRequest: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *WatchPhantomTimeSeriesRequest_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case WatchPhantomTimeSeriesRequest_FieldPathSelectorType:
		return watch_type.WatchType_STATEFUL
	case WatchPhantomTimeSeriesRequest_FieldPathSelectorParent:
		return (*phantom_time_serie.ParentReference)(nil)
	case WatchPhantomTimeSeriesRequest_FieldPathSelectorPageSize:
		return int32(0)
	case WatchPhantomTimeSeriesRequest_FieldPathSelectorPageToken:
		return (*phantom_time_serie.PagerCursor)(nil)
	case WatchPhantomTimeSeriesRequest_FieldPathSelectorOrderBy:
		return (*phantom_time_serie.OrderBy)(nil)
	case WatchPhantomTimeSeriesRequest_FieldPathSelectorResumeToken:
		return ""
	case WatchPhantomTimeSeriesRequest_FieldPathSelectorStartingTime:
		return (*timestamp.Timestamp)(nil)
	case WatchPhantomTimeSeriesRequest_FieldPathSelectorFilter:
		return (*phantom_time_serie.Filter)(nil)
	case WatchPhantomTimeSeriesRequest_FieldPathSelectorFieldMask:
		return (*phantom_time_serie.PhantomTimeSerie_FieldMask)(nil)
	case WatchPhantomTimeSeriesRequest_FieldPathSelectorView:
		return view.View_UNSPECIFIED
	case WatchPhantomTimeSeriesRequest_FieldPathSelectorMaxChunkSize:
		return int32(0)
	default:
		panic(fmt.Sprintf("Invalid selector for WatchPhantomTimeSeriesRequest: %d", fp.selector))
	}
}

func (fp *WatchPhantomTimeSeriesRequest_FieldTerminalPath) ClearValue(item *WatchPhantomTimeSeriesRequest) {
	if item != nil {
		switch fp.selector {
		case WatchPhantomTimeSeriesRequest_FieldPathSelectorType:
			item.Type = watch_type.WatchType_STATEFUL
		case WatchPhantomTimeSeriesRequest_FieldPathSelectorParent:
			item.Parent = nil
		case WatchPhantomTimeSeriesRequest_FieldPathSelectorPageSize:
			item.PageSize = int32(0)
		case WatchPhantomTimeSeriesRequest_FieldPathSelectorPageToken:
			item.PageToken = nil
		case WatchPhantomTimeSeriesRequest_FieldPathSelectorOrderBy:
			item.OrderBy = nil
		case WatchPhantomTimeSeriesRequest_FieldPathSelectorResumeToken:
			item.ResumeToken = ""
		case WatchPhantomTimeSeriesRequest_FieldPathSelectorStartingTime:
			item.StartingTime = nil
		case WatchPhantomTimeSeriesRequest_FieldPathSelectorFilter:
			item.Filter = nil
		case WatchPhantomTimeSeriesRequest_FieldPathSelectorFieldMask:
			item.FieldMask = nil
		case WatchPhantomTimeSeriesRequest_FieldPathSelectorView:
			item.View = view.View_UNSPECIFIED
		case WatchPhantomTimeSeriesRequest_FieldPathSelectorMaxChunkSize:
			item.MaxChunkSize = int32(0)
		default:
			panic(fmt.Sprintf("Invalid selector for WatchPhantomTimeSeriesRequest: %d", fp.selector))
		}
	}
}

func (fp *WatchPhantomTimeSeriesRequest_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*WatchPhantomTimeSeriesRequest))
}

// IsLeaf - whether field path is holds simple value
func (fp *WatchPhantomTimeSeriesRequest_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == WatchPhantomTimeSeriesRequest_FieldPathSelectorType ||
		fp.selector == WatchPhantomTimeSeriesRequest_FieldPathSelectorParent ||
		fp.selector == WatchPhantomTimeSeriesRequest_FieldPathSelectorPageSize ||
		fp.selector == WatchPhantomTimeSeriesRequest_FieldPathSelectorPageToken ||
		fp.selector == WatchPhantomTimeSeriesRequest_FieldPathSelectorOrderBy ||
		fp.selector == WatchPhantomTimeSeriesRequest_FieldPathSelectorResumeToken ||
		fp.selector == WatchPhantomTimeSeriesRequest_FieldPathSelectorStartingTime ||
		fp.selector == WatchPhantomTimeSeriesRequest_FieldPathSelectorFilter ||
		fp.selector == WatchPhantomTimeSeriesRequest_FieldPathSelectorFieldMask ||
		fp.selector == WatchPhantomTimeSeriesRequest_FieldPathSelectorView ||
		fp.selector == WatchPhantomTimeSeriesRequest_FieldPathSelectorMaxChunkSize
}

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

func (fp *WatchPhantomTimeSeriesRequest_FieldTerminalPath) WithIValue(value interface{}) WatchPhantomTimeSeriesRequest_FieldPathValue {
	switch fp.selector {
	case WatchPhantomTimeSeriesRequest_FieldPathSelectorType:
		return &WatchPhantomTimeSeriesRequest_FieldTerminalPathValue{WatchPhantomTimeSeriesRequest_FieldTerminalPath: *fp, value: value.(watch_type.WatchType)}
	case WatchPhantomTimeSeriesRequest_FieldPathSelectorParent:
		return &WatchPhantomTimeSeriesRequest_FieldTerminalPathValue{WatchPhantomTimeSeriesRequest_FieldTerminalPath: *fp, value: value.(*phantom_time_serie.ParentReference)}
	case WatchPhantomTimeSeriesRequest_FieldPathSelectorPageSize:
		return &WatchPhantomTimeSeriesRequest_FieldTerminalPathValue{WatchPhantomTimeSeriesRequest_FieldTerminalPath: *fp, value: value.(int32)}
	case WatchPhantomTimeSeriesRequest_FieldPathSelectorPageToken:
		return &WatchPhantomTimeSeriesRequest_FieldTerminalPathValue{WatchPhantomTimeSeriesRequest_FieldTerminalPath: *fp, value: value.(*phantom_time_serie.PagerCursor)}
	case WatchPhantomTimeSeriesRequest_FieldPathSelectorOrderBy:
		return &WatchPhantomTimeSeriesRequest_FieldTerminalPathValue{WatchPhantomTimeSeriesRequest_FieldTerminalPath: *fp, value: value.(*phantom_time_serie.OrderBy)}
	case WatchPhantomTimeSeriesRequest_FieldPathSelectorResumeToken:
		return &WatchPhantomTimeSeriesRequest_FieldTerminalPathValue{WatchPhantomTimeSeriesRequest_FieldTerminalPath: *fp, value: value.(string)}
	case WatchPhantomTimeSeriesRequest_FieldPathSelectorStartingTime:
		return &WatchPhantomTimeSeriesRequest_FieldTerminalPathValue{WatchPhantomTimeSeriesRequest_FieldTerminalPath: *fp, value: value.(*timestamp.Timestamp)}
	case WatchPhantomTimeSeriesRequest_FieldPathSelectorFilter:
		return &WatchPhantomTimeSeriesRequest_FieldTerminalPathValue{WatchPhantomTimeSeriesRequest_FieldTerminalPath: *fp, value: value.(*phantom_time_serie.Filter)}
	case WatchPhantomTimeSeriesRequest_FieldPathSelectorFieldMask:
		return &WatchPhantomTimeSeriesRequest_FieldTerminalPathValue{WatchPhantomTimeSeriesRequest_FieldTerminalPath: *fp, value: value.(*phantom_time_serie.PhantomTimeSerie_FieldMask)}
	case WatchPhantomTimeSeriesRequest_FieldPathSelectorView:
		return &WatchPhantomTimeSeriesRequest_FieldTerminalPathValue{WatchPhantomTimeSeriesRequest_FieldTerminalPath: *fp, value: value.(view.View)}
	case WatchPhantomTimeSeriesRequest_FieldPathSelectorMaxChunkSize:
		return &WatchPhantomTimeSeriesRequest_FieldTerminalPathValue{WatchPhantomTimeSeriesRequest_FieldTerminalPath: *fp, value: value.(int32)}
	default:
		panic(fmt.Sprintf("Invalid selector for WatchPhantomTimeSeriesRequest: %d", fp.selector))
	}
}

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

func (fp *WatchPhantomTimeSeriesRequest_FieldTerminalPath) WithIArrayOfValues(values interface{}) WatchPhantomTimeSeriesRequest_FieldPathArrayOfValues {
	fpaov := &WatchPhantomTimeSeriesRequest_FieldTerminalPathArrayOfValues{WatchPhantomTimeSeriesRequest_FieldTerminalPath: *fp}
	switch fp.selector {
	case WatchPhantomTimeSeriesRequest_FieldPathSelectorType:
		return &WatchPhantomTimeSeriesRequest_FieldTerminalPathArrayOfValues{WatchPhantomTimeSeriesRequest_FieldTerminalPath: *fp, values: values.([]watch_type.WatchType)}
	case WatchPhantomTimeSeriesRequest_FieldPathSelectorParent:
		return &WatchPhantomTimeSeriesRequest_FieldTerminalPathArrayOfValues{WatchPhantomTimeSeriesRequest_FieldTerminalPath: *fp, values: values.([]*phantom_time_serie.ParentReference)}
	case WatchPhantomTimeSeriesRequest_FieldPathSelectorPageSize:
		return &WatchPhantomTimeSeriesRequest_FieldTerminalPathArrayOfValues{WatchPhantomTimeSeriesRequest_FieldTerminalPath: *fp, values: values.([]int32)}
	case WatchPhantomTimeSeriesRequest_FieldPathSelectorPageToken:
		return &WatchPhantomTimeSeriesRequest_FieldTerminalPathArrayOfValues{WatchPhantomTimeSeriesRequest_FieldTerminalPath: *fp, values: values.([]*phantom_time_serie.PagerCursor)}
	case WatchPhantomTimeSeriesRequest_FieldPathSelectorOrderBy:
		return &WatchPhantomTimeSeriesRequest_FieldTerminalPathArrayOfValues{WatchPhantomTimeSeriesRequest_FieldTerminalPath: *fp, values: values.([]*phantom_time_serie.OrderBy)}
	case WatchPhantomTimeSeriesRequest_FieldPathSelectorResumeToken:
		return &WatchPhantomTimeSeriesRequest_FieldTerminalPathArrayOfValues{WatchPhantomTimeSeriesRequest_FieldTerminalPath: *fp, values: values.([]string)}
	case WatchPhantomTimeSeriesRequest_FieldPathSelectorStartingTime:
		return &WatchPhantomTimeSeriesRequest_FieldTerminalPathArrayOfValues{WatchPhantomTimeSeriesRequest_FieldTerminalPath: *fp, values: values.([]*timestamp.Timestamp)}
	case WatchPhantomTimeSeriesRequest_FieldPathSelectorFilter:
		return &WatchPhantomTimeSeriesRequest_FieldTerminalPathArrayOfValues{WatchPhantomTimeSeriesRequest_FieldTerminalPath: *fp, values: values.([]*phantom_time_serie.Filter)}
	case WatchPhantomTimeSeriesRequest_FieldPathSelectorFieldMask:
		return &WatchPhantomTimeSeriesRequest_FieldTerminalPathArrayOfValues{WatchPhantomTimeSeriesRequest_FieldTerminalPath: *fp, values: values.([]*phantom_time_serie.PhantomTimeSerie_FieldMask)}
	case WatchPhantomTimeSeriesRequest_FieldPathSelectorView:
		return &WatchPhantomTimeSeriesRequest_FieldTerminalPathArrayOfValues{WatchPhantomTimeSeriesRequest_FieldTerminalPath: *fp, values: values.([]view.View)}
	case WatchPhantomTimeSeriesRequest_FieldPathSelectorMaxChunkSize:
		return &WatchPhantomTimeSeriesRequest_FieldTerminalPathArrayOfValues{WatchPhantomTimeSeriesRequest_FieldTerminalPath: *fp, values: values.([]int32)}
	default:
		panic(fmt.Sprintf("Invalid selector for WatchPhantomTimeSeriesRequest: %d", fp.selector))
	}
	return fpaov
}

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

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

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

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

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

func MustParseWatchPhantomTimeSeriesRequest_FieldPathValue(pathStr, valueStr string) WatchPhantomTimeSeriesRequest_FieldPathValue {
	fpv, err := ParseWatchPhantomTimeSeriesRequest_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type WatchPhantomTimeSeriesRequest_FieldTerminalPathValue struct {
	WatchPhantomTimeSeriesRequest_FieldTerminalPath
	value interface{}
}

var _ WatchPhantomTimeSeriesRequest_FieldPathValue = (*WatchPhantomTimeSeriesRequest_FieldTerminalPathValue)(nil)

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

// SetTo stores value for selected field for object WatchPhantomTimeSeriesRequest
func (fpv *WatchPhantomTimeSeriesRequest_FieldTerminalPathValue) SetTo(target **WatchPhantomTimeSeriesRequest) {
	if *target == nil {
		*target = new(WatchPhantomTimeSeriesRequest)
	}
	switch fpv.selector {
	case WatchPhantomTimeSeriesRequest_FieldPathSelectorType:
		(*target).Type = fpv.value.(watch_type.WatchType)
	case WatchPhantomTimeSeriesRequest_FieldPathSelectorParent:
		(*target).Parent = fpv.value.(*phantom_time_serie.ParentReference)
	case WatchPhantomTimeSeriesRequest_FieldPathSelectorPageSize:
		(*target).PageSize = fpv.value.(int32)
	case WatchPhantomTimeSeriesRequest_FieldPathSelectorPageToken:
		(*target).PageToken = fpv.value.(*phantom_time_serie.PagerCursor)
	case WatchPhantomTimeSeriesRequest_FieldPathSelectorOrderBy:
		(*target).OrderBy = fpv.value.(*phantom_time_serie.OrderBy)
	case WatchPhantomTimeSeriesRequest_FieldPathSelectorResumeToken:
		(*target).ResumeToken = fpv.value.(string)
	case WatchPhantomTimeSeriesRequest_FieldPathSelectorStartingTime:
		(*target).StartingTime = fpv.value.(*timestamp.Timestamp)
	case WatchPhantomTimeSeriesRequest_FieldPathSelectorFilter:
		(*target).Filter = fpv.value.(*phantom_time_serie.Filter)
	case WatchPhantomTimeSeriesRequest_FieldPathSelectorFieldMask:
		(*target).FieldMask = fpv.value.(*phantom_time_serie.PhantomTimeSerie_FieldMask)
	case WatchPhantomTimeSeriesRequest_FieldPathSelectorView:
		(*target).View = fpv.value.(view.View)
	case WatchPhantomTimeSeriesRequest_FieldPathSelectorMaxChunkSize:
		(*target).MaxChunkSize = fpv.value.(int32)
	default:
		panic(fmt.Sprintf("Invalid selector for WatchPhantomTimeSeriesRequest: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'WatchPhantomTimeSeriesRequest_FieldTerminalPathValue' with the value under path in 'WatchPhantomTimeSeriesRequest'.
func (fpv *WatchPhantomTimeSeriesRequest_FieldTerminalPathValue) CompareWith(source *WatchPhantomTimeSeriesRequest) (int, bool) {
	switch fpv.selector {
	case WatchPhantomTimeSeriesRequest_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 WatchPhantomTimeSeriesRequest_FieldPathSelectorParent:
		leftValue := fpv.value.(*phantom_time_serie.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 WatchPhantomTimeSeriesRequest_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 WatchPhantomTimeSeriesRequest_FieldPathSelectorPageToken:
		return 0, false
	case WatchPhantomTimeSeriesRequest_FieldPathSelectorOrderBy:
		return 0, false
	case WatchPhantomTimeSeriesRequest_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 WatchPhantomTimeSeriesRequest_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 WatchPhantomTimeSeriesRequest_FieldPathSelectorFilter:
		return 0, false
	case WatchPhantomTimeSeriesRequest_FieldPathSelectorFieldMask:
		return 0, false
	case WatchPhantomTimeSeriesRequest_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 WatchPhantomTimeSeriesRequest_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 WatchPhantomTimeSeriesRequest: %d", fpv.selector))
	}
}

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

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

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

func MustParseWatchPhantomTimeSeriesRequest_FieldPathArrayItemValue(pathStr, valueStr string) WatchPhantomTimeSeriesRequest_FieldPathArrayItemValue {
	fpaiv, err := ParseWatchPhantomTimeSeriesRequest_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type WatchPhantomTimeSeriesRequest_FieldTerminalPathArrayItemValue struct {
	WatchPhantomTimeSeriesRequest_FieldTerminalPath
	value interface{}
}

var _ WatchPhantomTimeSeriesRequest_FieldPathArrayItemValue = (*WatchPhantomTimeSeriesRequest_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *WatchPhantomTimeSeriesRequest_FieldTerminalPathArrayItemValue) GetSingle(source *WatchPhantomTimeSeriesRequest) (interface{}, bool) {
	return nil, false
}

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

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

// WatchPhantomTimeSeriesRequest_FieldPathArrayOfValues allows storing slice of values for WatchPhantomTimeSeriesRequest fields according to their type
type WatchPhantomTimeSeriesRequest_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	WatchPhantomTimeSeriesRequest_FieldPath
}

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

func MustParseWatchPhantomTimeSeriesRequest_FieldPathArrayOfValues(pathStr, valuesStr string) WatchPhantomTimeSeriesRequest_FieldPathArrayOfValues {
	fpaov, err := ParseWatchPhantomTimeSeriesRequest_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type WatchPhantomTimeSeriesRequest_FieldTerminalPathArrayOfValues struct {
	WatchPhantomTimeSeriesRequest_FieldTerminalPath
	values interface{}
}

var _ WatchPhantomTimeSeriesRequest_FieldPathArrayOfValues = (*WatchPhantomTimeSeriesRequest_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *WatchPhantomTimeSeriesRequest_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case WatchPhantomTimeSeriesRequest_FieldPathSelectorType:
		for _, v := range fpaov.values.([]watch_type.WatchType) {
			values = append(values, v)
		}
	case WatchPhantomTimeSeriesRequest_FieldPathSelectorParent:
		for _, v := range fpaov.values.([]*phantom_time_serie.ParentReference) {
			values = append(values, v)
		}
	case WatchPhantomTimeSeriesRequest_FieldPathSelectorPageSize:
		for _, v := range fpaov.values.([]int32) {
			values = append(values, v)
		}
	case WatchPhantomTimeSeriesRequest_FieldPathSelectorPageToken:
		for _, v := range fpaov.values.([]*phantom_time_serie.PagerCursor) {
			values = append(values, v)
		}
	case WatchPhantomTimeSeriesRequest_FieldPathSelectorOrderBy:
		for _, v := range fpaov.values.([]*phantom_time_serie.OrderBy) {
			values = append(values, v)
		}
	case WatchPhantomTimeSeriesRequest_FieldPathSelectorResumeToken:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case WatchPhantomTimeSeriesRequest_FieldPathSelectorStartingTime:
		for _, v := range fpaov.values.([]*timestamp.Timestamp) {
			values = append(values, v)
		}
	case WatchPhantomTimeSeriesRequest_FieldPathSelectorFilter:
		for _, v := range fpaov.values.([]*phantom_time_serie.Filter) {
			values = append(values, v)
		}
	case WatchPhantomTimeSeriesRequest_FieldPathSelectorFieldMask:
		for _, v := range fpaov.values.([]*phantom_time_serie.PhantomTimeSerie_FieldMask) {
			values = append(values, v)
		}
	case WatchPhantomTimeSeriesRequest_FieldPathSelectorView:
		for _, v := range fpaov.values.([]view.View) {
			values = append(values, v)
		}
	case WatchPhantomTimeSeriesRequest_FieldPathSelectorMaxChunkSize:
		for _, v := range fpaov.values.([]int32) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *WatchPhantomTimeSeriesRequest_FieldTerminalPathArrayOfValues) AsTypeArrayOfValues() ([]watch_type.WatchType, bool) {
	res, ok := fpaov.values.([]watch_type.WatchType)
	return res, ok
}
func (fpaov *WatchPhantomTimeSeriesRequest_FieldTerminalPathArrayOfValues) AsParentArrayOfValues() ([]*phantom_time_serie.ParentReference, bool) {
	res, ok := fpaov.values.([]*phantom_time_serie.ParentReference)
	return res, ok
}
func (fpaov *WatchPhantomTimeSeriesRequest_FieldTerminalPathArrayOfValues) AsPageSizeArrayOfValues() ([]int32, bool) {
	res, ok := fpaov.values.([]int32)
	return res, ok
}
func (fpaov *WatchPhantomTimeSeriesRequest_FieldTerminalPathArrayOfValues) AsPageTokenArrayOfValues() ([]*phantom_time_serie.PagerCursor, bool) {
	res, ok := fpaov.values.([]*phantom_time_serie.PagerCursor)
	return res, ok
}
func (fpaov *WatchPhantomTimeSeriesRequest_FieldTerminalPathArrayOfValues) AsOrderByArrayOfValues() ([]*phantom_time_serie.OrderBy, bool) {
	res, ok := fpaov.values.([]*phantom_time_serie.OrderBy)
	return res, ok
}
func (fpaov *WatchPhantomTimeSeriesRequest_FieldTerminalPathArrayOfValues) AsResumeTokenArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *WatchPhantomTimeSeriesRequest_FieldTerminalPathArrayOfValues) AsStartingTimeArrayOfValues() ([]*timestamp.Timestamp, bool) {
	res, ok := fpaov.values.([]*timestamp.Timestamp)
	return res, ok
}
func (fpaov *WatchPhantomTimeSeriesRequest_FieldTerminalPathArrayOfValues) AsFilterArrayOfValues() ([]*phantom_time_serie.Filter, bool) {
	res, ok := fpaov.values.([]*phantom_time_serie.Filter)
	return res, ok
}
func (fpaov *WatchPhantomTimeSeriesRequest_FieldTerminalPathArrayOfValues) AsFieldMaskArrayOfValues() ([]*phantom_time_serie.PhantomTimeSerie_FieldMask, bool) {
	res, ok := fpaov.values.([]*phantom_time_serie.PhantomTimeSerie_FieldMask)
	return res, ok
}
func (fpaov *WatchPhantomTimeSeriesRequest_FieldTerminalPathArrayOfValues) AsViewArrayOfValues() ([]view.View, bool) {
	res, ok := fpaov.values.([]view.View)
	return res, ok
}
func (fpaov *WatchPhantomTimeSeriesRequest_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 WatchPhantomTimeSeriesResponse_FieldPath interface {
	gotenobject.FieldPath
	Selector() WatchPhantomTimeSeriesResponse_FieldPathSelector
	Get(source *WatchPhantomTimeSeriesResponse) []interface{}
	GetSingle(source *WatchPhantomTimeSeriesResponse) (interface{}, bool)
	ClearValue(item *WatchPhantomTimeSeriesResponse)

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

type WatchPhantomTimeSeriesResponse_FieldPathSelector int32

const (
	WatchPhantomTimeSeriesResponse_FieldPathSelectorPhantomTimeSerieChanges WatchPhantomTimeSeriesResponse_FieldPathSelector = 0
	WatchPhantomTimeSeriesResponse_FieldPathSelectorIsCurrent               WatchPhantomTimeSeriesResponse_FieldPathSelector = 1
	WatchPhantomTimeSeriesResponse_FieldPathSelectorPageTokenChange         WatchPhantomTimeSeriesResponse_FieldPathSelector = 2
	WatchPhantomTimeSeriesResponse_FieldPathSelectorResumeToken             WatchPhantomTimeSeriesResponse_FieldPathSelector = 3
	WatchPhantomTimeSeriesResponse_FieldPathSelectorSnapshotSize            WatchPhantomTimeSeriesResponse_FieldPathSelector = 4
	WatchPhantomTimeSeriesResponse_FieldPathSelectorIsSoftReset             WatchPhantomTimeSeriesResponse_FieldPathSelector = 5
	WatchPhantomTimeSeriesResponse_FieldPathSelectorIsHardReset             WatchPhantomTimeSeriesResponse_FieldPathSelector = 6
)

func (s WatchPhantomTimeSeriesResponse_FieldPathSelector) String() string {
	switch s {
	case WatchPhantomTimeSeriesResponse_FieldPathSelectorPhantomTimeSerieChanges:
		return "phantom_time_serie_changes"
	case WatchPhantomTimeSeriesResponse_FieldPathSelectorIsCurrent:
		return "is_current"
	case WatchPhantomTimeSeriesResponse_FieldPathSelectorPageTokenChange:
		return "page_token_change"
	case WatchPhantomTimeSeriesResponse_FieldPathSelectorResumeToken:
		return "resume_token"
	case WatchPhantomTimeSeriesResponse_FieldPathSelectorSnapshotSize:
		return "snapshot_size"
	case WatchPhantomTimeSeriesResponse_FieldPathSelectorIsSoftReset:
		return "is_soft_reset"
	case WatchPhantomTimeSeriesResponse_FieldPathSelectorIsHardReset:
		return "is_hard_reset"
	default:
		panic(fmt.Sprintf("Invalid selector for WatchPhantomTimeSeriesResponse: %d", s))
	}
}

func BuildWatchPhantomTimeSeriesResponse_FieldPath(fp gotenobject.RawFieldPath) (WatchPhantomTimeSeriesResponse_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object WatchPhantomTimeSeriesResponse")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "phantom_time_serie_changes", "phantomTimeSerieChanges", "phantom-time-serie-changes":
			return &WatchPhantomTimeSeriesResponse_FieldTerminalPath{selector: WatchPhantomTimeSeriesResponse_FieldPathSelectorPhantomTimeSerieChanges}, nil
		case "is_current", "isCurrent", "is-current":
			return &WatchPhantomTimeSeriesResponse_FieldTerminalPath{selector: WatchPhantomTimeSeriesResponse_FieldPathSelectorIsCurrent}, nil
		case "page_token_change", "pageTokenChange", "page-token-change":
			return &WatchPhantomTimeSeriesResponse_FieldTerminalPath{selector: WatchPhantomTimeSeriesResponse_FieldPathSelectorPageTokenChange}, nil
		case "resume_token", "resumeToken", "resume-token":
			return &WatchPhantomTimeSeriesResponse_FieldTerminalPath{selector: WatchPhantomTimeSeriesResponse_FieldPathSelectorResumeToken}, nil
		case "snapshot_size", "snapshotSize", "snapshot-size":
			return &WatchPhantomTimeSeriesResponse_FieldTerminalPath{selector: WatchPhantomTimeSeriesResponse_FieldPathSelectorSnapshotSize}, nil
		case "is_soft_reset", "isSoftReset", "is-soft-reset":
			return &WatchPhantomTimeSeriesResponse_FieldTerminalPath{selector: WatchPhantomTimeSeriesResponse_FieldPathSelectorIsSoftReset}, nil
		case "is_hard_reset", "isHardReset", "is-hard-reset":
			return &WatchPhantomTimeSeriesResponse_FieldTerminalPath{selector: WatchPhantomTimeSeriesResponse_FieldPathSelectorIsHardReset}, nil
		}
	} else {
		switch fp[0] {
		case "page_token_change", "pageTokenChange", "page-token-change":
			if subpath, err := BuildWatchPhantomTimeSeriesResponsePageTokenChange_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &WatchPhantomTimeSeriesResponse_FieldSubPath{selector: WatchPhantomTimeSeriesResponse_FieldPathSelectorPageTokenChange, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object WatchPhantomTimeSeriesResponse", fp)
}

func ParseWatchPhantomTimeSeriesResponse_FieldPath(rawField string) (WatchPhantomTimeSeriesResponse_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildWatchPhantomTimeSeriesResponse_FieldPath(fp)
}

func MustParseWatchPhantomTimeSeriesResponse_FieldPath(rawField string) WatchPhantomTimeSeriesResponse_FieldPath {
	fp, err := ParseWatchPhantomTimeSeriesResponse_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type WatchPhantomTimeSeriesResponse_FieldTerminalPath struct {
	selector WatchPhantomTimeSeriesResponse_FieldPathSelector
}

var _ WatchPhantomTimeSeriesResponse_FieldPath = (*WatchPhantomTimeSeriesResponse_FieldTerminalPath)(nil)

func (fp *WatchPhantomTimeSeriesResponse_FieldTerminalPath) Selector() WatchPhantomTimeSeriesResponse_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source WatchPhantomTimeSeriesResponse
func (fp *WatchPhantomTimeSeriesResponse_FieldTerminalPath) Get(source *WatchPhantomTimeSeriesResponse) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case WatchPhantomTimeSeriesResponse_FieldPathSelectorPhantomTimeSerieChanges:
			for _, value := range source.GetPhantomTimeSerieChanges() {
				values = append(values, value)
			}
		case WatchPhantomTimeSeriesResponse_FieldPathSelectorIsCurrent:
			values = append(values, source.IsCurrent)
		case WatchPhantomTimeSeriesResponse_FieldPathSelectorPageTokenChange:
			if source.PageTokenChange != nil {
				values = append(values, source.PageTokenChange)
			}
		case WatchPhantomTimeSeriesResponse_FieldPathSelectorResumeToken:
			values = append(values, source.ResumeToken)
		case WatchPhantomTimeSeriesResponse_FieldPathSelectorSnapshotSize:
			values = append(values, source.SnapshotSize)
		case WatchPhantomTimeSeriesResponse_FieldPathSelectorIsSoftReset:
			values = append(values, source.IsSoftReset)
		case WatchPhantomTimeSeriesResponse_FieldPathSelectorIsHardReset:
			values = append(values, source.IsHardReset)
		default:
			panic(fmt.Sprintf("Invalid selector for WatchPhantomTimeSeriesResponse: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source WatchPhantomTimeSeriesResponse
func (fp *WatchPhantomTimeSeriesResponse_FieldTerminalPath) GetSingle(source *WatchPhantomTimeSeriesResponse) (interface{}, bool) {
	switch fp.selector {
	case WatchPhantomTimeSeriesResponse_FieldPathSelectorPhantomTimeSerieChanges:
		res := source.GetPhantomTimeSerieChanges()
		return res, res != nil
	case WatchPhantomTimeSeriesResponse_FieldPathSelectorIsCurrent:
		return source.GetIsCurrent(), source != nil
	case WatchPhantomTimeSeriesResponse_FieldPathSelectorPageTokenChange:
		res := source.GetPageTokenChange()
		return res, res != nil
	case WatchPhantomTimeSeriesResponse_FieldPathSelectorResumeToken:
		return source.GetResumeToken(), source != nil
	case WatchPhantomTimeSeriesResponse_FieldPathSelectorSnapshotSize:
		return source.GetSnapshotSize(), source != nil
	case WatchPhantomTimeSeriesResponse_FieldPathSelectorIsSoftReset:
		return source.GetIsSoftReset(), source != nil
	case WatchPhantomTimeSeriesResponse_FieldPathSelectorIsHardReset:
		return source.GetIsHardReset(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for WatchPhantomTimeSeriesResponse: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *WatchPhantomTimeSeriesResponse_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case WatchPhantomTimeSeriesResponse_FieldPathSelectorPhantomTimeSerieChanges:
		return ([]*phantom_time_serie.PhantomTimeSerieChange)(nil)
	case WatchPhantomTimeSeriesResponse_FieldPathSelectorIsCurrent:
		return false
	case WatchPhantomTimeSeriesResponse_FieldPathSelectorPageTokenChange:
		return (*WatchPhantomTimeSeriesResponse_PageTokenChange)(nil)
	case WatchPhantomTimeSeriesResponse_FieldPathSelectorResumeToken:
		return ""
	case WatchPhantomTimeSeriesResponse_FieldPathSelectorSnapshotSize:
		return int64(0)
	case WatchPhantomTimeSeriesResponse_FieldPathSelectorIsSoftReset:
		return false
	case WatchPhantomTimeSeriesResponse_FieldPathSelectorIsHardReset:
		return false
	default:
		panic(fmt.Sprintf("Invalid selector for WatchPhantomTimeSeriesResponse: %d", fp.selector))
	}
}

func (fp *WatchPhantomTimeSeriesResponse_FieldTerminalPath) ClearValue(item *WatchPhantomTimeSeriesResponse) {
	if item != nil {
		switch fp.selector {
		case WatchPhantomTimeSeriesResponse_FieldPathSelectorPhantomTimeSerieChanges:
			item.PhantomTimeSerieChanges = nil
		case WatchPhantomTimeSeriesResponse_FieldPathSelectorIsCurrent:
			item.IsCurrent = false
		case WatchPhantomTimeSeriesResponse_FieldPathSelectorPageTokenChange:
			item.PageTokenChange = nil
		case WatchPhantomTimeSeriesResponse_FieldPathSelectorResumeToken:
			item.ResumeToken = ""
		case WatchPhantomTimeSeriesResponse_FieldPathSelectorSnapshotSize:
			item.SnapshotSize = int64(0)
		case WatchPhantomTimeSeriesResponse_FieldPathSelectorIsSoftReset:
			item.IsSoftReset = false
		case WatchPhantomTimeSeriesResponse_FieldPathSelectorIsHardReset:
			item.IsHardReset = false
		default:
			panic(fmt.Sprintf("Invalid selector for WatchPhantomTimeSeriesResponse: %d", fp.selector))
		}
	}
}

func (fp *WatchPhantomTimeSeriesResponse_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*WatchPhantomTimeSeriesResponse))
}

// IsLeaf - whether field path is holds simple value
func (fp *WatchPhantomTimeSeriesResponse_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == WatchPhantomTimeSeriesResponse_FieldPathSelectorPhantomTimeSerieChanges ||
		fp.selector == WatchPhantomTimeSeriesResponse_FieldPathSelectorIsCurrent ||
		fp.selector == WatchPhantomTimeSeriesResponse_FieldPathSelectorResumeToken ||
		fp.selector == WatchPhantomTimeSeriesResponse_FieldPathSelectorSnapshotSize ||
		fp.selector == WatchPhantomTimeSeriesResponse_FieldPathSelectorIsSoftReset ||
		fp.selector == WatchPhantomTimeSeriesResponse_FieldPathSelectorIsHardReset
}

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

func (fp *WatchPhantomTimeSeriesResponse_FieldTerminalPath) WithIValue(value interface{}) WatchPhantomTimeSeriesResponse_FieldPathValue {
	switch fp.selector {
	case WatchPhantomTimeSeriesResponse_FieldPathSelectorPhantomTimeSerieChanges:
		return &WatchPhantomTimeSeriesResponse_FieldTerminalPathValue{WatchPhantomTimeSeriesResponse_FieldTerminalPath: *fp, value: value.([]*phantom_time_serie.PhantomTimeSerieChange)}
	case WatchPhantomTimeSeriesResponse_FieldPathSelectorIsCurrent:
		return &WatchPhantomTimeSeriesResponse_FieldTerminalPathValue{WatchPhantomTimeSeriesResponse_FieldTerminalPath: *fp, value: value.(bool)}
	case WatchPhantomTimeSeriesResponse_FieldPathSelectorPageTokenChange:
		return &WatchPhantomTimeSeriesResponse_FieldTerminalPathValue{WatchPhantomTimeSeriesResponse_FieldTerminalPath: *fp, value: value.(*WatchPhantomTimeSeriesResponse_PageTokenChange)}
	case WatchPhantomTimeSeriesResponse_FieldPathSelectorResumeToken:
		return &WatchPhantomTimeSeriesResponse_FieldTerminalPathValue{WatchPhantomTimeSeriesResponse_FieldTerminalPath: *fp, value: value.(string)}
	case WatchPhantomTimeSeriesResponse_FieldPathSelectorSnapshotSize:
		return &WatchPhantomTimeSeriesResponse_FieldTerminalPathValue{WatchPhantomTimeSeriesResponse_FieldTerminalPath: *fp, value: value.(int64)}
	case WatchPhantomTimeSeriesResponse_FieldPathSelectorIsSoftReset:
		return &WatchPhantomTimeSeriesResponse_FieldTerminalPathValue{WatchPhantomTimeSeriesResponse_FieldTerminalPath: *fp, value: value.(bool)}
	case WatchPhantomTimeSeriesResponse_FieldPathSelectorIsHardReset:
		return &WatchPhantomTimeSeriesResponse_FieldTerminalPathValue{WatchPhantomTimeSeriesResponse_FieldTerminalPath: *fp, value: value.(bool)}
	default:
		panic(fmt.Sprintf("Invalid selector for WatchPhantomTimeSeriesResponse: %d", fp.selector))
	}
}

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

func (fp *WatchPhantomTimeSeriesResponse_FieldTerminalPath) WithIArrayOfValues(values interface{}) WatchPhantomTimeSeriesResponse_FieldPathArrayOfValues {
	fpaov := &WatchPhantomTimeSeriesResponse_FieldTerminalPathArrayOfValues{WatchPhantomTimeSeriesResponse_FieldTerminalPath: *fp}
	switch fp.selector {
	case WatchPhantomTimeSeriesResponse_FieldPathSelectorPhantomTimeSerieChanges:
		return &WatchPhantomTimeSeriesResponse_FieldTerminalPathArrayOfValues{WatchPhantomTimeSeriesResponse_FieldTerminalPath: *fp, values: values.([][]*phantom_time_serie.PhantomTimeSerieChange)}
	case WatchPhantomTimeSeriesResponse_FieldPathSelectorIsCurrent:
		return &WatchPhantomTimeSeriesResponse_FieldTerminalPathArrayOfValues{WatchPhantomTimeSeriesResponse_FieldTerminalPath: *fp, values: values.([]bool)}
	case WatchPhantomTimeSeriesResponse_FieldPathSelectorPageTokenChange:
		return &WatchPhantomTimeSeriesResponse_FieldTerminalPathArrayOfValues{WatchPhantomTimeSeriesResponse_FieldTerminalPath: *fp, values: values.([]*WatchPhantomTimeSeriesResponse_PageTokenChange)}
	case WatchPhantomTimeSeriesResponse_FieldPathSelectorResumeToken:
		return &WatchPhantomTimeSeriesResponse_FieldTerminalPathArrayOfValues{WatchPhantomTimeSeriesResponse_FieldTerminalPath: *fp, values: values.([]string)}
	case WatchPhantomTimeSeriesResponse_FieldPathSelectorSnapshotSize:
		return &WatchPhantomTimeSeriesResponse_FieldTerminalPathArrayOfValues{WatchPhantomTimeSeriesResponse_FieldTerminalPath: *fp, values: values.([]int64)}
	case WatchPhantomTimeSeriesResponse_FieldPathSelectorIsSoftReset:
		return &WatchPhantomTimeSeriesResponse_FieldTerminalPathArrayOfValues{WatchPhantomTimeSeriesResponse_FieldTerminalPath: *fp, values: values.([]bool)}
	case WatchPhantomTimeSeriesResponse_FieldPathSelectorIsHardReset:
		return &WatchPhantomTimeSeriesResponse_FieldTerminalPathArrayOfValues{WatchPhantomTimeSeriesResponse_FieldTerminalPath: *fp, values: values.([]bool)}
	default:
		panic(fmt.Sprintf("Invalid selector for WatchPhantomTimeSeriesResponse: %d", fp.selector))
	}
	return fpaov
}

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

func (fp *WatchPhantomTimeSeriesResponse_FieldTerminalPath) WithIArrayItemValue(value interface{}) WatchPhantomTimeSeriesResponse_FieldPathArrayItemValue {
	switch fp.selector {
	case WatchPhantomTimeSeriesResponse_FieldPathSelectorPhantomTimeSerieChanges:
		return &WatchPhantomTimeSeriesResponse_FieldTerminalPathArrayItemValue{WatchPhantomTimeSeriesResponse_FieldTerminalPath: *fp, value: value.(*phantom_time_serie.PhantomTimeSerieChange)}
	default:
		panic(fmt.Sprintf("Invalid selector for WatchPhantomTimeSeriesResponse: %d", fp.selector))
	}
}

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

type WatchPhantomTimeSeriesResponse_FieldSubPath struct {
	selector WatchPhantomTimeSeriesResponse_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ WatchPhantomTimeSeriesResponse_FieldPath = (*WatchPhantomTimeSeriesResponse_FieldSubPath)(nil)

func (fps *WatchPhantomTimeSeriesResponse_FieldSubPath) Selector() WatchPhantomTimeSeriesResponse_FieldPathSelector {
	return fps.selector
}
func (fps *WatchPhantomTimeSeriesResponse_FieldSubPath) AsPageTokenChangeSubPath() (WatchPhantomTimeSeriesResponsePageTokenChange_FieldPath, bool) {
	res, ok := fps.subPath.(WatchPhantomTimeSeriesResponsePageTokenChange_FieldPath)
	return res, ok
}

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

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

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

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

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

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

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

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

func (fps *WatchPhantomTimeSeriesResponse_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*WatchPhantomTimeSeriesResponse))
}

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

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

func (fps *WatchPhantomTimeSeriesResponse_FieldSubPath) WithIValue(value interface{}) WatchPhantomTimeSeriesResponse_FieldPathValue {
	return &WatchPhantomTimeSeriesResponse_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *WatchPhantomTimeSeriesResponse_FieldSubPath) WithIArrayOfValues(values interface{}) WatchPhantomTimeSeriesResponse_FieldPathArrayOfValues {
	return &WatchPhantomTimeSeriesResponse_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *WatchPhantomTimeSeriesResponse_FieldSubPath) WithIArrayItemValue(value interface{}) WatchPhantomTimeSeriesResponse_FieldPathArrayItemValue {
	return &WatchPhantomTimeSeriesResponse_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

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

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

func MustParseWatchPhantomTimeSeriesResponse_FieldPathValue(pathStr, valueStr string) WatchPhantomTimeSeriesResponse_FieldPathValue {
	fpv, err := ParseWatchPhantomTimeSeriesResponse_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type WatchPhantomTimeSeriesResponse_FieldTerminalPathValue struct {
	WatchPhantomTimeSeriesResponse_FieldTerminalPath
	value interface{}
}

var _ WatchPhantomTimeSeriesResponse_FieldPathValue = (*WatchPhantomTimeSeriesResponse_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'WatchPhantomTimeSeriesResponse' as interface{}
func (fpv *WatchPhantomTimeSeriesResponse_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *WatchPhantomTimeSeriesResponse_FieldTerminalPathValue) AsPhantomTimeSerieChangesValue() ([]*phantom_time_serie.PhantomTimeSerieChange, bool) {
	res, ok := fpv.value.([]*phantom_time_serie.PhantomTimeSerieChange)
	return res, ok
}
func (fpv *WatchPhantomTimeSeriesResponse_FieldTerminalPathValue) AsIsCurrentValue() (bool, bool) {
	res, ok := fpv.value.(bool)
	return res, ok
}
func (fpv *WatchPhantomTimeSeriesResponse_FieldTerminalPathValue) AsPageTokenChangeValue() (*WatchPhantomTimeSeriesResponse_PageTokenChange, bool) {
	res, ok := fpv.value.(*WatchPhantomTimeSeriesResponse_PageTokenChange)
	return res, ok
}
func (fpv *WatchPhantomTimeSeriesResponse_FieldTerminalPathValue) AsResumeTokenValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *WatchPhantomTimeSeriesResponse_FieldTerminalPathValue) AsSnapshotSizeValue() (int64, bool) {
	res, ok := fpv.value.(int64)
	return res, ok
}
func (fpv *WatchPhantomTimeSeriesResponse_FieldTerminalPathValue) AsIsSoftResetValue() (bool, bool) {
	res, ok := fpv.value.(bool)
	return res, ok
}
func (fpv *WatchPhantomTimeSeriesResponse_FieldTerminalPathValue) AsIsHardResetValue() (bool, bool) {
	res, ok := fpv.value.(bool)
	return res, ok
}

// SetTo stores value for selected field for object WatchPhantomTimeSeriesResponse
func (fpv *WatchPhantomTimeSeriesResponse_FieldTerminalPathValue) SetTo(target **WatchPhantomTimeSeriesResponse) {
	if *target == nil {
		*target = new(WatchPhantomTimeSeriesResponse)
	}
	switch fpv.selector {
	case WatchPhantomTimeSeriesResponse_FieldPathSelectorPhantomTimeSerieChanges:
		(*target).PhantomTimeSerieChanges = fpv.value.([]*phantom_time_serie.PhantomTimeSerieChange)
	case WatchPhantomTimeSeriesResponse_FieldPathSelectorIsCurrent:
		(*target).IsCurrent = fpv.value.(bool)
	case WatchPhantomTimeSeriesResponse_FieldPathSelectorPageTokenChange:
		(*target).PageTokenChange = fpv.value.(*WatchPhantomTimeSeriesResponse_PageTokenChange)
	case WatchPhantomTimeSeriesResponse_FieldPathSelectorResumeToken:
		(*target).ResumeToken = fpv.value.(string)
	case WatchPhantomTimeSeriesResponse_FieldPathSelectorSnapshotSize:
		(*target).SnapshotSize = fpv.value.(int64)
	case WatchPhantomTimeSeriesResponse_FieldPathSelectorIsSoftReset:
		(*target).IsSoftReset = fpv.value.(bool)
	case WatchPhantomTimeSeriesResponse_FieldPathSelectorIsHardReset:
		(*target).IsHardReset = fpv.value.(bool)
	default:
		panic(fmt.Sprintf("Invalid selector for WatchPhantomTimeSeriesResponse: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'WatchPhantomTimeSeriesResponse_FieldTerminalPathValue' with the value under path in 'WatchPhantomTimeSeriesResponse'.
func (fpv *WatchPhantomTimeSeriesResponse_FieldTerminalPathValue) CompareWith(source *WatchPhantomTimeSeriesResponse) (int, bool) {
	switch fpv.selector {
	case WatchPhantomTimeSeriesResponse_FieldPathSelectorPhantomTimeSerieChanges:
		return 0, false
	case WatchPhantomTimeSeriesResponse_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 WatchPhantomTimeSeriesResponse_FieldPathSelectorPageTokenChange:
		return 0, false
	case WatchPhantomTimeSeriesResponse_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 WatchPhantomTimeSeriesResponse_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 WatchPhantomTimeSeriesResponse_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 WatchPhantomTimeSeriesResponse_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 WatchPhantomTimeSeriesResponse: %d", fpv.selector))
	}
}

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

type WatchPhantomTimeSeriesResponse_FieldSubPathValue struct {
	WatchPhantomTimeSeriesResponse_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ WatchPhantomTimeSeriesResponse_FieldPathValue = (*WatchPhantomTimeSeriesResponse_FieldSubPathValue)(nil)

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

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

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

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

func (fpvs *WatchPhantomTimeSeriesResponse_FieldSubPathValue) CompareWith(source *WatchPhantomTimeSeriesResponse) (int, bool) {
	switch fpvs.Selector() {
	case WatchPhantomTimeSeriesResponse_FieldPathSelectorPageTokenChange:
		return fpvs.subPathValue.(WatchPhantomTimeSeriesResponsePageTokenChange_FieldPathValue).CompareWith(source.GetPageTokenChange())
	default:
		panic(fmt.Sprintf("Invalid selector for WatchPhantomTimeSeriesResponse: %d", fpvs.Selector()))
	}
}

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

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

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

func MustParseWatchPhantomTimeSeriesResponse_FieldPathArrayItemValue(pathStr, valueStr string) WatchPhantomTimeSeriesResponse_FieldPathArrayItemValue {
	fpaiv, err := ParseWatchPhantomTimeSeriesResponse_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type WatchPhantomTimeSeriesResponse_FieldTerminalPathArrayItemValue struct {
	WatchPhantomTimeSeriesResponse_FieldTerminalPath
	value interface{}
}

var _ WatchPhantomTimeSeriesResponse_FieldPathArrayItemValue = (*WatchPhantomTimeSeriesResponse_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object WatchPhantomTimeSeriesResponse as interface{}
func (fpaiv *WatchPhantomTimeSeriesResponse_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}
func (fpaiv *WatchPhantomTimeSeriesResponse_FieldTerminalPathArrayItemValue) AsPhantomTimeSerieChangesItemValue() (*phantom_time_serie.PhantomTimeSerieChange, bool) {
	res, ok := fpaiv.value.(*phantom_time_serie.PhantomTimeSerieChange)
	return res, ok
}

func (fpaiv *WatchPhantomTimeSeriesResponse_FieldTerminalPathArrayItemValue) GetSingle(source *WatchPhantomTimeSeriesResponse) (interface{}, bool) {
	return nil, false
}

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

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

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

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

// WatchPhantomTimeSeriesResponse_FieldPathArrayOfValues allows storing slice of values for WatchPhantomTimeSeriesResponse fields according to their type
type WatchPhantomTimeSeriesResponse_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	WatchPhantomTimeSeriesResponse_FieldPath
}

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

func MustParseWatchPhantomTimeSeriesResponse_FieldPathArrayOfValues(pathStr, valuesStr string) WatchPhantomTimeSeriesResponse_FieldPathArrayOfValues {
	fpaov, err := ParseWatchPhantomTimeSeriesResponse_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type WatchPhantomTimeSeriesResponse_FieldTerminalPathArrayOfValues struct {
	WatchPhantomTimeSeriesResponse_FieldTerminalPath
	values interface{}
}

var _ WatchPhantomTimeSeriesResponse_FieldPathArrayOfValues = (*WatchPhantomTimeSeriesResponse_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *WatchPhantomTimeSeriesResponse_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case WatchPhantomTimeSeriesResponse_FieldPathSelectorPhantomTimeSerieChanges:
		for _, v := range fpaov.values.([][]*phantom_time_serie.PhantomTimeSerieChange) {
			values = append(values, v)
		}
	case WatchPhantomTimeSeriesResponse_FieldPathSelectorIsCurrent:
		for _, v := range fpaov.values.([]bool) {
			values = append(values, v)
		}
	case WatchPhantomTimeSeriesResponse_FieldPathSelectorPageTokenChange:
		for _, v := range fpaov.values.([]*WatchPhantomTimeSeriesResponse_PageTokenChange) {
			values = append(values, v)
		}
	case WatchPhantomTimeSeriesResponse_FieldPathSelectorResumeToken:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case WatchPhantomTimeSeriesResponse_FieldPathSelectorSnapshotSize:
		for _, v := range fpaov.values.([]int64) {
			values = append(values, v)
		}
	case WatchPhantomTimeSeriesResponse_FieldPathSelectorIsSoftReset:
		for _, v := range fpaov.values.([]bool) {
			values = append(values, v)
		}
	case WatchPhantomTimeSeriesResponse_FieldPathSelectorIsHardReset:
		for _, v := range fpaov.values.([]bool) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *WatchPhantomTimeSeriesResponse_FieldTerminalPathArrayOfValues) AsPhantomTimeSerieChangesArrayOfValues() ([][]*phantom_time_serie.PhantomTimeSerieChange, bool) {
	res, ok := fpaov.values.([][]*phantom_time_serie.PhantomTimeSerieChange)
	return res, ok
}
func (fpaov *WatchPhantomTimeSeriesResponse_FieldTerminalPathArrayOfValues) AsIsCurrentArrayOfValues() ([]bool, bool) {
	res, ok := fpaov.values.([]bool)
	return res, ok
}
func (fpaov *WatchPhantomTimeSeriesResponse_FieldTerminalPathArrayOfValues) AsPageTokenChangeArrayOfValues() ([]*WatchPhantomTimeSeriesResponse_PageTokenChange, bool) {
	res, ok := fpaov.values.([]*WatchPhantomTimeSeriesResponse_PageTokenChange)
	return res, ok
}
func (fpaov *WatchPhantomTimeSeriesResponse_FieldTerminalPathArrayOfValues) AsResumeTokenArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *WatchPhantomTimeSeriesResponse_FieldTerminalPathArrayOfValues) AsSnapshotSizeArrayOfValues() ([]int64, bool) {
	res, ok := fpaov.values.([]int64)
	return res, ok
}
func (fpaov *WatchPhantomTimeSeriesResponse_FieldTerminalPathArrayOfValues) AsIsSoftResetArrayOfValues() ([]bool, bool) {
	res, ok := fpaov.values.([]bool)
	return res, ok
}
func (fpaov *WatchPhantomTimeSeriesResponse_FieldTerminalPathArrayOfValues) AsIsHardResetArrayOfValues() ([]bool, bool) {
	res, ok := fpaov.values.([]bool)
	return res, ok
}

type WatchPhantomTimeSeriesResponse_FieldSubPathArrayOfValues struct {
	WatchPhantomTimeSeriesResponse_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ WatchPhantomTimeSeriesResponse_FieldPathArrayOfValues = (*WatchPhantomTimeSeriesResponse_FieldSubPathArrayOfValues)(nil)

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

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

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

type WatchPhantomTimeSeriesResponsePageTokenChange_FieldPathSelector int32

const (
	WatchPhantomTimeSeriesResponsePageTokenChange_FieldPathSelectorPrevPageToken WatchPhantomTimeSeriesResponsePageTokenChange_FieldPathSelector = 0
	WatchPhantomTimeSeriesResponsePageTokenChange_FieldPathSelectorNextPageToken WatchPhantomTimeSeriesResponsePageTokenChange_FieldPathSelector = 1
)

func (s WatchPhantomTimeSeriesResponsePageTokenChange_FieldPathSelector) String() string {
	switch s {
	case WatchPhantomTimeSeriesResponsePageTokenChange_FieldPathSelectorPrevPageToken:
		return "prev_page_token"
	case WatchPhantomTimeSeriesResponsePageTokenChange_FieldPathSelectorNextPageToken:
		return "next_page_token"
	default:
		panic(fmt.Sprintf("Invalid selector for WatchPhantomTimeSeriesResponse_PageTokenChange: %d", s))
	}
}

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

func ParseWatchPhantomTimeSeriesResponsePageTokenChange_FieldPath(rawField string) (WatchPhantomTimeSeriesResponsePageTokenChange_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildWatchPhantomTimeSeriesResponsePageTokenChange_FieldPath(fp)
}

func MustParseWatchPhantomTimeSeriesResponsePageTokenChange_FieldPath(rawField string) WatchPhantomTimeSeriesResponsePageTokenChange_FieldPath {
	fp, err := ParseWatchPhantomTimeSeriesResponsePageTokenChange_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type WatchPhantomTimeSeriesResponsePageTokenChange_FieldTerminalPath struct {
	selector WatchPhantomTimeSeriesResponsePageTokenChange_FieldPathSelector
}

var _ WatchPhantomTimeSeriesResponsePageTokenChange_FieldPath = (*WatchPhantomTimeSeriesResponsePageTokenChange_FieldTerminalPath)(nil)

func (fp *WatchPhantomTimeSeriesResponsePageTokenChange_FieldTerminalPath) Selector() WatchPhantomTimeSeriesResponsePageTokenChange_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

// GetDefault returns a default value of the field type
func (fp *WatchPhantomTimeSeriesResponsePageTokenChange_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case WatchPhantomTimeSeriesResponsePageTokenChange_FieldPathSelectorPrevPageToken:
		return (*phantom_time_serie.PagerCursor)(nil)
	case WatchPhantomTimeSeriesResponsePageTokenChange_FieldPathSelectorNextPageToken:
		return (*phantom_time_serie.PagerCursor)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for WatchPhantomTimeSeriesResponse_PageTokenChange: %d", fp.selector))
	}
}

func (fp *WatchPhantomTimeSeriesResponsePageTokenChange_FieldTerminalPath) ClearValue(item *WatchPhantomTimeSeriesResponse_PageTokenChange) {
	if item != nil {
		switch fp.selector {
		case WatchPhantomTimeSeriesResponsePageTokenChange_FieldPathSelectorPrevPageToken:
			item.PrevPageToken = nil
		case WatchPhantomTimeSeriesResponsePageTokenChange_FieldPathSelectorNextPageToken:
			item.NextPageToken = nil
		default:
			panic(fmt.Sprintf("Invalid selector for WatchPhantomTimeSeriesResponse_PageTokenChange: %d", fp.selector))
		}
	}
}

func (fp *WatchPhantomTimeSeriesResponsePageTokenChange_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*WatchPhantomTimeSeriesResponse_PageTokenChange))
}

// IsLeaf - whether field path is holds simple value
func (fp *WatchPhantomTimeSeriesResponsePageTokenChange_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == WatchPhantomTimeSeriesResponsePageTokenChange_FieldPathSelectorPrevPageToken ||
		fp.selector == WatchPhantomTimeSeriesResponsePageTokenChange_FieldPathSelectorNextPageToken
}

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

func (fp *WatchPhantomTimeSeriesResponsePageTokenChange_FieldTerminalPath) WithIValue(value interface{}) WatchPhantomTimeSeriesResponsePageTokenChange_FieldPathValue {
	switch fp.selector {
	case WatchPhantomTimeSeriesResponsePageTokenChange_FieldPathSelectorPrevPageToken:
		return &WatchPhantomTimeSeriesResponsePageTokenChange_FieldTerminalPathValue{WatchPhantomTimeSeriesResponsePageTokenChange_FieldTerminalPath: *fp, value: value.(*phantom_time_serie.PagerCursor)}
	case WatchPhantomTimeSeriesResponsePageTokenChange_FieldPathSelectorNextPageToken:
		return &WatchPhantomTimeSeriesResponsePageTokenChange_FieldTerminalPathValue{WatchPhantomTimeSeriesResponsePageTokenChange_FieldTerminalPath: *fp, value: value.(*phantom_time_serie.PagerCursor)}
	default:
		panic(fmt.Sprintf("Invalid selector for WatchPhantomTimeSeriesResponse_PageTokenChange: %d", fp.selector))
	}
}

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

func (fp *WatchPhantomTimeSeriesResponsePageTokenChange_FieldTerminalPath) WithIArrayOfValues(values interface{}) WatchPhantomTimeSeriesResponsePageTokenChange_FieldPathArrayOfValues {
	fpaov := &WatchPhantomTimeSeriesResponsePageTokenChange_FieldTerminalPathArrayOfValues{WatchPhantomTimeSeriesResponsePageTokenChange_FieldTerminalPath: *fp}
	switch fp.selector {
	case WatchPhantomTimeSeriesResponsePageTokenChange_FieldPathSelectorPrevPageToken:
		return &WatchPhantomTimeSeriesResponsePageTokenChange_FieldTerminalPathArrayOfValues{WatchPhantomTimeSeriesResponsePageTokenChange_FieldTerminalPath: *fp, values: values.([]*phantom_time_serie.PagerCursor)}
	case WatchPhantomTimeSeriesResponsePageTokenChange_FieldPathSelectorNextPageToken:
		return &WatchPhantomTimeSeriesResponsePageTokenChange_FieldTerminalPathArrayOfValues{WatchPhantomTimeSeriesResponsePageTokenChange_FieldTerminalPath: *fp, values: values.([]*phantom_time_serie.PagerCursor)}
	default:
		panic(fmt.Sprintf("Invalid selector for WatchPhantomTimeSeriesResponse_PageTokenChange: %d", fp.selector))
	}
	return fpaov
}

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

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

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

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

func ParseWatchPhantomTimeSeriesResponsePageTokenChange_FieldPathValue(pathStr, valueStr string) (WatchPhantomTimeSeriesResponsePageTokenChange_FieldPathValue, error) {
	fp, err := ParseWatchPhantomTimeSeriesResponsePageTokenChange_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.(WatchPhantomTimeSeriesResponsePageTokenChange_FieldPathValue), nil
}

func MustParseWatchPhantomTimeSeriesResponsePageTokenChange_FieldPathValue(pathStr, valueStr string) WatchPhantomTimeSeriesResponsePageTokenChange_FieldPathValue {
	fpv, err := ParseWatchPhantomTimeSeriesResponsePageTokenChange_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type WatchPhantomTimeSeriesResponsePageTokenChange_FieldTerminalPathValue struct {
	WatchPhantomTimeSeriesResponsePageTokenChange_FieldTerminalPath
	value interface{}
}

var _ WatchPhantomTimeSeriesResponsePageTokenChange_FieldPathValue = (*WatchPhantomTimeSeriesResponsePageTokenChange_FieldTerminalPathValue)(nil)

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

// SetTo stores value for selected field for object PageTokenChange
func (fpv *WatchPhantomTimeSeriesResponsePageTokenChange_FieldTerminalPathValue) SetTo(target **WatchPhantomTimeSeriesResponse_PageTokenChange) {
	if *target == nil {
		*target = new(WatchPhantomTimeSeriesResponse_PageTokenChange)
	}
	switch fpv.selector {
	case WatchPhantomTimeSeriesResponsePageTokenChange_FieldPathSelectorPrevPageToken:
		(*target).PrevPageToken = fpv.value.(*phantom_time_serie.PagerCursor)
	case WatchPhantomTimeSeriesResponsePageTokenChange_FieldPathSelectorNextPageToken:
		(*target).NextPageToken = fpv.value.(*phantom_time_serie.PagerCursor)
	default:
		panic(fmt.Sprintf("Invalid selector for WatchPhantomTimeSeriesResponse_PageTokenChange: %d", fpv.selector))
	}
}

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

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

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

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

// ParseWatchPhantomTimeSeriesResponsePageTokenChange_FieldPathArrayItemValue parses string and JSON-encoded value to its Value
func ParseWatchPhantomTimeSeriesResponsePageTokenChange_FieldPathArrayItemValue(pathStr, valueStr string) (WatchPhantomTimeSeriesResponsePageTokenChange_FieldPathArrayItemValue, error) {
	fp, err := ParseWatchPhantomTimeSeriesResponsePageTokenChange_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.(WatchPhantomTimeSeriesResponsePageTokenChange_FieldPathArrayItemValue), nil
}

func MustParseWatchPhantomTimeSeriesResponsePageTokenChange_FieldPathArrayItemValue(pathStr, valueStr string) WatchPhantomTimeSeriesResponsePageTokenChange_FieldPathArrayItemValue {
	fpaiv, err := ParseWatchPhantomTimeSeriesResponsePageTokenChange_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type WatchPhantomTimeSeriesResponsePageTokenChange_FieldTerminalPathArrayItemValue struct {
	WatchPhantomTimeSeriesResponsePageTokenChange_FieldTerminalPath
	value interface{}
}

var _ WatchPhantomTimeSeriesResponsePageTokenChange_FieldPathArrayItemValue = (*WatchPhantomTimeSeriesResponsePageTokenChange_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *WatchPhantomTimeSeriesResponsePageTokenChange_FieldTerminalPathArrayItemValue) GetSingle(source *WatchPhantomTimeSeriesResponse_PageTokenChange) (interface{}, bool) {
	return nil, false
}

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

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

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

func ParseWatchPhantomTimeSeriesResponsePageTokenChange_FieldPathArrayOfValues(pathStr, valuesStr string) (WatchPhantomTimeSeriesResponsePageTokenChange_FieldPathArrayOfValues, error) {
	fp, err := ParseWatchPhantomTimeSeriesResponsePageTokenChange_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.(WatchPhantomTimeSeriesResponsePageTokenChange_FieldPathArrayOfValues), nil
}

func MustParseWatchPhantomTimeSeriesResponsePageTokenChange_FieldPathArrayOfValues(pathStr, valuesStr string) WatchPhantomTimeSeriesResponsePageTokenChange_FieldPathArrayOfValues {
	fpaov, err := ParseWatchPhantomTimeSeriesResponsePageTokenChange_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type WatchPhantomTimeSeriesResponsePageTokenChange_FieldTerminalPathArrayOfValues struct {
	WatchPhantomTimeSeriesResponsePageTokenChange_FieldTerminalPath
	values interface{}
}

var _ WatchPhantomTimeSeriesResponsePageTokenChange_FieldPathArrayOfValues = (*WatchPhantomTimeSeriesResponsePageTokenChange_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *WatchPhantomTimeSeriesResponsePageTokenChange_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case WatchPhantomTimeSeriesResponsePageTokenChange_FieldPathSelectorPrevPageToken:
		for _, v := range fpaov.values.([]*phantom_time_serie.PagerCursor) {
			values = append(values, v)
		}
	case WatchPhantomTimeSeriesResponsePageTokenChange_FieldPathSelectorNextPageToken:
		for _, v := range fpaov.values.([]*phantom_time_serie.PagerCursor) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *WatchPhantomTimeSeriesResponsePageTokenChange_FieldTerminalPathArrayOfValues) AsPrevPageTokenArrayOfValues() ([]*phantom_time_serie.PagerCursor, bool) {
	res, ok := fpaov.values.([]*phantom_time_serie.PagerCursor)
	return res, ok
}
func (fpaov *WatchPhantomTimeSeriesResponsePageTokenChange_FieldTerminalPathArrayOfValues) AsNextPageTokenArrayOfValues() ([]*phantom_time_serie.PagerCursor, bool) {
	res, ok := fpaov.values.([]*phantom_time_serie.PagerCursor)
	return res, ok
}

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

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

type CreatePhantomTimeSerieRequest_FieldPathSelector int32

const (
	CreatePhantomTimeSerieRequest_FieldPathSelectorParent           CreatePhantomTimeSerieRequest_FieldPathSelector = 0
	CreatePhantomTimeSerieRequest_FieldPathSelectorPhantomTimeSerie CreatePhantomTimeSerieRequest_FieldPathSelector = 1
)

func (s CreatePhantomTimeSerieRequest_FieldPathSelector) String() string {
	switch s {
	case CreatePhantomTimeSerieRequest_FieldPathSelectorParent:
		return "parent"
	case CreatePhantomTimeSerieRequest_FieldPathSelectorPhantomTimeSerie:
		return "phantom_time_serie"
	default:
		panic(fmt.Sprintf("Invalid selector for CreatePhantomTimeSerieRequest: %d", s))
	}
}

func BuildCreatePhantomTimeSerieRequest_FieldPath(fp gotenobject.RawFieldPath) (CreatePhantomTimeSerieRequest_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object CreatePhantomTimeSerieRequest")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "parent":
			return &CreatePhantomTimeSerieRequest_FieldTerminalPath{selector: CreatePhantomTimeSerieRequest_FieldPathSelectorParent}, nil
		case "phantom_time_serie", "phantomTimeSerie", "phantom-time-serie":
			return &CreatePhantomTimeSerieRequest_FieldTerminalPath{selector: CreatePhantomTimeSerieRequest_FieldPathSelectorPhantomTimeSerie}, nil
		}
	} else {
		switch fp[0] {
		case "phantom_time_serie", "phantomTimeSerie", "phantom-time-serie":
			if subpath, err := phantom_time_serie.BuildPhantomTimeSerie_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &CreatePhantomTimeSerieRequest_FieldSubPath{selector: CreatePhantomTimeSerieRequest_FieldPathSelectorPhantomTimeSerie, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object CreatePhantomTimeSerieRequest", fp)
}

func ParseCreatePhantomTimeSerieRequest_FieldPath(rawField string) (CreatePhantomTimeSerieRequest_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildCreatePhantomTimeSerieRequest_FieldPath(fp)
}

func MustParseCreatePhantomTimeSerieRequest_FieldPath(rawField string) CreatePhantomTimeSerieRequest_FieldPath {
	fp, err := ParseCreatePhantomTimeSerieRequest_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type CreatePhantomTimeSerieRequest_FieldTerminalPath struct {
	selector CreatePhantomTimeSerieRequest_FieldPathSelector
}

var _ CreatePhantomTimeSerieRequest_FieldPath = (*CreatePhantomTimeSerieRequest_FieldTerminalPath)(nil)

func (fp *CreatePhantomTimeSerieRequest_FieldTerminalPath) Selector() CreatePhantomTimeSerieRequest_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

// GetDefault returns a default value of the field type
func (fp *CreatePhantomTimeSerieRequest_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case CreatePhantomTimeSerieRequest_FieldPathSelectorParent:
		return (*phantom_time_serie.ParentReference)(nil)
	case CreatePhantomTimeSerieRequest_FieldPathSelectorPhantomTimeSerie:
		return (*phantom_time_serie.PhantomTimeSerie)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for CreatePhantomTimeSerieRequest: %d", fp.selector))
	}
}

func (fp *CreatePhantomTimeSerieRequest_FieldTerminalPath) ClearValue(item *CreatePhantomTimeSerieRequest) {
	if item != nil {
		switch fp.selector {
		case CreatePhantomTimeSerieRequest_FieldPathSelectorParent:
			item.Parent = nil
		case CreatePhantomTimeSerieRequest_FieldPathSelectorPhantomTimeSerie:
			item.PhantomTimeSerie = nil
		default:
			panic(fmt.Sprintf("Invalid selector for CreatePhantomTimeSerieRequest: %d", fp.selector))
		}
	}
}

func (fp *CreatePhantomTimeSerieRequest_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*CreatePhantomTimeSerieRequest))
}

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

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

func (fp *CreatePhantomTimeSerieRequest_FieldTerminalPath) WithIValue(value interface{}) CreatePhantomTimeSerieRequest_FieldPathValue {
	switch fp.selector {
	case CreatePhantomTimeSerieRequest_FieldPathSelectorParent:
		return &CreatePhantomTimeSerieRequest_FieldTerminalPathValue{CreatePhantomTimeSerieRequest_FieldTerminalPath: *fp, value: value.(*phantom_time_serie.ParentReference)}
	case CreatePhantomTimeSerieRequest_FieldPathSelectorPhantomTimeSerie:
		return &CreatePhantomTimeSerieRequest_FieldTerminalPathValue{CreatePhantomTimeSerieRequest_FieldTerminalPath: *fp, value: value.(*phantom_time_serie.PhantomTimeSerie)}
	default:
		panic(fmt.Sprintf("Invalid selector for CreatePhantomTimeSerieRequest: %d", fp.selector))
	}
}

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

func (fp *CreatePhantomTimeSerieRequest_FieldTerminalPath) WithIArrayOfValues(values interface{}) CreatePhantomTimeSerieRequest_FieldPathArrayOfValues {
	fpaov := &CreatePhantomTimeSerieRequest_FieldTerminalPathArrayOfValues{CreatePhantomTimeSerieRequest_FieldTerminalPath: *fp}
	switch fp.selector {
	case CreatePhantomTimeSerieRequest_FieldPathSelectorParent:
		return &CreatePhantomTimeSerieRequest_FieldTerminalPathArrayOfValues{CreatePhantomTimeSerieRequest_FieldTerminalPath: *fp, values: values.([]*phantom_time_serie.ParentReference)}
	case CreatePhantomTimeSerieRequest_FieldPathSelectorPhantomTimeSerie:
		return &CreatePhantomTimeSerieRequest_FieldTerminalPathArrayOfValues{CreatePhantomTimeSerieRequest_FieldTerminalPath: *fp, values: values.([]*phantom_time_serie.PhantomTimeSerie)}
	default:
		panic(fmt.Sprintf("Invalid selector for CreatePhantomTimeSerieRequest: %d", fp.selector))
	}
	return fpaov
}

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

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

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

type CreatePhantomTimeSerieRequest_FieldSubPath struct {
	selector CreatePhantomTimeSerieRequest_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ CreatePhantomTimeSerieRequest_FieldPath = (*CreatePhantomTimeSerieRequest_FieldSubPath)(nil)

func (fps *CreatePhantomTimeSerieRequest_FieldSubPath) Selector() CreatePhantomTimeSerieRequest_FieldPathSelector {
	return fps.selector
}
func (fps *CreatePhantomTimeSerieRequest_FieldSubPath) AsPhantomTimeSerieSubPath() (phantom_time_serie.PhantomTimeSerie_FieldPath, bool) {
	res, ok := fps.subPath.(phantom_time_serie.PhantomTimeSerie_FieldPath)
	return res, ok
}

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

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

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

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

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

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

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

func (fps *CreatePhantomTimeSerieRequest_FieldSubPath) ClearValue(item *CreatePhantomTimeSerieRequest) {
	if item != nil {
		switch fps.selector {
		case CreatePhantomTimeSerieRequest_FieldPathSelectorPhantomTimeSerie:
			fps.subPath.ClearValueRaw(item.PhantomTimeSerie)
		default:
			panic(fmt.Sprintf("Invalid selector for CreatePhantomTimeSerieRequest: %d", fps.selector))
		}
	}
}

func (fps *CreatePhantomTimeSerieRequest_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*CreatePhantomTimeSerieRequest))
}

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

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

func (fps *CreatePhantomTimeSerieRequest_FieldSubPath) WithIValue(value interface{}) CreatePhantomTimeSerieRequest_FieldPathValue {
	return &CreatePhantomTimeSerieRequest_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *CreatePhantomTimeSerieRequest_FieldSubPath) WithIArrayOfValues(values interface{}) CreatePhantomTimeSerieRequest_FieldPathArrayOfValues {
	return &CreatePhantomTimeSerieRequest_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *CreatePhantomTimeSerieRequest_FieldSubPath) WithIArrayItemValue(value interface{}) CreatePhantomTimeSerieRequest_FieldPathArrayItemValue {
	return &CreatePhantomTimeSerieRequest_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

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

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

func MustParseCreatePhantomTimeSerieRequest_FieldPathValue(pathStr, valueStr string) CreatePhantomTimeSerieRequest_FieldPathValue {
	fpv, err := ParseCreatePhantomTimeSerieRequest_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type CreatePhantomTimeSerieRequest_FieldTerminalPathValue struct {
	CreatePhantomTimeSerieRequest_FieldTerminalPath
	value interface{}
}

var _ CreatePhantomTimeSerieRequest_FieldPathValue = (*CreatePhantomTimeSerieRequest_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'CreatePhantomTimeSerieRequest' as interface{}
func (fpv *CreatePhantomTimeSerieRequest_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *CreatePhantomTimeSerieRequest_FieldTerminalPathValue) AsParentValue() (*phantom_time_serie.ParentReference, bool) {
	res, ok := fpv.value.(*phantom_time_serie.ParentReference)
	return res, ok
}
func (fpv *CreatePhantomTimeSerieRequest_FieldTerminalPathValue) AsPhantomTimeSerieValue() (*phantom_time_serie.PhantomTimeSerie, bool) {
	res, ok := fpv.value.(*phantom_time_serie.PhantomTimeSerie)
	return res, ok
}

// SetTo stores value for selected field for object CreatePhantomTimeSerieRequest
func (fpv *CreatePhantomTimeSerieRequest_FieldTerminalPathValue) SetTo(target **CreatePhantomTimeSerieRequest) {
	if *target == nil {
		*target = new(CreatePhantomTimeSerieRequest)
	}
	switch fpv.selector {
	case CreatePhantomTimeSerieRequest_FieldPathSelectorParent:
		(*target).Parent = fpv.value.(*phantom_time_serie.ParentReference)
	case CreatePhantomTimeSerieRequest_FieldPathSelectorPhantomTimeSerie:
		(*target).PhantomTimeSerie = fpv.value.(*phantom_time_serie.PhantomTimeSerie)
	default:
		panic(fmt.Sprintf("Invalid selector for CreatePhantomTimeSerieRequest: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'CreatePhantomTimeSerieRequest_FieldTerminalPathValue' with the value under path in 'CreatePhantomTimeSerieRequest'.
func (fpv *CreatePhantomTimeSerieRequest_FieldTerminalPathValue) CompareWith(source *CreatePhantomTimeSerieRequest) (int, bool) {
	switch fpv.selector {
	case CreatePhantomTimeSerieRequest_FieldPathSelectorParent:
		leftValue := fpv.value.(*phantom_time_serie.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 CreatePhantomTimeSerieRequest_FieldPathSelectorPhantomTimeSerie:
		return 0, false
	default:
		panic(fmt.Sprintf("Invalid selector for CreatePhantomTimeSerieRequest: %d", fpv.selector))
	}
}

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

type CreatePhantomTimeSerieRequest_FieldSubPathValue struct {
	CreatePhantomTimeSerieRequest_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ CreatePhantomTimeSerieRequest_FieldPathValue = (*CreatePhantomTimeSerieRequest_FieldSubPathValue)(nil)

func (fpvs *CreatePhantomTimeSerieRequest_FieldSubPathValue) AsPhantomTimeSeriePathValue() (phantom_time_serie.PhantomTimeSerie_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(phantom_time_serie.PhantomTimeSerie_FieldPathValue)
	return res, ok
}

func (fpvs *CreatePhantomTimeSerieRequest_FieldSubPathValue) SetTo(target **CreatePhantomTimeSerieRequest) {
	if *target == nil {
		*target = new(CreatePhantomTimeSerieRequest)
	}
	switch fpvs.Selector() {
	case CreatePhantomTimeSerieRequest_FieldPathSelectorPhantomTimeSerie:
		fpvs.subPathValue.(phantom_time_serie.PhantomTimeSerie_FieldPathValue).SetTo(&(*target).PhantomTimeSerie)
	default:
		panic(fmt.Sprintf("Invalid selector for CreatePhantomTimeSerieRequest: %d", fpvs.Selector()))
	}
}

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

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

func (fpvs *CreatePhantomTimeSerieRequest_FieldSubPathValue) CompareWith(source *CreatePhantomTimeSerieRequest) (int, bool) {
	switch fpvs.Selector() {
	case CreatePhantomTimeSerieRequest_FieldPathSelectorPhantomTimeSerie:
		return fpvs.subPathValue.(phantom_time_serie.PhantomTimeSerie_FieldPathValue).CompareWith(source.GetPhantomTimeSerie())
	default:
		panic(fmt.Sprintf("Invalid selector for CreatePhantomTimeSerieRequest: %d", fpvs.Selector()))
	}
}

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

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

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

func MustParseCreatePhantomTimeSerieRequest_FieldPathArrayItemValue(pathStr, valueStr string) CreatePhantomTimeSerieRequest_FieldPathArrayItemValue {
	fpaiv, err := ParseCreatePhantomTimeSerieRequest_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type CreatePhantomTimeSerieRequest_FieldTerminalPathArrayItemValue struct {
	CreatePhantomTimeSerieRequest_FieldTerminalPath
	value interface{}
}

var _ CreatePhantomTimeSerieRequest_FieldPathArrayItemValue = (*CreatePhantomTimeSerieRequest_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *CreatePhantomTimeSerieRequest_FieldTerminalPathArrayItemValue) GetSingle(source *CreatePhantomTimeSerieRequest) (interface{}, bool) {
	return nil, false
}

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

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

// GetRawValue returns stored array item value
func (fpaivs *CreatePhantomTimeSerieRequest_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *CreatePhantomTimeSerieRequest_FieldSubPathArrayItemValue) AsPhantomTimeSeriePathItemValue() (phantom_time_serie.PhantomTimeSerie_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(phantom_time_serie.PhantomTimeSerie_FieldPathArrayItemValue)
	return res, ok
}

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

// CreatePhantomTimeSerieRequest_FieldPathArrayOfValues allows storing slice of values for CreatePhantomTimeSerieRequest fields according to their type
type CreatePhantomTimeSerieRequest_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	CreatePhantomTimeSerieRequest_FieldPath
}

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

func MustParseCreatePhantomTimeSerieRequest_FieldPathArrayOfValues(pathStr, valuesStr string) CreatePhantomTimeSerieRequest_FieldPathArrayOfValues {
	fpaov, err := ParseCreatePhantomTimeSerieRequest_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type CreatePhantomTimeSerieRequest_FieldTerminalPathArrayOfValues struct {
	CreatePhantomTimeSerieRequest_FieldTerminalPath
	values interface{}
}

var _ CreatePhantomTimeSerieRequest_FieldPathArrayOfValues = (*CreatePhantomTimeSerieRequest_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *CreatePhantomTimeSerieRequest_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case CreatePhantomTimeSerieRequest_FieldPathSelectorParent:
		for _, v := range fpaov.values.([]*phantom_time_serie.ParentReference) {
			values = append(values, v)
		}
	case CreatePhantomTimeSerieRequest_FieldPathSelectorPhantomTimeSerie:
		for _, v := range fpaov.values.([]*phantom_time_serie.PhantomTimeSerie) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *CreatePhantomTimeSerieRequest_FieldTerminalPathArrayOfValues) AsParentArrayOfValues() ([]*phantom_time_serie.ParentReference, bool) {
	res, ok := fpaov.values.([]*phantom_time_serie.ParentReference)
	return res, ok
}
func (fpaov *CreatePhantomTimeSerieRequest_FieldTerminalPathArrayOfValues) AsPhantomTimeSerieArrayOfValues() ([]*phantom_time_serie.PhantomTimeSerie, bool) {
	res, ok := fpaov.values.([]*phantom_time_serie.PhantomTimeSerie)
	return res, ok
}

type CreatePhantomTimeSerieRequest_FieldSubPathArrayOfValues struct {
	CreatePhantomTimeSerieRequest_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ CreatePhantomTimeSerieRequest_FieldPathArrayOfValues = (*CreatePhantomTimeSerieRequest_FieldSubPathArrayOfValues)(nil)

func (fpsaov *CreatePhantomTimeSerieRequest_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *CreatePhantomTimeSerieRequest_FieldSubPathArrayOfValues) AsPhantomTimeSeriePathArrayOfValues() (phantom_time_serie.PhantomTimeSerie_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(phantom_time_serie.PhantomTimeSerie_FieldPathArrayOfValues)
	return res, ok
}

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

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

type UpdatePhantomTimeSerieRequest_FieldPathSelector int32

const (
	UpdatePhantomTimeSerieRequest_FieldPathSelectorPhantomTimeSerie UpdatePhantomTimeSerieRequest_FieldPathSelector = 0
	UpdatePhantomTimeSerieRequest_FieldPathSelectorUpdateMask       UpdatePhantomTimeSerieRequest_FieldPathSelector = 1
	UpdatePhantomTimeSerieRequest_FieldPathSelectorCas              UpdatePhantomTimeSerieRequest_FieldPathSelector = 2
)

func (s UpdatePhantomTimeSerieRequest_FieldPathSelector) String() string {
	switch s {
	case UpdatePhantomTimeSerieRequest_FieldPathSelectorPhantomTimeSerie:
		return "phantom_time_serie"
	case UpdatePhantomTimeSerieRequest_FieldPathSelectorUpdateMask:
		return "update_mask"
	case UpdatePhantomTimeSerieRequest_FieldPathSelectorCas:
		return "cas"
	default:
		panic(fmt.Sprintf("Invalid selector for UpdatePhantomTimeSerieRequest: %d", s))
	}
}

func BuildUpdatePhantomTimeSerieRequest_FieldPath(fp gotenobject.RawFieldPath) (UpdatePhantomTimeSerieRequest_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object UpdatePhantomTimeSerieRequest")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "phantom_time_serie", "phantomTimeSerie", "phantom-time-serie":
			return &UpdatePhantomTimeSerieRequest_FieldTerminalPath{selector: UpdatePhantomTimeSerieRequest_FieldPathSelectorPhantomTimeSerie}, nil
		case "update_mask", "updateMask", "update-mask":
			return &UpdatePhantomTimeSerieRequest_FieldTerminalPath{selector: UpdatePhantomTimeSerieRequest_FieldPathSelectorUpdateMask}, nil
		case "cas":
			return &UpdatePhantomTimeSerieRequest_FieldTerminalPath{selector: UpdatePhantomTimeSerieRequest_FieldPathSelectorCas}, nil
		}
	} else {
		switch fp[0] {
		case "phantom_time_serie", "phantomTimeSerie", "phantom-time-serie":
			if subpath, err := phantom_time_serie.BuildPhantomTimeSerie_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &UpdatePhantomTimeSerieRequest_FieldSubPath{selector: UpdatePhantomTimeSerieRequest_FieldPathSelectorPhantomTimeSerie, subPath: subpath}, nil
			}
		case "cas":
			if subpath, err := BuildUpdatePhantomTimeSerieRequestCAS_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &UpdatePhantomTimeSerieRequest_FieldSubPath{selector: UpdatePhantomTimeSerieRequest_FieldPathSelectorCas, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object UpdatePhantomTimeSerieRequest", fp)
}

func ParseUpdatePhantomTimeSerieRequest_FieldPath(rawField string) (UpdatePhantomTimeSerieRequest_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildUpdatePhantomTimeSerieRequest_FieldPath(fp)
}

func MustParseUpdatePhantomTimeSerieRequest_FieldPath(rawField string) UpdatePhantomTimeSerieRequest_FieldPath {
	fp, err := ParseUpdatePhantomTimeSerieRequest_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type UpdatePhantomTimeSerieRequest_FieldTerminalPath struct {
	selector UpdatePhantomTimeSerieRequest_FieldPathSelector
}

var _ UpdatePhantomTimeSerieRequest_FieldPath = (*UpdatePhantomTimeSerieRequest_FieldTerminalPath)(nil)

func (fp *UpdatePhantomTimeSerieRequest_FieldTerminalPath) Selector() UpdatePhantomTimeSerieRequest_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source UpdatePhantomTimeSerieRequest
func (fp *UpdatePhantomTimeSerieRequest_FieldTerminalPath) Get(source *UpdatePhantomTimeSerieRequest) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case UpdatePhantomTimeSerieRequest_FieldPathSelectorPhantomTimeSerie:
			if source.PhantomTimeSerie != nil {
				values = append(values, source.PhantomTimeSerie)
			}
		case UpdatePhantomTimeSerieRequest_FieldPathSelectorUpdateMask:
			if source.UpdateMask != nil {
				values = append(values, source.UpdateMask)
			}
		case UpdatePhantomTimeSerieRequest_FieldPathSelectorCas:
			if source.Cas != nil {
				values = append(values, source.Cas)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for UpdatePhantomTimeSerieRequest: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source UpdatePhantomTimeSerieRequest
func (fp *UpdatePhantomTimeSerieRequest_FieldTerminalPath) GetSingle(source *UpdatePhantomTimeSerieRequest) (interface{}, bool) {
	switch fp.selector {
	case UpdatePhantomTimeSerieRequest_FieldPathSelectorPhantomTimeSerie:
		res := source.GetPhantomTimeSerie()
		return res, res != nil
	case UpdatePhantomTimeSerieRequest_FieldPathSelectorUpdateMask:
		res := source.GetUpdateMask()
		return res, res != nil
	case UpdatePhantomTimeSerieRequest_FieldPathSelectorCas:
		res := source.GetCas()
		return res, res != nil
	default:
		panic(fmt.Sprintf("Invalid selector for UpdatePhantomTimeSerieRequest: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *UpdatePhantomTimeSerieRequest_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case UpdatePhantomTimeSerieRequest_FieldPathSelectorPhantomTimeSerie:
		return (*phantom_time_serie.PhantomTimeSerie)(nil)
	case UpdatePhantomTimeSerieRequest_FieldPathSelectorUpdateMask:
		return (*phantom_time_serie.PhantomTimeSerie_FieldMask)(nil)
	case UpdatePhantomTimeSerieRequest_FieldPathSelectorCas:
		return (*UpdatePhantomTimeSerieRequest_CAS)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for UpdatePhantomTimeSerieRequest: %d", fp.selector))
	}
}

func (fp *UpdatePhantomTimeSerieRequest_FieldTerminalPath) ClearValue(item *UpdatePhantomTimeSerieRequest) {
	if item != nil {
		switch fp.selector {
		case UpdatePhantomTimeSerieRequest_FieldPathSelectorPhantomTimeSerie:
			item.PhantomTimeSerie = nil
		case UpdatePhantomTimeSerieRequest_FieldPathSelectorUpdateMask:
			item.UpdateMask = nil
		case UpdatePhantomTimeSerieRequest_FieldPathSelectorCas:
			item.Cas = nil
		default:
			panic(fmt.Sprintf("Invalid selector for UpdatePhantomTimeSerieRequest: %d", fp.selector))
		}
	}
}

func (fp *UpdatePhantomTimeSerieRequest_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*UpdatePhantomTimeSerieRequest))
}

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

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

func (fp *UpdatePhantomTimeSerieRequest_FieldTerminalPath) WithIValue(value interface{}) UpdatePhantomTimeSerieRequest_FieldPathValue {
	switch fp.selector {
	case UpdatePhantomTimeSerieRequest_FieldPathSelectorPhantomTimeSerie:
		return &UpdatePhantomTimeSerieRequest_FieldTerminalPathValue{UpdatePhantomTimeSerieRequest_FieldTerminalPath: *fp, value: value.(*phantom_time_serie.PhantomTimeSerie)}
	case UpdatePhantomTimeSerieRequest_FieldPathSelectorUpdateMask:
		return &UpdatePhantomTimeSerieRequest_FieldTerminalPathValue{UpdatePhantomTimeSerieRequest_FieldTerminalPath: *fp, value: value.(*phantom_time_serie.PhantomTimeSerie_FieldMask)}
	case UpdatePhantomTimeSerieRequest_FieldPathSelectorCas:
		return &UpdatePhantomTimeSerieRequest_FieldTerminalPathValue{UpdatePhantomTimeSerieRequest_FieldTerminalPath: *fp, value: value.(*UpdatePhantomTimeSerieRequest_CAS)}
	default:
		panic(fmt.Sprintf("Invalid selector for UpdatePhantomTimeSerieRequest: %d", fp.selector))
	}
}

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

func (fp *UpdatePhantomTimeSerieRequest_FieldTerminalPath) WithIArrayOfValues(values interface{}) UpdatePhantomTimeSerieRequest_FieldPathArrayOfValues {
	fpaov := &UpdatePhantomTimeSerieRequest_FieldTerminalPathArrayOfValues{UpdatePhantomTimeSerieRequest_FieldTerminalPath: *fp}
	switch fp.selector {
	case UpdatePhantomTimeSerieRequest_FieldPathSelectorPhantomTimeSerie:
		return &UpdatePhantomTimeSerieRequest_FieldTerminalPathArrayOfValues{UpdatePhantomTimeSerieRequest_FieldTerminalPath: *fp, values: values.([]*phantom_time_serie.PhantomTimeSerie)}
	case UpdatePhantomTimeSerieRequest_FieldPathSelectorUpdateMask:
		return &UpdatePhantomTimeSerieRequest_FieldTerminalPathArrayOfValues{UpdatePhantomTimeSerieRequest_FieldTerminalPath: *fp, values: values.([]*phantom_time_serie.PhantomTimeSerie_FieldMask)}
	case UpdatePhantomTimeSerieRequest_FieldPathSelectorCas:
		return &UpdatePhantomTimeSerieRequest_FieldTerminalPathArrayOfValues{UpdatePhantomTimeSerieRequest_FieldTerminalPath: *fp, values: values.([]*UpdatePhantomTimeSerieRequest_CAS)}
	default:
		panic(fmt.Sprintf("Invalid selector for UpdatePhantomTimeSerieRequest: %d", fp.selector))
	}
	return fpaov
}

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

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

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

type UpdatePhantomTimeSerieRequest_FieldSubPath struct {
	selector UpdatePhantomTimeSerieRequest_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ UpdatePhantomTimeSerieRequest_FieldPath = (*UpdatePhantomTimeSerieRequest_FieldSubPath)(nil)

func (fps *UpdatePhantomTimeSerieRequest_FieldSubPath) Selector() UpdatePhantomTimeSerieRequest_FieldPathSelector {
	return fps.selector
}
func (fps *UpdatePhantomTimeSerieRequest_FieldSubPath) AsPhantomTimeSerieSubPath() (phantom_time_serie.PhantomTimeSerie_FieldPath, bool) {
	res, ok := fps.subPath.(phantom_time_serie.PhantomTimeSerie_FieldPath)
	return res, ok
}
func (fps *UpdatePhantomTimeSerieRequest_FieldSubPath) AsCasSubPath() (UpdatePhantomTimeSerieRequestCAS_FieldPath, bool) {
	res, ok := fps.subPath.(UpdatePhantomTimeSerieRequestCAS_FieldPath)
	return res, ok
}

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

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

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

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

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

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

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

func (fps *UpdatePhantomTimeSerieRequest_FieldSubPath) ClearValue(item *UpdatePhantomTimeSerieRequest) {
	if item != nil {
		switch fps.selector {
		case UpdatePhantomTimeSerieRequest_FieldPathSelectorPhantomTimeSerie:
			fps.subPath.ClearValueRaw(item.PhantomTimeSerie)
		case UpdatePhantomTimeSerieRequest_FieldPathSelectorCas:
			fps.subPath.ClearValueRaw(item.Cas)
		default:
			panic(fmt.Sprintf("Invalid selector for UpdatePhantomTimeSerieRequest: %d", fps.selector))
		}
	}
}

func (fps *UpdatePhantomTimeSerieRequest_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*UpdatePhantomTimeSerieRequest))
}

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

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

func (fps *UpdatePhantomTimeSerieRequest_FieldSubPath) WithIValue(value interface{}) UpdatePhantomTimeSerieRequest_FieldPathValue {
	return &UpdatePhantomTimeSerieRequest_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *UpdatePhantomTimeSerieRequest_FieldSubPath) WithIArrayOfValues(values interface{}) UpdatePhantomTimeSerieRequest_FieldPathArrayOfValues {
	return &UpdatePhantomTimeSerieRequest_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *UpdatePhantomTimeSerieRequest_FieldSubPath) WithIArrayItemValue(value interface{}) UpdatePhantomTimeSerieRequest_FieldPathArrayItemValue {
	return &UpdatePhantomTimeSerieRequest_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

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

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

func MustParseUpdatePhantomTimeSerieRequest_FieldPathValue(pathStr, valueStr string) UpdatePhantomTimeSerieRequest_FieldPathValue {
	fpv, err := ParseUpdatePhantomTimeSerieRequest_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type UpdatePhantomTimeSerieRequest_FieldTerminalPathValue struct {
	UpdatePhantomTimeSerieRequest_FieldTerminalPath
	value interface{}
}

var _ UpdatePhantomTimeSerieRequest_FieldPathValue = (*UpdatePhantomTimeSerieRequest_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'UpdatePhantomTimeSerieRequest' as interface{}
func (fpv *UpdatePhantomTimeSerieRequest_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *UpdatePhantomTimeSerieRequest_FieldTerminalPathValue) AsPhantomTimeSerieValue() (*phantom_time_serie.PhantomTimeSerie, bool) {
	res, ok := fpv.value.(*phantom_time_serie.PhantomTimeSerie)
	return res, ok
}
func (fpv *UpdatePhantomTimeSerieRequest_FieldTerminalPathValue) AsUpdateMaskValue() (*phantom_time_serie.PhantomTimeSerie_FieldMask, bool) {
	res, ok := fpv.value.(*phantom_time_serie.PhantomTimeSerie_FieldMask)
	return res, ok
}
func (fpv *UpdatePhantomTimeSerieRequest_FieldTerminalPathValue) AsCasValue() (*UpdatePhantomTimeSerieRequest_CAS, bool) {
	res, ok := fpv.value.(*UpdatePhantomTimeSerieRequest_CAS)
	return res, ok
}

// SetTo stores value for selected field for object UpdatePhantomTimeSerieRequest
func (fpv *UpdatePhantomTimeSerieRequest_FieldTerminalPathValue) SetTo(target **UpdatePhantomTimeSerieRequest) {
	if *target == nil {
		*target = new(UpdatePhantomTimeSerieRequest)
	}
	switch fpv.selector {
	case UpdatePhantomTimeSerieRequest_FieldPathSelectorPhantomTimeSerie:
		(*target).PhantomTimeSerie = fpv.value.(*phantom_time_serie.PhantomTimeSerie)
	case UpdatePhantomTimeSerieRequest_FieldPathSelectorUpdateMask:
		(*target).UpdateMask = fpv.value.(*phantom_time_serie.PhantomTimeSerie_FieldMask)
	case UpdatePhantomTimeSerieRequest_FieldPathSelectorCas:
		(*target).Cas = fpv.value.(*UpdatePhantomTimeSerieRequest_CAS)
	default:
		panic(fmt.Sprintf("Invalid selector for UpdatePhantomTimeSerieRequest: %d", fpv.selector))
	}
}

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

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

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

type UpdatePhantomTimeSerieRequest_FieldSubPathValue struct {
	UpdatePhantomTimeSerieRequest_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ UpdatePhantomTimeSerieRequest_FieldPathValue = (*UpdatePhantomTimeSerieRequest_FieldSubPathValue)(nil)

func (fpvs *UpdatePhantomTimeSerieRequest_FieldSubPathValue) AsPhantomTimeSeriePathValue() (phantom_time_serie.PhantomTimeSerie_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(phantom_time_serie.PhantomTimeSerie_FieldPathValue)
	return res, ok
}
func (fpvs *UpdatePhantomTimeSerieRequest_FieldSubPathValue) AsCasPathValue() (UpdatePhantomTimeSerieRequestCAS_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(UpdatePhantomTimeSerieRequestCAS_FieldPathValue)
	return res, ok
}

func (fpvs *UpdatePhantomTimeSerieRequest_FieldSubPathValue) SetTo(target **UpdatePhantomTimeSerieRequest) {
	if *target == nil {
		*target = new(UpdatePhantomTimeSerieRequest)
	}
	switch fpvs.Selector() {
	case UpdatePhantomTimeSerieRequest_FieldPathSelectorPhantomTimeSerie:
		fpvs.subPathValue.(phantom_time_serie.PhantomTimeSerie_FieldPathValue).SetTo(&(*target).PhantomTimeSerie)
	case UpdatePhantomTimeSerieRequest_FieldPathSelectorCas:
		fpvs.subPathValue.(UpdatePhantomTimeSerieRequestCAS_FieldPathValue).SetTo(&(*target).Cas)
	default:
		panic(fmt.Sprintf("Invalid selector for UpdatePhantomTimeSerieRequest: %d", fpvs.Selector()))
	}
}

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

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

func (fpvs *UpdatePhantomTimeSerieRequest_FieldSubPathValue) CompareWith(source *UpdatePhantomTimeSerieRequest) (int, bool) {
	switch fpvs.Selector() {
	case UpdatePhantomTimeSerieRequest_FieldPathSelectorPhantomTimeSerie:
		return fpvs.subPathValue.(phantom_time_serie.PhantomTimeSerie_FieldPathValue).CompareWith(source.GetPhantomTimeSerie())
	case UpdatePhantomTimeSerieRequest_FieldPathSelectorCas:
		return fpvs.subPathValue.(UpdatePhantomTimeSerieRequestCAS_FieldPathValue).CompareWith(source.GetCas())
	default:
		panic(fmt.Sprintf("Invalid selector for UpdatePhantomTimeSerieRequest: %d", fpvs.Selector()))
	}
}

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

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

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

func MustParseUpdatePhantomTimeSerieRequest_FieldPathArrayItemValue(pathStr, valueStr string) UpdatePhantomTimeSerieRequest_FieldPathArrayItemValue {
	fpaiv, err := ParseUpdatePhantomTimeSerieRequest_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type UpdatePhantomTimeSerieRequest_FieldTerminalPathArrayItemValue struct {
	UpdatePhantomTimeSerieRequest_FieldTerminalPath
	value interface{}
}

var _ UpdatePhantomTimeSerieRequest_FieldPathArrayItemValue = (*UpdatePhantomTimeSerieRequest_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *UpdatePhantomTimeSerieRequest_FieldTerminalPathArrayItemValue) GetSingle(source *UpdatePhantomTimeSerieRequest) (interface{}, bool) {
	return nil, false
}

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

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

// GetRawValue returns stored array item value
func (fpaivs *UpdatePhantomTimeSerieRequest_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *UpdatePhantomTimeSerieRequest_FieldSubPathArrayItemValue) AsPhantomTimeSeriePathItemValue() (phantom_time_serie.PhantomTimeSerie_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(phantom_time_serie.PhantomTimeSerie_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *UpdatePhantomTimeSerieRequest_FieldSubPathArrayItemValue) AsCasPathItemValue() (UpdatePhantomTimeSerieRequestCAS_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(UpdatePhantomTimeSerieRequestCAS_FieldPathArrayItemValue)
	return res, ok
}

// Contains returns a boolean indicating if value that is being held is present in given 'UpdatePhantomTimeSerieRequest'
func (fpaivs *UpdatePhantomTimeSerieRequest_FieldSubPathArrayItemValue) ContainsValue(source *UpdatePhantomTimeSerieRequest) bool {
	switch fpaivs.Selector() {
	case UpdatePhantomTimeSerieRequest_FieldPathSelectorPhantomTimeSerie:
		return fpaivs.subPathItemValue.(phantom_time_serie.PhantomTimeSerie_FieldPathArrayItemValue).ContainsValue(source.GetPhantomTimeSerie())
	case UpdatePhantomTimeSerieRequest_FieldPathSelectorCas:
		return fpaivs.subPathItemValue.(UpdatePhantomTimeSerieRequestCAS_FieldPathArrayItemValue).ContainsValue(source.GetCas())
	default:
		panic(fmt.Sprintf("Invalid selector for UpdatePhantomTimeSerieRequest: %d", fpaivs.Selector()))
	}
}

// UpdatePhantomTimeSerieRequest_FieldPathArrayOfValues allows storing slice of values for UpdatePhantomTimeSerieRequest fields according to their type
type UpdatePhantomTimeSerieRequest_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	UpdatePhantomTimeSerieRequest_FieldPath
}

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

func MustParseUpdatePhantomTimeSerieRequest_FieldPathArrayOfValues(pathStr, valuesStr string) UpdatePhantomTimeSerieRequest_FieldPathArrayOfValues {
	fpaov, err := ParseUpdatePhantomTimeSerieRequest_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type UpdatePhantomTimeSerieRequest_FieldTerminalPathArrayOfValues struct {
	UpdatePhantomTimeSerieRequest_FieldTerminalPath
	values interface{}
}

var _ UpdatePhantomTimeSerieRequest_FieldPathArrayOfValues = (*UpdatePhantomTimeSerieRequest_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *UpdatePhantomTimeSerieRequest_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case UpdatePhantomTimeSerieRequest_FieldPathSelectorPhantomTimeSerie:
		for _, v := range fpaov.values.([]*phantom_time_serie.PhantomTimeSerie) {
			values = append(values, v)
		}
	case UpdatePhantomTimeSerieRequest_FieldPathSelectorUpdateMask:
		for _, v := range fpaov.values.([]*phantom_time_serie.PhantomTimeSerie_FieldMask) {
			values = append(values, v)
		}
	case UpdatePhantomTimeSerieRequest_FieldPathSelectorCas:
		for _, v := range fpaov.values.([]*UpdatePhantomTimeSerieRequest_CAS) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *UpdatePhantomTimeSerieRequest_FieldTerminalPathArrayOfValues) AsPhantomTimeSerieArrayOfValues() ([]*phantom_time_serie.PhantomTimeSerie, bool) {
	res, ok := fpaov.values.([]*phantom_time_serie.PhantomTimeSerie)
	return res, ok
}
func (fpaov *UpdatePhantomTimeSerieRequest_FieldTerminalPathArrayOfValues) AsUpdateMaskArrayOfValues() ([]*phantom_time_serie.PhantomTimeSerie_FieldMask, bool) {
	res, ok := fpaov.values.([]*phantom_time_serie.PhantomTimeSerie_FieldMask)
	return res, ok
}
func (fpaov *UpdatePhantomTimeSerieRequest_FieldTerminalPathArrayOfValues) AsCasArrayOfValues() ([]*UpdatePhantomTimeSerieRequest_CAS, bool) {
	res, ok := fpaov.values.([]*UpdatePhantomTimeSerieRequest_CAS)
	return res, ok
}

type UpdatePhantomTimeSerieRequest_FieldSubPathArrayOfValues struct {
	UpdatePhantomTimeSerieRequest_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ UpdatePhantomTimeSerieRequest_FieldPathArrayOfValues = (*UpdatePhantomTimeSerieRequest_FieldSubPathArrayOfValues)(nil)

func (fpsaov *UpdatePhantomTimeSerieRequest_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *UpdatePhantomTimeSerieRequest_FieldSubPathArrayOfValues) AsPhantomTimeSeriePathArrayOfValues() (phantom_time_serie.PhantomTimeSerie_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(phantom_time_serie.PhantomTimeSerie_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *UpdatePhantomTimeSerieRequest_FieldSubPathArrayOfValues) AsCasPathArrayOfValues() (UpdatePhantomTimeSerieRequestCAS_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(UpdatePhantomTimeSerieRequestCAS_FieldPathArrayOfValues)
	return res, ok
}

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

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

type UpdatePhantomTimeSerieRequestCAS_FieldPathSelector int32

const (
	UpdatePhantomTimeSerieRequestCAS_FieldPathSelectorConditionalState UpdatePhantomTimeSerieRequestCAS_FieldPathSelector = 0
	UpdatePhantomTimeSerieRequestCAS_FieldPathSelectorFieldMask        UpdatePhantomTimeSerieRequestCAS_FieldPathSelector = 1
)

func (s UpdatePhantomTimeSerieRequestCAS_FieldPathSelector) String() string {
	switch s {
	case UpdatePhantomTimeSerieRequestCAS_FieldPathSelectorConditionalState:
		return "conditional_state"
	case UpdatePhantomTimeSerieRequestCAS_FieldPathSelectorFieldMask:
		return "field_mask"
	default:
		panic(fmt.Sprintf("Invalid selector for UpdatePhantomTimeSerieRequest_CAS: %d", s))
	}
}

func BuildUpdatePhantomTimeSerieRequestCAS_FieldPath(fp gotenobject.RawFieldPath) (UpdatePhantomTimeSerieRequestCAS_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object UpdatePhantomTimeSerieRequest_CAS")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "conditional_state", "conditionalState", "conditional-state":
			return &UpdatePhantomTimeSerieRequestCAS_FieldTerminalPath{selector: UpdatePhantomTimeSerieRequestCAS_FieldPathSelectorConditionalState}, nil
		case "field_mask", "fieldMask", "field-mask":
			return &UpdatePhantomTimeSerieRequestCAS_FieldTerminalPath{selector: UpdatePhantomTimeSerieRequestCAS_FieldPathSelectorFieldMask}, nil
		}
	} else {
		switch fp[0] {
		case "conditional_state", "conditionalState", "conditional-state":
			if subpath, err := phantom_time_serie.BuildPhantomTimeSerie_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &UpdatePhantomTimeSerieRequestCAS_FieldSubPath{selector: UpdatePhantomTimeSerieRequestCAS_FieldPathSelectorConditionalState, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object UpdatePhantomTimeSerieRequest_CAS", fp)
}

func ParseUpdatePhantomTimeSerieRequestCAS_FieldPath(rawField string) (UpdatePhantomTimeSerieRequestCAS_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildUpdatePhantomTimeSerieRequestCAS_FieldPath(fp)
}

func MustParseUpdatePhantomTimeSerieRequestCAS_FieldPath(rawField string) UpdatePhantomTimeSerieRequestCAS_FieldPath {
	fp, err := ParseUpdatePhantomTimeSerieRequestCAS_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type UpdatePhantomTimeSerieRequestCAS_FieldTerminalPath struct {
	selector UpdatePhantomTimeSerieRequestCAS_FieldPathSelector
}

var _ UpdatePhantomTimeSerieRequestCAS_FieldPath = (*UpdatePhantomTimeSerieRequestCAS_FieldTerminalPath)(nil)

func (fp *UpdatePhantomTimeSerieRequestCAS_FieldTerminalPath) Selector() UpdatePhantomTimeSerieRequestCAS_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

// GetDefault returns a default value of the field type
func (fp *UpdatePhantomTimeSerieRequestCAS_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case UpdatePhantomTimeSerieRequestCAS_FieldPathSelectorConditionalState:
		return (*phantom_time_serie.PhantomTimeSerie)(nil)
	case UpdatePhantomTimeSerieRequestCAS_FieldPathSelectorFieldMask:
		return (*phantom_time_serie.PhantomTimeSerie_FieldMask)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for UpdatePhantomTimeSerieRequest_CAS: %d", fp.selector))
	}
}

func (fp *UpdatePhantomTimeSerieRequestCAS_FieldTerminalPath) ClearValue(item *UpdatePhantomTimeSerieRequest_CAS) {
	if item != nil {
		switch fp.selector {
		case UpdatePhantomTimeSerieRequestCAS_FieldPathSelectorConditionalState:
			item.ConditionalState = nil
		case UpdatePhantomTimeSerieRequestCAS_FieldPathSelectorFieldMask:
			item.FieldMask = nil
		default:
			panic(fmt.Sprintf("Invalid selector for UpdatePhantomTimeSerieRequest_CAS: %d", fp.selector))
		}
	}
}

func (fp *UpdatePhantomTimeSerieRequestCAS_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*UpdatePhantomTimeSerieRequest_CAS))
}

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

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

func (fp *UpdatePhantomTimeSerieRequestCAS_FieldTerminalPath) WithIValue(value interface{}) UpdatePhantomTimeSerieRequestCAS_FieldPathValue {
	switch fp.selector {
	case UpdatePhantomTimeSerieRequestCAS_FieldPathSelectorConditionalState:
		return &UpdatePhantomTimeSerieRequestCAS_FieldTerminalPathValue{UpdatePhantomTimeSerieRequestCAS_FieldTerminalPath: *fp, value: value.(*phantom_time_serie.PhantomTimeSerie)}
	case UpdatePhantomTimeSerieRequestCAS_FieldPathSelectorFieldMask:
		return &UpdatePhantomTimeSerieRequestCAS_FieldTerminalPathValue{UpdatePhantomTimeSerieRequestCAS_FieldTerminalPath: *fp, value: value.(*phantom_time_serie.PhantomTimeSerie_FieldMask)}
	default:
		panic(fmt.Sprintf("Invalid selector for UpdatePhantomTimeSerieRequest_CAS: %d", fp.selector))
	}
}

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

func (fp *UpdatePhantomTimeSerieRequestCAS_FieldTerminalPath) WithIArrayOfValues(values interface{}) UpdatePhantomTimeSerieRequestCAS_FieldPathArrayOfValues {
	fpaov := &UpdatePhantomTimeSerieRequestCAS_FieldTerminalPathArrayOfValues{UpdatePhantomTimeSerieRequestCAS_FieldTerminalPath: *fp}
	switch fp.selector {
	case UpdatePhantomTimeSerieRequestCAS_FieldPathSelectorConditionalState:
		return &UpdatePhantomTimeSerieRequestCAS_FieldTerminalPathArrayOfValues{UpdatePhantomTimeSerieRequestCAS_FieldTerminalPath: *fp, values: values.([]*phantom_time_serie.PhantomTimeSerie)}
	case UpdatePhantomTimeSerieRequestCAS_FieldPathSelectorFieldMask:
		return &UpdatePhantomTimeSerieRequestCAS_FieldTerminalPathArrayOfValues{UpdatePhantomTimeSerieRequestCAS_FieldTerminalPath: *fp, values: values.([]*phantom_time_serie.PhantomTimeSerie_FieldMask)}
	default:
		panic(fmt.Sprintf("Invalid selector for UpdatePhantomTimeSerieRequest_CAS: %d", fp.selector))
	}
	return fpaov
}

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

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

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

type UpdatePhantomTimeSerieRequestCAS_FieldSubPath struct {
	selector UpdatePhantomTimeSerieRequestCAS_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ UpdatePhantomTimeSerieRequestCAS_FieldPath = (*UpdatePhantomTimeSerieRequestCAS_FieldSubPath)(nil)

func (fps *UpdatePhantomTimeSerieRequestCAS_FieldSubPath) Selector() UpdatePhantomTimeSerieRequestCAS_FieldPathSelector {
	return fps.selector
}
func (fps *UpdatePhantomTimeSerieRequestCAS_FieldSubPath) AsConditionalStateSubPath() (phantom_time_serie.PhantomTimeSerie_FieldPath, bool) {
	res, ok := fps.subPath.(phantom_time_serie.PhantomTimeSerie_FieldPath)
	return res, ok
}

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

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

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

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

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

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

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

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

func (fps *UpdatePhantomTimeSerieRequestCAS_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*UpdatePhantomTimeSerieRequest_CAS))
}

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

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

func (fps *UpdatePhantomTimeSerieRequestCAS_FieldSubPath) WithIValue(value interface{}) UpdatePhantomTimeSerieRequestCAS_FieldPathValue {
	return &UpdatePhantomTimeSerieRequestCAS_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *UpdatePhantomTimeSerieRequestCAS_FieldSubPath) WithIArrayOfValues(values interface{}) UpdatePhantomTimeSerieRequestCAS_FieldPathArrayOfValues {
	return &UpdatePhantomTimeSerieRequestCAS_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *UpdatePhantomTimeSerieRequestCAS_FieldSubPath) WithIArrayItemValue(value interface{}) UpdatePhantomTimeSerieRequestCAS_FieldPathArrayItemValue {
	return &UpdatePhantomTimeSerieRequestCAS_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

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

func ParseUpdatePhantomTimeSerieRequestCAS_FieldPathValue(pathStr, valueStr string) (UpdatePhantomTimeSerieRequestCAS_FieldPathValue, error) {
	fp, err := ParseUpdatePhantomTimeSerieRequestCAS_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.(UpdatePhantomTimeSerieRequestCAS_FieldPathValue), nil
}

func MustParseUpdatePhantomTimeSerieRequestCAS_FieldPathValue(pathStr, valueStr string) UpdatePhantomTimeSerieRequestCAS_FieldPathValue {
	fpv, err := ParseUpdatePhantomTimeSerieRequestCAS_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type UpdatePhantomTimeSerieRequestCAS_FieldTerminalPathValue struct {
	UpdatePhantomTimeSerieRequestCAS_FieldTerminalPath
	value interface{}
}

var _ UpdatePhantomTimeSerieRequestCAS_FieldPathValue = (*UpdatePhantomTimeSerieRequestCAS_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'CAS' as interface{}
func (fpv *UpdatePhantomTimeSerieRequestCAS_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *UpdatePhantomTimeSerieRequestCAS_FieldTerminalPathValue) AsConditionalStateValue() (*phantom_time_serie.PhantomTimeSerie, bool) {
	res, ok := fpv.value.(*phantom_time_serie.PhantomTimeSerie)
	return res, ok
}
func (fpv *UpdatePhantomTimeSerieRequestCAS_FieldTerminalPathValue) AsFieldMaskValue() (*phantom_time_serie.PhantomTimeSerie_FieldMask, bool) {
	res, ok := fpv.value.(*phantom_time_serie.PhantomTimeSerie_FieldMask)
	return res, ok
}

// SetTo stores value for selected field for object CAS
func (fpv *UpdatePhantomTimeSerieRequestCAS_FieldTerminalPathValue) SetTo(target **UpdatePhantomTimeSerieRequest_CAS) {
	if *target == nil {
		*target = new(UpdatePhantomTimeSerieRequest_CAS)
	}
	switch fpv.selector {
	case UpdatePhantomTimeSerieRequestCAS_FieldPathSelectorConditionalState:
		(*target).ConditionalState = fpv.value.(*phantom_time_serie.PhantomTimeSerie)
	case UpdatePhantomTimeSerieRequestCAS_FieldPathSelectorFieldMask:
		(*target).FieldMask = fpv.value.(*phantom_time_serie.PhantomTimeSerie_FieldMask)
	default:
		panic(fmt.Sprintf("Invalid selector for UpdatePhantomTimeSerieRequest_CAS: %d", fpv.selector))
	}
}

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

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

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

type UpdatePhantomTimeSerieRequestCAS_FieldSubPathValue struct {
	UpdatePhantomTimeSerieRequestCAS_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ UpdatePhantomTimeSerieRequestCAS_FieldPathValue = (*UpdatePhantomTimeSerieRequestCAS_FieldSubPathValue)(nil)

func (fpvs *UpdatePhantomTimeSerieRequestCAS_FieldSubPathValue) AsConditionalStatePathValue() (phantom_time_serie.PhantomTimeSerie_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(phantom_time_serie.PhantomTimeSerie_FieldPathValue)
	return res, ok
}

func (fpvs *UpdatePhantomTimeSerieRequestCAS_FieldSubPathValue) SetTo(target **UpdatePhantomTimeSerieRequest_CAS) {
	if *target == nil {
		*target = new(UpdatePhantomTimeSerieRequest_CAS)
	}
	switch fpvs.Selector() {
	case UpdatePhantomTimeSerieRequestCAS_FieldPathSelectorConditionalState:
		fpvs.subPathValue.(phantom_time_serie.PhantomTimeSerie_FieldPathValue).SetTo(&(*target).ConditionalState)
	default:
		panic(fmt.Sprintf("Invalid selector for UpdatePhantomTimeSerieRequest_CAS: %d", fpvs.Selector()))
	}
}

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

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

func (fpvs *UpdatePhantomTimeSerieRequestCAS_FieldSubPathValue) CompareWith(source *UpdatePhantomTimeSerieRequest_CAS) (int, bool) {
	switch fpvs.Selector() {
	case UpdatePhantomTimeSerieRequestCAS_FieldPathSelectorConditionalState:
		return fpvs.subPathValue.(phantom_time_serie.PhantomTimeSerie_FieldPathValue).CompareWith(source.GetConditionalState())
	default:
		panic(fmt.Sprintf("Invalid selector for UpdatePhantomTimeSerieRequest_CAS: %d", fpvs.Selector()))
	}
}

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

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

// ParseUpdatePhantomTimeSerieRequestCAS_FieldPathArrayItemValue parses string and JSON-encoded value to its Value
func ParseUpdatePhantomTimeSerieRequestCAS_FieldPathArrayItemValue(pathStr, valueStr string) (UpdatePhantomTimeSerieRequestCAS_FieldPathArrayItemValue, error) {
	fp, err := ParseUpdatePhantomTimeSerieRequestCAS_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.(UpdatePhantomTimeSerieRequestCAS_FieldPathArrayItemValue), nil
}

func MustParseUpdatePhantomTimeSerieRequestCAS_FieldPathArrayItemValue(pathStr, valueStr string) UpdatePhantomTimeSerieRequestCAS_FieldPathArrayItemValue {
	fpaiv, err := ParseUpdatePhantomTimeSerieRequestCAS_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type UpdatePhantomTimeSerieRequestCAS_FieldTerminalPathArrayItemValue struct {
	UpdatePhantomTimeSerieRequestCAS_FieldTerminalPath
	value interface{}
}

var _ UpdatePhantomTimeSerieRequestCAS_FieldPathArrayItemValue = (*UpdatePhantomTimeSerieRequestCAS_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *UpdatePhantomTimeSerieRequestCAS_FieldTerminalPathArrayItemValue) GetSingle(source *UpdatePhantomTimeSerieRequest_CAS) (interface{}, bool) {
	return nil, false
}

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

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

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

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

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

func ParseUpdatePhantomTimeSerieRequestCAS_FieldPathArrayOfValues(pathStr, valuesStr string) (UpdatePhantomTimeSerieRequestCAS_FieldPathArrayOfValues, error) {
	fp, err := ParseUpdatePhantomTimeSerieRequestCAS_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.(UpdatePhantomTimeSerieRequestCAS_FieldPathArrayOfValues), nil
}

func MustParseUpdatePhantomTimeSerieRequestCAS_FieldPathArrayOfValues(pathStr, valuesStr string) UpdatePhantomTimeSerieRequestCAS_FieldPathArrayOfValues {
	fpaov, err := ParseUpdatePhantomTimeSerieRequestCAS_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type UpdatePhantomTimeSerieRequestCAS_FieldTerminalPathArrayOfValues struct {
	UpdatePhantomTimeSerieRequestCAS_FieldTerminalPath
	values interface{}
}

var _ UpdatePhantomTimeSerieRequestCAS_FieldPathArrayOfValues = (*UpdatePhantomTimeSerieRequestCAS_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *UpdatePhantomTimeSerieRequestCAS_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case UpdatePhantomTimeSerieRequestCAS_FieldPathSelectorConditionalState:
		for _, v := range fpaov.values.([]*phantom_time_serie.PhantomTimeSerie) {
			values = append(values, v)
		}
	case UpdatePhantomTimeSerieRequestCAS_FieldPathSelectorFieldMask:
		for _, v := range fpaov.values.([]*phantom_time_serie.PhantomTimeSerie_FieldMask) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *UpdatePhantomTimeSerieRequestCAS_FieldTerminalPathArrayOfValues) AsConditionalStateArrayOfValues() ([]*phantom_time_serie.PhantomTimeSerie, bool) {
	res, ok := fpaov.values.([]*phantom_time_serie.PhantomTimeSerie)
	return res, ok
}
func (fpaov *UpdatePhantomTimeSerieRequestCAS_FieldTerminalPathArrayOfValues) AsFieldMaskArrayOfValues() ([]*phantom_time_serie.PhantomTimeSerie_FieldMask, bool) {
	res, ok := fpaov.values.([]*phantom_time_serie.PhantomTimeSerie_FieldMask)
	return res, ok
}

type UpdatePhantomTimeSerieRequestCAS_FieldSubPathArrayOfValues struct {
	UpdatePhantomTimeSerieRequestCAS_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ UpdatePhantomTimeSerieRequestCAS_FieldPathArrayOfValues = (*UpdatePhantomTimeSerieRequestCAS_FieldSubPathArrayOfValues)(nil)

func (fpsaov *UpdatePhantomTimeSerieRequestCAS_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *UpdatePhantomTimeSerieRequestCAS_FieldSubPathArrayOfValues) AsConditionalStatePathArrayOfValues() (phantom_time_serie.PhantomTimeSerie_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(phantom_time_serie.PhantomTimeSerie_FieldPathArrayOfValues)
	return res, ok
}

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

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

type DeletePhantomTimeSerieRequest_FieldPathSelector int32

const (
	DeletePhantomTimeSerieRequest_FieldPathSelectorName DeletePhantomTimeSerieRequest_FieldPathSelector = 0
)

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

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

func ParseDeletePhantomTimeSerieRequest_FieldPath(rawField string) (DeletePhantomTimeSerieRequest_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildDeletePhantomTimeSerieRequest_FieldPath(fp)
}

func MustParseDeletePhantomTimeSerieRequest_FieldPath(rawField string) DeletePhantomTimeSerieRequest_FieldPath {
	fp, err := ParseDeletePhantomTimeSerieRequest_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type DeletePhantomTimeSerieRequest_FieldTerminalPath struct {
	selector DeletePhantomTimeSerieRequest_FieldPathSelector
}

var _ DeletePhantomTimeSerieRequest_FieldPath = (*DeletePhantomTimeSerieRequest_FieldTerminalPath)(nil)

func (fp *DeletePhantomTimeSerieRequest_FieldTerminalPath) Selector() DeletePhantomTimeSerieRequest_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

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

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

func (fp *DeletePhantomTimeSerieRequest_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*DeletePhantomTimeSerieRequest))
}

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

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

func (fp *DeletePhantomTimeSerieRequest_FieldTerminalPath) WithIValue(value interface{}) DeletePhantomTimeSerieRequest_FieldPathValue {
	switch fp.selector {
	case DeletePhantomTimeSerieRequest_FieldPathSelectorName:
		return &DeletePhantomTimeSerieRequest_FieldTerminalPathValue{DeletePhantomTimeSerieRequest_FieldTerminalPath: *fp, value: value.(*phantom_time_serie.Reference)}
	default:
		panic(fmt.Sprintf("Invalid selector for DeletePhantomTimeSerieRequest: %d", fp.selector))
	}
}

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

func (fp *DeletePhantomTimeSerieRequest_FieldTerminalPath) WithIArrayOfValues(values interface{}) DeletePhantomTimeSerieRequest_FieldPathArrayOfValues {
	fpaov := &DeletePhantomTimeSerieRequest_FieldTerminalPathArrayOfValues{DeletePhantomTimeSerieRequest_FieldTerminalPath: *fp}
	switch fp.selector {
	case DeletePhantomTimeSerieRequest_FieldPathSelectorName:
		return &DeletePhantomTimeSerieRequest_FieldTerminalPathArrayOfValues{DeletePhantomTimeSerieRequest_FieldTerminalPath: *fp, values: values.([]*phantom_time_serie.Reference)}
	default:
		panic(fmt.Sprintf("Invalid selector for DeletePhantomTimeSerieRequest: %d", fp.selector))
	}
	return fpaov
}

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

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

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

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

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

func MustParseDeletePhantomTimeSerieRequest_FieldPathValue(pathStr, valueStr string) DeletePhantomTimeSerieRequest_FieldPathValue {
	fpv, err := ParseDeletePhantomTimeSerieRequest_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type DeletePhantomTimeSerieRequest_FieldTerminalPathValue struct {
	DeletePhantomTimeSerieRequest_FieldTerminalPath
	value interface{}
}

var _ DeletePhantomTimeSerieRequest_FieldPathValue = (*DeletePhantomTimeSerieRequest_FieldTerminalPathValue)(nil)

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

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

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

// CompareWith compares value in the 'DeletePhantomTimeSerieRequest_FieldTerminalPathValue' with the value under path in 'DeletePhantomTimeSerieRequest'.
func (fpv *DeletePhantomTimeSerieRequest_FieldTerminalPathValue) CompareWith(source *DeletePhantomTimeSerieRequest) (int, bool) {
	switch fpv.selector {
	case DeletePhantomTimeSerieRequest_FieldPathSelectorName:
		leftValue := fpv.value.(*phantom_time_serie.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 DeletePhantomTimeSerieRequest: %d", fpv.selector))
	}
}

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

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

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

func MustParseDeletePhantomTimeSerieRequest_FieldPathArrayItemValue(pathStr, valueStr string) DeletePhantomTimeSerieRequest_FieldPathArrayItemValue {
	fpaiv, err := ParseDeletePhantomTimeSerieRequest_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type DeletePhantomTimeSerieRequest_FieldTerminalPathArrayItemValue struct {
	DeletePhantomTimeSerieRequest_FieldTerminalPath
	value interface{}
}

var _ DeletePhantomTimeSerieRequest_FieldPathArrayItemValue = (*DeletePhantomTimeSerieRequest_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *DeletePhantomTimeSerieRequest_FieldTerminalPathArrayItemValue) GetSingle(source *DeletePhantomTimeSerieRequest) (interface{}, bool) {
	return nil, false
}

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

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

// DeletePhantomTimeSerieRequest_FieldPathArrayOfValues allows storing slice of values for DeletePhantomTimeSerieRequest fields according to their type
type DeletePhantomTimeSerieRequest_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	DeletePhantomTimeSerieRequest_FieldPath
}

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

func MustParseDeletePhantomTimeSerieRequest_FieldPathArrayOfValues(pathStr, valuesStr string) DeletePhantomTimeSerieRequest_FieldPathArrayOfValues {
	fpaov, err := ParseDeletePhantomTimeSerieRequest_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type DeletePhantomTimeSerieRequest_FieldTerminalPathArrayOfValues struct {
	DeletePhantomTimeSerieRequest_FieldTerminalPath
	values interface{}
}

var _ DeletePhantomTimeSerieRequest_FieldPathArrayOfValues = (*DeletePhantomTimeSerieRequest_FieldTerminalPathArrayOfValues)(nil)

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