time_serie_custom.pb.fieldpath.go

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

package 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 (
	rpc "github.com/cloudwan/edgelq-sdk/common/rpc"
	monitoring_common "github.com/cloudwan/edgelq-sdk/monitoring/common/v3"
	project "github.com/cloudwan/edgelq-sdk/monitoring/resources/v3/project"
	time_serie "github.com/cloudwan/edgelq-sdk/monitoring/resources/v3/time_serie"
	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 (
	_ = &rpc.Status{}
	_ = &monitoring_common.LabelDescriptor{}
	_ = &project.Project{}
	_ = &time_serie.Point{}
	_ = &field_mask.FieldMask{}
)

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

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

type ListTimeSeriesRequest_FieldPathSelector int32

const (
	ListTimeSeriesRequest_FieldPathSelectorParent      ListTimeSeriesRequest_FieldPathSelector = 0
	ListTimeSeriesRequest_FieldPathSelectorFilter      ListTimeSeriesRequest_FieldPathSelector = 1
	ListTimeSeriesRequest_FieldPathSelectorInterval    ListTimeSeriesRequest_FieldPathSelector = 2
	ListTimeSeriesRequest_FieldPathSelectorAggregation ListTimeSeriesRequest_FieldPathSelector = 3
	ListTimeSeriesRequest_FieldPathSelectorOrderBy     ListTimeSeriesRequest_FieldPathSelector = 4
	ListTimeSeriesRequest_FieldPathSelectorView        ListTimeSeriesRequest_FieldPathSelector = 5
	ListTimeSeriesRequest_FieldPathSelectorFieldMask   ListTimeSeriesRequest_FieldPathSelector = 6
	ListTimeSeriesRequest_FieldPathSelectorPageSize    ListTimeSeriesRequest_FieldPathSelector = 7
	ListTimeSeriesRequest_FieldPathSelectorPageToken   ListTimeSeriesRequest_FieldPathSelector = 8
)

func (s ListTimeSeriesRequest_FieldPathSelector) String() string {
	switch s {
	case ListTimeSeriesRequest_FieldPathSelectorParent:
		return "parent"
	case ListTimeSeriesRequest_FieldPathSelectorFilter:
		return "filter"
	case ListTimeSeriesRequest_FieldPathSelectorInterval:
		return "interval"
	case ListTimeSeriesRequest_FieldPathSelectorAggregation:
		return "aggregation"
	case ListTimeSeriesRequest_FieldPathSelectorOrderBy:
		return "order_by"
	case ListTimeSeriesRequest_FieldPathSelectorView:
		return "view"
	case ListTimeSeriesRequest_FieldPathSelectorFieldMask:
		return "field_mask"
	case ListTimeSeriesRequest_FieldPathSelectorPageSize:
		return "page_size"
	case ListTimeSeriesRequest_FieldPathSelectorPageToken:
		return "page_token"
	default:
		panic(fmt.Sprintf("Invalid selector for ListTimeSeriesRequest: %d", s))
	}
}

func BuildListTimeSeriesRequest_FieldPath(fp gotenobject.RawFieldPath) (ListTimeSeriesRequest_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object ListTimeSeriesRequest")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "parent":
			return &ListTimeSeriesRequest_FieldTerminalPath{selector: ListTimeSeriesRequest_FieldPathSelectorParent}, nil
		case "filter":
			return &ListTimeSeriesRequest_FieldTerminalPath{selector: ListTimeSeriesRequest_FieldPathSelectorFilter}, nil
		case "interval":
			return &ListTimeSeriesRequest_FieldTerminalPath{selector: ListTimeSeriesRequest_FieldPathSelectorInterval}, nil
		case "aggregation":
			return &ListTimeSeriesRequest_FieldTerminalPath{selector: ListTimeSeriesRequest_FieldPathSelectorAggregation}, nil
		case "order_by", "orderBy", "order-by":
			return &ListTimeSeriesRequest_FieldTerminalPath{selector: ListTimeSeriesRequest_FieldPathSelectorOrderBy}, nil
		case "view":
			return &ListTimeSeriesRequest_FieldTerminalPath{selector: ListTimeSeriesRequest_FieldPathSelectorView}, nil
		case "field_mask", "fieldMask", "field-mask":
			return &ListTimeSeriesRequest_FieldTerminalPath{selector: ListTimeSeriesRequest_FieldPathSelectorFieldMask}, nil
		case "page_size", "pageSize", "page-size":
			return &ListTimeSeriesRequest_FieldTerminalPath{selector: ListTimeSeriesRequest_FieldPathSelectorPageSize}, nil
		case "page_token", "pageToken", "page-token":
			return &ListTimeSeriesRequest_FieldTerminalPath{selector: ListTimeSeriesRequest_FieldPathSelectorPageToken}, nil
		}
	} else {
		switch fp[0] {
		case "interval":
			if subpath, err := monitoring_common.BuildTimeInterval_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &ListTimeSeriesRequest_FieldSubPath{selector: ListTimeSeriesRequest_FieldPathSelectorInterval, subPath: subpath}, nil
			}
		case "aggregation":
			if subpath, err := monitoring_common.BuildAggregation_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &ListTimeSeriesRequest_FieldSubPath{selector: ListTimeSeriesRequest_FieldPathSelectorAggregation, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object ListTimeSeriesRequest", fp)
}

func ParseListTimeSeriesRequest_FieldPath(rawField string) (ListTimeSeriesRequest_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildListTimeSeriesRequest_FieldPath(fp)
}

func MustParseListTimeSeriesRequest_FieldPath(rawField string) ListTimeSeriesRequest_FieldPath {
	fp, err := ParseListTimeSeriesRequest_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type ListTimeSeriesRequest_FieldTerminalPath struct {
	selector ListTimeSeriesRequest_FieldPathSelector
}

var _ ListTimeSeriesRequest_FieldPath = (*ListTimeSeriesRequest_FieldTerminalPath)(nil)

func (fp *ListTimeSeriesRequest_FieldTerminalPath) Selector() ListTimeSeriesRequest_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source ListTimeSeriesRequest
func (fp *ListTimeSeriesRequest_FieldTerminalPath) Get(source *ListTimeSeriesRequest) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case ListTimeSeriesRequest_FieldPathSelectorParent:
			if source.Parent != nil {
				values = append(values, source.Parent)
			}
		case ListTimeSeriesRequest_FieldPathSelectorFilter:
			if source.Filter != nil {
				values = append(values, source.Filter)
			}
		case ListTimeSeriesRequest_FieldPathSelectorInterval:
			if source.Interval != nil {
				values = append(values, source.Interval)
			}
		case ListTimeSeriesRequest_FieldPathSelectorAggregation:
			if source.Aggregation != nil {
				values = append(values, source.Aggregation)
			}
		case ListTimeSeriesRequest_FieldPathSelectorOrderBy:
			values = append(values, source.OrderBy)
		case ListTimeSeriesRequest_FieldPathSelectorView:
			values = append(values, source.View)
		case ListTimeSeriesRequest_FieldPathSelectorFieldMask:
			if source.FieldMask != nil {
				values = append(values, source.FieldMask)
			}
		case ListTimeSeriesRequest_FieldPathSelectorPageSize:
			values = append(values, source.PageSize)
		case ListTimeSeriesRequest_FieldPathSelectorPageToken:
			values = append(values, source.PageToken)
		default:
			panic(fmt.Sprintf("Invalid selector for ListTimeSeriesRequest: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source ListTimeSeriesRequest
func (fp *ListTimeSeriesRequest_FieldTerminalPath) GetSingle(source *ListTimeSeriesRequest) (interface{}, bool) {
	switch fp.selector {
	case ListTimeSeriesRequest_FieldPathSelectorParent:
		res := source.GetParent()
		return res, res != nil
	case ListTimeSeriesRequest_FieldPathSelectorFilter:
		res := source.GetFilter()
		return res, res != nil
	case ListTimeSeriesRequest_FieldPathSelectorInterval:
		res := source.GetInterval()
		return res, res != nil
	case ListTimeSeriesRequest_FieldPathSelectorAggregation:
		res := source.GetAggregation()
		return res, res != nil
	case ListTimeSeriesRequest_FieldPathSelectorOrderBy:
		return source.GetOrderBy(), source != nil
	case ListTimeSeriesRequest_FieldPathSelectorView:
		return source.GetView(), source != nil
	case ListTimeSeriesRequest_FieldPathSelectorFieldMask:
		res := source.GetFieldMask()
		return res, res != nil
	case ListTimeSeriesRequest_FieldPathSelectorPageSize:
		return source.GetPageSize(), source != nil
	case ListTimeSeriesRequest_FieldPathSelectorPageToken:
		return source.GetPageToken(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for ListTimeSeriesRequest: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *ListTimeSeriesRequest_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case ListTimeSeriesRequest_FieldPathSelectorParent:
		return (*project.Name)(nil)
	case ListTimeSeriesRequest_FieldPathSelectorFilter:
		return (*time_serie.Filter)(nil)
	case ListTimeSeriesRequest_FieldPathSelectorInterval:
		return (*monitoring_common.TimeInterval)(nil)
	case ListTimeSeriesRequest_FieldPathSelectorAggregation:
		return (*monitoring_common.Aggregation)(nil)
	case ListTimeSeriesRequest_FieldPathSelectorOrderBy:
		return ""
	case ListTimeSeriesRequest_FieldPathSelectorView:
		return monitoring_common.TimeSeriesView_FULL
	case ListTimeSeriesRequest_FieldPathSelectorFieldMask:
		return (*time_serie.TimeSerie_FieldMask)(nil)
	case ListTimeSeriesRequest_FieldPathSelectorPageSize:
		return int32(0)
	case ListTimeSeriesRequest_FieldPathSelectorPageToken:
		return ""
	default:
		panic(fmt.Sprintf("Invalid selector for ListTimeSeriesRequest: %d", fp.selector))
	}
}

func (fp *ListTimeSeriesRequest_FieldTerminalPath) ClearValue(item *ListTimeSeriesRequest) {
	if item != nil {
		switch fp.selector {
		case ListTimeSeriesRequest_FieldPathSelectorParent:
			item.Parent = nil
		case ListTimeSeriesRequest_FieldPathSelectorFilter:
			item.Filter = nil
		case ListTimeSeriesRequest_FieldPathSelectorInterval:
			item.Interval = nil
		case ListTimeSeriesRequest_FieldPathSelectorAggregation:
			item.Aggregation = nil
		case ListTimeSeriesRequest_FieldPathSelectorOrderBy:
			item.OrderBy = ""
		case ListTimeSeriesRequest_FieldPathSelectorView:
			item.View = monitoring_common.TimeSeriesView_FULL
		case ListTimeSeriesRequest_FieldPathSelectorFieldMask:
			item.FieldMask = nil
		case ListTimeSeriesRequest_FieldPathSelectorPageSize:
			item.PageSize = int32(0)
		case ListTimeSeriesRequest_FieldPathSelectorPageToken:
			item.PageToken = ""
		default:
			panic(fmt.Sprintf("Invalid selector for ListTimeSeriesRequest: %d", fp.selector))
		}
	}
}

func (fp *ListTimeSeriesRequest_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*ListTimeSeriesRequest))
}

// IsLeaf - whether field path is holds simple value
func (fp *ListTimeSeriesRequest_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == ListTimeSeriesRequest_FieldPathSelectorParent ||
		fp.selector == ListTimeSeriesRequest_FieldPathSelectorFilter ||
		fp.selector == ListTimeSeriesRequest_FieldPathSelectorOrderBy ||
		fp.selector == ListTimeSeriesRequest_FieldPathSelectorView ||
		fp.selector == ListTimeSeriesRequest_FieldPathSelectorFieldMask ||
		fp.selector == ListTimeSeriesRequest_FieldPathSelectorPageSize ||
		fp.selector == ListTimeSeriesRequest_FieldPathSelectorPageToken
}

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

func (fp *ListTimeSeriesRequest_FieldTerminalPath) WithIValue(value interface{}) ListTimeSeriesRequest_FieldPathValue {
	switch fp.selector {
	case ListTimeSeriesRequest_FieldPathSelectorParent:
		return &ListTimeSeriesRequest_FieldTerminalPathValue{ListTimeSeriesRequest_FieldTerminalPath: *fp, value: value.(*project.Name)}
	case ListTimeSeriesRequest_FieldPathSelectorFilter:
		return &ListTimeSeriesRequest_FieldTerminalPathValue{ListTimeSeriesRequest_FieldTerminalPath: *fp, value: value.(*time_serie.Filter)}
	case ListTimeSeriesRequest_FieldPathSelectorInterval:
		return &ListTimeSeriesRequest_FieldTerminalPathValue{ListTimeSeriesRequest_FieldTerminalPath: *fp, value: value.(*monitoring_common.TimeInterval)}
	case ListTimeSeriesRequest_FieldPathSelectorAggregation:
		return &ListTimeSeriesRequest_FieldTerminalPathValue{ListTimeSeriesRequest_FieldTerminalPath: *fp, value: value.(*monitoring_common.Aggregation)}
	case ListTimeSeriesRequest_FieldPathSelectorOrderBy:
		return &ListTimeSeriesRequest_FieldTerminalPathValue{ListTimeSeriesRequest_FieldTerminalPath: *fp, value: value.(string)}
	case ListTimeSeriesRequest_FieldPathSelectorView:
		return &ListTimeSeriesRequest_FieldTerminalPathValue{ListTimeSeriesRequest_FieldTerminalPath: *fp, value: value.(monitoring_common.TimeSeriesView)}
	case ListTimeSeriesRequest_FieldPathSelectorFieldMask:
		return &ListTimeSeriesRequest_FieldTerminalPathValue{ListTimeSeriesRequest_FieldTerminalPath: *fp, value: value.(*time_serie.TimeSerie_FieldMask)}
	case ListTimeSeriesRequest_FieldPathSelectorPageSize:
		return &ListTimeSeriesRequest_FieldTerminalPathValue{ListTimeSeriesRequest_FieldTerminalPath: *fp, value: value.(int32)}
	case ListTimeSeriesRequest_FieldPathSelectorPageToken:
		return &ListTimeSeriesRequest_FieldTerminalPathValue{ListTimeSeriesRequest_FieldTerminalPath: *fp, value: value.(string)}
	default:
		panic(fmt.Sprintf("Invalid selector for ListTimeSeriesRequest: %d", fp.selector))
	}
}

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

func (fp *ListTimeSeriesRequest_FieldTerminalPath) WithIArrayOfValues(values interface{}) ListTimeSeriesRequest_FieldPathArrayOfValues {
	fpaov := &ListTimeSeriesRequest_FieldTerminalPathArrayOfValues{ListTimeSeriesRequest_FieldTerminalPath: *fp}
	switch fp.selector {
	case ListTimeSeriesRequest_FieldPathSelectorParent:
		return &ListTimeSeriesRequest_FieldTerminalPathArrayOfValues{ListTimeSeriesRequest_FieldTerminalPath: *fp, values: values.([]*project.Name)}
	case ListTimeSeriesRequest_FieldPathSelectorFilter:
		return &ListTimeSeriesRequest_FieldTerminalPathArrayOfValues{ListTimeSeriesRequest_FieldTerminalPath: *fp, values: values.([]*time_serie.Filter)}
	case ListTimeSeriesRequest_FieldPathSelectorInterval:
		return &ListTimeSeriesRequest_FieldTerminalPathArrayOfValues{ListTimeSeriesRequest_FieldTerminalPath: *fp, values: values.([]*monitoring_common.TimeInterval)}
	case ListTimeSeriesRequest_FieldPathSelectorAggregation:
		return &ListTimeSeriesRequest_FieldTerminalPathArrayOfValues{ListTimeSeriesRequest_FieldTerminalPath: *fp, values: values.([]*monitoring_common.Aggregation)}
	case ListTimeSeriesRequest_FieldPathSelectorOrderBy:
		return &ListTimeSeriesRequest_FieldTerminalPathArrayOfValues{ListTimeSeriesRequest_FieldTerminalPath: *fp, values: values.([]string)}
	case ListTimeSeriesRequest_FieldPathSelectorView:
		return &ListTimeSeriesRequest_FieldTerminalPathArrayOfValues{ListTimeSeriesRequest_FieldTerminalPath: *fp, values: values.([]monitoring_common.TimeSeriesView)}
	case ListTimeSeriesRequest_FieldPathSelectorFieldMask:
		return &ListTimeSeriesRequest_FieldTerminalPathArrayOfValues{ListTimeSeriesRequest_FieldTerminalPath: *fp, values: values.([]*time_serie.TimeSerie_FieldMask)}
	case ListTimeSeriesRequest_FieldPathSelectorPageSize:
		return &ListTimeSeriesRequest_FieldTerminalPathArrayOfValues{ListTimeSeriesRequest_FieldTerminalPath: *fp, values: values.([]int32)}
	case ListTimeSeriesRequest_FieldPathSelectorPageToken:
		return &ListTimeSeriesRequest_FieldTerminalPathArrayOfValues{ListTimeSeriesRequest_FieldTerminalPath: *fp, values: values.([]string)}
	default:
		panic(fmt.Sprintf("Invalid selector for ListTimeSeriesRequest: %d", fp.selector))
	}
	return fpaov
}

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

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

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

type ListTimeSeriesRequest_FieldSubPath struct {
	selector ListTimeSeriesRequest_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ ListTimeSeriesRequest_FieldPath = (*ListTimeSeriesRequest_FieldSubPath)(nil)

func (fps *ListTimeSeriesRequest_FieldSubPath) Selector() ListTimeSeriesRequest_FieldPathSelector {
	return fps.selector
}
func (fps *ListTimeSeriesRequest_FieldSubPath) AsIntervalSubPath() (monitoring_common.TimeInterval_FieldPath, bool) {
	res, ok := fps.subPath.(monitoring_common.TimeInterval_FieldPath)
	return res, ok
}
func (fps *ListTimeSeriesRequest_FieldSubPath) AsAggregationSubPath() (monitoring_common.Aggregation_FieldPath, bool) {
	res, ok := fps.subPath.(monitoring_common.Aggregation_FieldPath)
	return res, ok
}

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

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

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

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

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

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

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

func (fps *ListTimeSeriesRequest_FieldSubPath) ClearValue(item *ListTimeSeriesRequest) {
	if item != nil {
		switch fps.selector {
		case ListTimeSeriesRequest_FieldPathSelectorInterval:
			fps.subPath.ClearValueRaw(item.Interval)
		case ListTimeSeriesRequest_FieldPathSelectorAggregation:
			fps.subPath.ClearValueRaw(item.Aggregation)
		default:
			panic(fmt.Sprintf("Invalid selector for ListTimeSeriesRequest: %d", fps.selector))
		}
	}
}

func (fps *ListTimeSeriesRequest_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*ListTimeSeriesRequest))
}

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

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

func (fps *ListTimeSeriesRequest_FieldSubPath) WithIValue(value interface{}) ListTimeSeriesRequest_FieldPathValue {
	return &ListTimeSeriesRequest_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *ListTimeSeriesRequest_FieldSubPath) WithIArrayOfValues(values interface{}) ListTimeSeriesRequest_FieldPathArrayOfValues {
	return &ListTimeSeriesRequest_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *ListTimeSeriesRequest_FieldSubPath) WithIArrayItemValue(value interface{}) ListTimeSeriesRequest_FieldPathArrayItemValue {
	return &ListTimeSeriesRequest_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

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

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

func MustParseListTimeSeriesRequest_FieldPathValue(pathStr, valueStr string) ListTimeSeriesRequest_FieldPathValue {
	fpv, err := ParseListTimeSeriesRequest_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type ListTimeSeriesRequest_FieldTerminalPathValue struct {
	ListTimeSeriesRequest_FieldTerminalPath
	value interface{}
}

var _ ListTimeSeriesRequest_FieldPathValue = (*ListTimeSeriesRequest_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'ListTimeSeriesRequest' as interface{}
func (fpv *ListTimeSeriesRequest_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *ListTimeSeriesRequest_FieldTerminalPathValue) AsParentValue() (*project.Name, bool) {
	res, ok := fpv.value.(*project.Name)
	return res, ok
}
func (fpv *ListTimeSeriesRequest_FieldTerminalPathValue) AsFilterValue() (*time_serie.Filter, bool) {
	res, ok := fpv.value.(*time_serie.Filter)
	return res, ok
}
func (fpv *ListTimeSeriesRequest_FieldTerminalPathValue) AsIntervalValue() (*monitoring_common.TimeInterval, bool) {
	res, ok := fpv.value.(*monitoring_common.TimeInterval)
	return res, ok
}
func (fpv *ListTimeSeriesRequest_FieldTerminalPathValue) AsAggregationValue() (*monitoring_common.Aggregation, bool) {
	res, ok := fpv.value.(*monitoring_common.Aggregation)
	return res, ok
}
func (fpv *ListTimeSeriesRequest_FieldTerminalPathValue) AsOrderByValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *ListTimeSeriesRequest_FieldTerminalPathValue) AsViewValue() (monitoring_common.TimeSeriesView, bool) {
	res, ok := fpv.value.(monitoring_common.TimeSeriesView)
	return res, ok
}
func (fpv *ListTimeSeriesRequest_FieldTerminalPathValue) AsFieldMaskValue() (*time_serie.TimeSerie_FieldMask, bool) {
	res, ok := fpv.value.(*time_serie.TimeSerie_FieldMask)
	return res, ok
}
func (fpv *ListTimeSeriesRequest_FieldTerminalPathValue) AsPageSizeValue() (int32, bool) {
	res, ok := fpv.value.(int32)
	return res, ok
}
func (fpv *ListTimeSeriesRequest_FieldTerminalPathValue) AsPageTokenValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}

// SetTo stores value for selected field for object ListTimeSeriesRequest
func (fpv *ListTimeSeriesRequest_FieldTerminalPathValue) SetTo(target **ListTimeSeriesRequest) {
	if *target == nil {
		*target = new(ListTimeSeriesRequest)
	}
	switch fpv.selector {
	case ListTimeSeriesRequest_FieldPathSelectorParent:
		(*target).Parent = fpv.value.(*project.Name)
	case ListTimeSeriesRequest_FieldPathSelectorFilter:
		(*target).Filter = fpv.value.(*time_serie.Filter)
	case ListTimeSeriesRequest_FieldPathSelectorInterval:
		(*target).Interval = fpv.value.(*monitoring_common.TimeInterval)
	case ListTimeSeriesRequest_FieldPathSelectorAggregation:
		(*target).Aggregation = fpv.value.(*monitoring_common.Aggregation)
	case ListTimeSeriesRequest_FieldPathSelectorOrderBy:
		(*target).OrderBy = fpv.value.(string)
	case ListTimeSeriesRequest_FieldPathSelectorView:
		(*target).View = fpv.value.(monitoring_common.TimeSeriesView)
	case ListTimeSeriesRequest_FieldPathSelectorFieldMask:
		(*target).FieldMask = fpv.value.(*time_serie.TimeSerie_FieldMask)
	case ListTimeSeriesRequest_FieldPathSelectorPageSize:
		(*target).PageSize = fpv.value.(int32)
	case ListTimeSeriesRequest_FieldPathSelectorPageToken:
		(*target).PageToken = fpv.value.(string)
	default:
		panic(fmt.Sprintf("Invalid selector for ListTimeSeriesRequest: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'ListTimeSeriesRequest_FieldTerminalPathValue' with the value under path in 'ListTimeSeriesRequest'.
func (fpv *ListTimeSeriesRequest_FieldTerminalPathValue) CompareWith(source *ListTimeSeriesRequest) (int, bool) {
	switch fpv.selector {
	case ListTimeSeriesRequest_FieldPathSelectorParent:
		leftValue := fpv.value.(*project.Name)
		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 ListTimeSeriesRequest_FieldPathSelectorFilter:
		return 0, false
	case ListTimeSeriesRequest_FieldPathSelectorInterval:
		return 0, false
	case ListTimeSeriesRequest_FieldPathSelectorAggregation:
		return 0, false
	case ListTimeSeriesRequest_FieldPathSelectorOrderBy:
		leftValue := fpv.value.(string)
		rightValue := source.GetOrderBy()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case ListTimeSeriesRequest_FieldPathSelectorView:
		leftValue := fpv.value.(monitoring_common.TimeSeriesView)
		rightValue := source.GetView()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case ListTimeSeriesRequest_FieldPathSelectorFieldMask:
		return 0, false
	case ListTimeSeriesRequest_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 ListTimeSeriesRequest_FieldPathSelectorPageToken:
		leftValue := fpv.value.(string)
		rightValue := source.GetPageToken()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for ListTimeSeriesRequest: %d", fpv.selector))
	}
}

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

type ListTimeSeriesRequest_FieldSubPathValue struct {
	ListTimeSeriesRequest_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ ListTimeSeriesRequest_FieldPathValue = (*ListTimeSeriesRequest_FieldSubPathValue)(nil)

func (fpvs *ListTimeSeriesRequest_FieldSubPathValue) AsIntervalPathValue() (monitoring_common.TimeInterval_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(monitoring_common.TimeInterval_FieldPathValue)
	return res, ok
}
func (fpvs *ListTimeSeriesRequest_FieldSubPathValue) AsAggregationPathValue() (monitoring_common.Aggregation_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(monitoring_common.Aggregation_FieldPathValue)
	return res, ok
}

func (fpvs *ListTimeSeriesRequest_FieldSubPathValue) SetTo(target **ListTimeSeriesRequest) {
	if *target == nil {
		*target = new(ListTimeSeriesRequest)
	}
	switch fpvs.Selector() {
	case ListTimeSeriesRequest_FieldPathSelectorInterval:
		fpvs.subPathValue.(monitoring_common.TimeInterval_FieldPathValue).SetTo(&(*target).Interval)
	case ListTimeSeriesRequest_FieldPathSelectorAggregation:
		fpvs.subPathValue.(monitoring_common.Aggregation_FieldPathValue).SetTo(&(*target).Aggregation)
	default:
		panic(fmt.Sprintf("Invalid selector for ListTimeSeriesRequest: %d", fpvs.Selector()))
	}
}

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

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

func (fpvs *ListTimeSeriesRequest_FieldSubPathValue) CompareWith(source *ListTimeSeriesRequest) (int, bool) {
	switch fpvs.Selector() {
	case ListTimeSeriesRequest_FieldPathSelectorInterval:
		return fpvs.subPathValue.(monitoring_common.TimeInterval_FieldPathValue).CompareWith(source.GetInterval())
	case ListTimeSeriesRequest_FieldPathSelectorAggregation:
		return fpvs.subPathValue.(monitoring_common.Aggregation_FieldPathValue).CompareWith(source.GetAggregation())
	default:
		panic(fmt.Sprintf("Invalid selector for ListTimeSeriesRequest: %d", fpvs.Selector()))
	}
}

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

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

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

func MustParseListTimeSeriesRequest_FieldPathArrayItemValue(pathStr, valueStr string) ListTimeSeriesRequest_FieldPathArrayItemValue {
	fpaiv, err := ParseListTimeSeriesRequest_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type ListTimeSeriesRequest_FieldTerminalPathArrayItemValue struct {
	ListTimeSeriesRequest_FieldTerminalPath
	value interface{}
}

var _ ListTimeSeriesRequest_FieldPathArrayItemValue = (*ListTimeSeriesRequest_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *ListTimeSeriesRequest_FieldTerminalPathArrayItemValue) GetSingle(source *ListTimeSeriesRequest) (interface{}, bool) {
	return nil, false
}

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

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

// GetRawValue returns stored array item value
func (fpaivs *ListTimeSeriesRequest_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *ListTimeSeriesRequest_FieldSubPathArrayItemValue) AsIntervalPathItemValue() (monitoring_common.TimeInterval_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(monitoring_common.TimeInterval_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *ListTimeSeriesRequest_FieldSubPathArrayItemValue) AsAggregationPathItemValue() (monitoring_common.Aggregation_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(monitoring_common.Aggregation_FieldPathArrayItemValue)
	return res, ok
}

// Contains returns a boolean indicating if value that is being held is present in given 'ListTimeSeriesRequest'
func (fpaivs *ListTimeSeriesRequest_FieldSubPathArrayItemValue) ContainsValue(source *ListTimeSeriesRequest) bool {
	switch fpaivs.Selector() {
	case ListTimeSeriesRequest_FieldPathSelectorInterval:
		return fpaivs.subPathItemValue.(monitoring_common.TimeInterval_FieldPathArrayItemValue).ContainsValue(source.GetInterval())
	case ListTimeSeriesRequest_FieldPathSelectorAggregation:
		return fpaivs.subPathItemValue.(monitoring_common.Aggregation_FieldPathArrayItemValue).ContainsValue(source.GetAggregation())
	default:
		panic(fmt.Sprintf("Invalid selector for ListTimeSeriesRequest: %d", fpaivs.Selector()))
	}
}

// ListTimeSeriesRequest_FieldPathArrayOfValues allows storing slice of values for ListTimeSeriesRequest fields according to their type
type ListTimeSeriesRequest_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	ListTimeSeriesRequest_FieldPath
}

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

func MustParseListTimeSeriesRequest_FieldPathArrayOfValues(pathStr, valuesStr string) ListTimeSeriesRequest_FieldPathArrayOfValues {
	fpaov, err := ParseListTimeSeriesRequest_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type ListTimeSeriesRequest_FieldTerminalPathArrayOfValues struct {
	ListTimeSeriesRequest_FieldTerminalPath
	values interface{}
}

var _ ListTimeSeriesRequest_FieldPathArrayOfValues = (*ListTimeSeriesRequest_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *ListTimeSeriesRequest_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case ListTimeSeriesRequest_FieldPathSelectorParent:
		for _, v := range fpaov.values.([]*project.Name) {
			values = append(values, v)
		}
	case ListTimeSeriesRequest_FieldPathSelectorFilter:
		for _, v := range fpaov.values.([]*time_serie.Filter) {
			values = append(values, v)
		}
	case ListTimeSeriesRequest_FieldPathSelectorInterval:
		for _, v := range fpaov.values.([]*monitoring_common.TimeInterval) {
			values = append(values, v)
		}
	case ListTimeSeriesRequest_FieldPathSelectorAggregation:
		for _, v := range fpaov.values.([]*monitoring_common.Aggregation) {
			values = append(values, v)
		}
	case ListTimeSeriesRequest_FieldPathSelectorOrderBy:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case ListTimeSeriesRequest_FieldPathSelectorView:
		for _, v := range fpaov.values.([]monitoring_common.TimeSeriesView) {
			values = append(values, v)
		}
	case ListTimeSeriesRequest_FieldPathSelectorFieldMask:
		for _, v := range fpaov.values.([]*time_serie.TimeSerie_FieldMask) {
			values = append(values, v)
		}
	case ListTimeSeriesRequest_FieldPathSelectorPageSize:
		for _, v := range fpaov.values.([]int32) {
			values = append(values, v)
		}
	case ListTimeSeriesRequest_FieldPathSelectorPageToken:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *ListTimeSeriesRequest_FieldTerminalPathArrayOfValues) AsParentArrayOfValues() ([]*project.Name, bool) {
	res, ok := fpaov.values.([]*project.Name)
	return res, ok
}
func (fpaov *ListTimeSeriesRequest_FieldTerminalPathArrayOfValues) AsFilterArrayOfValues() ([]*time_serie.Filter, bool) {
	res, ok := fpaov.values.([]*time_serie.Filter)
	return res, ok
}
func (fpaov *ListTimeSeriesRequest_FieldTerminalPathArrayOfValues) AsIntervalArrayOfValues() ([]*monitoring_common.TimeInterval, bool) {
	res, ok := fpaov.values.([]*monitoring_common.TimeInterval)
	return res, ok
}
func (fpaov *ListTimeSeriesRequest_FieldTerminalPathArrayOfValues) AsAggregationArrayOfValues() ([]*monitoring_common.Aggregation, bool) {
	res, ok := fpaov.values.([]*monitoring_common.Aggregation)
	return res, ok
}
func (fpaov *ListTimeSeriesRequest_FieldTerminalPathArrayOfValues) AsOrderByArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *ListTimeSeriesRequest_FieldTerminalPathArrayOfValues) AsViewArrayOfValues() ([]monitoring_common.TimeSeriesView, bool) {
	res, ok := fpaov.values.([]monitoring_common.TimeSeriesView)
	return res, ok
}
func (fpaov *ListTimeSeriesRequest_FieldTerminalPathArrayOfValues) AsFieldMaskArrayOfValues() ([]*time_serie.TimeSerie_FieldMask, bool) {
	res, ok := fpaov.values.([]*time_serie.TimeSerie_FieldMask)
	return res, ok
}
func (fpaov *ListTimeSeriesRequest_FieldTerminalPathArrayOfValues) AsPageSizeArrayOfValues() ([]int32, bool) {
	res, ok := fpaov.values.([]int32)
	return res, ok
}
func (fpaov *ListTimeSeriesRequest_FieldTerminalPathArrayOfValues) AsPageTokenArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}

type ListTimeSeriesRequest_FieldSubPathArrayOfValues struct {
	ListTimeSeriesRequest_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ ListTimeSeriesRequest_FieldPathArrayOfValues = (*ListTimeSeriesRequest_FieldSubPathArrayOfValues)(nil)

func (fpsaov *ListTimeSeriesRequest_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *ListTimeSeriesRequest_FieldSubPathArrayOfValues) AsIntervalPathArrayOfValues() (monitoring_common.TimeInterval_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(monitoring_common.TimeInterval_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *ListTimeSeriesRequest_FieldSubPathArrayOfValues) AsAggregationPathArrayOfValues() (monitoring_common.Aggregation_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(monitoring_common.Aggregation_FieldPathArrayOfValues)
	return res, ok
}

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

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

type ListTimeSeriesResponse_FieldPathSelector int32

const (
	ListTimeSeriesResponse_FieldPathSelectorTimeSeries      ListTimeSeriesResponse_FieldPathSelector = 0
	ListTimeSeriesResponse_FieldPathSelectorNextPageToken   ListTimeSeriesResponse_FieldPathSelector = 1
	ListTimeSeriesResponse_FieldPathSelectorExecutionErrors ListTimeSeriesResponse_FieldPathSelector = 2
)

func (s ListTimeSeriesResponse_FieldPathSelector) String() string {
	switch s {
	case ListTimeSeriesResponse_FieldPathSelectorTimeSeries:
		return "time_series"
	case ListTimeSeriesResponse_FieldPathSelectorNextPageToken:
		return "next_page_token"
	case ListTimeSeriesResponse_FieldPathSelectorExecutionErrors:
		return "execution_errors"
	default:
		panic(fmt.Sprintf("Invalid selector for ListTimeSeriesResponse: %d", s))
	}
}

func BuildListTimeSeriesResponse_FieldPath(fp gotenobject.RawFieldPath) (ListTimeSeriesResponse_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object ListTimeSeriesResponse")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "time_series", "timeSeries", "time-series":
			return &ListTimeSeriesResponse_FieldTerminalPath{selector: ListTimeSeriesResponse_FieldPathSelectorTimeSeries}, nil
		case "next_page_token", "nextPageToken", "next-page-token":
			return &ListTimeSeriesResponse_FieldTerminalPath{selector: ListTimeSeriesResponse_FieldPathSelectorNextPageToken}, nil
		case "execution_errors", "executionErrors", "execution-errors":
			return &ListTimeSeriesResponse_FieldTerminalPath{selector: ListTimeSeriesResponse_FieldPathSelectorExecutionErrors}, nil
		}
	} else {
		switch fp[0] {
		case "time_series", "timeSeries", "time-series":
			if subpath, err := time_serie.BuildTimeSerie_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &ListTimeSeriesResponse_FieldSubPath{selector: ListTimeSeriesResponse_FieldPathSelectorTimeSeries, subPath: subpath}, nil
			}
		case "execution_errors", "executionErrors", "execution-errors":
			if subpath, err := rpc.BuildStatus_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &ListTimeSeriesResponse_FieldSubPath{selector: ListTimeSeriesResponse_FieldPathSelectorExecutionErrors, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object ListTimeSeriesResponse", fp)
}

func ParseListTimeSeriesResponse_FieldPath(rawField string) (ListTimeSeriesResponse_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildListTimeSeriesResponse_FieldPath(fp)
}

func MustParseListTimeSeriesResponse_FieldPath(rawField string) ListTimeSeriesResponse_FieldPath {
	fp, err := ParseListTimeSeriesResponse_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type ListTimeSeriesResponse_FieldTerminalPath struct {
	selector ListTimeSeriesResponse_FieldPathSelector
}

var _ ListTimeSeriesResponse_FieldPath = (*ListTimeSeriesResponse_FieldTerminalPath)(nil)

func (fp *ListTimeSeriesResponse_FieldTerminalPath) Selector() ListTimeSeriesResponse_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source ListTimeSeriesResponse
func (fp *ListTimeSeriesResponse_FieldTerminalPath) Get(source *ListTimeSeriesResponse) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case ListTimeSeriesResponse_FieldPathSelectorTimeSeries:
			for _, value := range source.GetTimeSeries() {
				values = append(values, value)
			}
		case ListTimeSeriesResponse_FieldPathSelectorNextPageToken:
			values = append(values, source.NextPageToken)
		case ListTimeSeriesResponse_FieldPathSelectorExecutionErrors:
			for _, value := range source.GetExecutionErrors() {
				values = append(values, value)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for ListTimeSeriesResponse: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source ListTimeSeriesResponse
func (fp *ListTimeSeriesResponse_FieldTerminalPath) GetSingle(source *ListTimeSeriesResponse) (interface{}, bool) {
	switch fp.selector {
	case ListTimeSeriesResponse_FieldPathSelectorTimeSeries:
		res := source.GetTimeSeries()
		return res, res != nil
	case ListTimeSeriesResponse_FieldPathSelectorNextPageToken:
		return source.GetNextPageToken(), source != nil
	case ListTimeSeriesResponse_FieldPathSelectorExecutionErrors:
		res := source.GetExecutionErrors()
		return res, res != nil
	default:
		panic(fmt.Sprintf("Invalid selector for ListTimeSeriesResponse: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *ListTimeSeriesResponse_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case ListTimeSeriesResponse_FieldPathSelectorTimeSeries:
		return ([]*time_serie.TimeSerie)(nil)
	case ListTimeSeriesResponse_FieldPathSelectorNextPageToken:
		return ""
	case ListTimeSeriesResponse_FieldPathSelectorExecutionErrors:
		return ([]*rpc.Status)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for ListTimeSeriesResponse: %d", fp.selector))
	}
}

func (fp *ListTimeSeriesResponse_FieldTerminalPath) ClearValue(item *ListTimeSeriesResponse) {
	if item != nil {
		switch fp.selector {
		case ListTimeSeriesResponse_FieldPathSelectorTimeSeries:
			item.TimeSeries = nil
		case ListTimeSeriesResponse_FieldPathSelectorNextPageToken:
			item.NextPageToken = ""
		case ListTimeSeriesResponse_FieldPathSelectorExecutionErrors:
			item.ExecutionErrors = nil
		default:
			panic(fmt.Sprintf("Invalid selector for ListTimeSeriesResponse: %d", fp.selector))
		}
	}
}

func (fp *ListTimeSeriesResponse_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*ListTimeSeriesResponse))
}

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

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

func (fp *ListTimeSeriesResponse_FieldTerminalPath) WithIValue(value interface{}) ListTimeSeriesResponse_FieldPathValue {
	switch fp.selector {
	case ListTimeSeriesResponse_FieldPathSelectorTimeSeries:
		return &ListTimeSeriesResponse_FieldTerminalPathValue{ListTimeSeriesResponse_FieldTerminalPath: *fp, value: value.([]*time_serie.TimeSerie)}
	case ListTimeSeriesResponse_FieldPathSelectorNextPageToken:
		return &ListTimeSeriesResponse_FieldTerminalPathValue{ListTimeSeriesResponse_FieldTerminalPath: *fp, value: value.(string)}
	case ListTimeSeriesResponse_FieldPathSelectorExecutionErrors:
		return &ListTimeSeriesResponse_FieldTerminalPathValue{ListTimeSeriesResponse_FieldTerminalPath: *fp, value: value.([]*rpc.Status)}
	default:
		panic(fmt.Sprintf("Invalid selector for ListTimeSeriesResponse: %d", fp.selector))
	}
}

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

func (fp *ListTimeSeriesResponse_FieldTerminalPath) WithIArrayOfValues(values interface{}) ListTimeSeriesResponse_FieldPathArrayOfValues {
	fpaov := &ListTimeSeriesResponse_FieldTerminalPathArrayOfValues{ListTimeSeriesResponse_FieldTerminalPath: *fp}
	switch fp.selector {
	case ListTimeSeriesResponse_FieldPathSelectorTimeSeries:
		return &ListTimeSeriesResponse_FieldTerminalPathArrayOfValues{ListTimeSeriesResponse_FieldTerminalPath: *fp, values: values.([][]*time_serie.TimeSerie)}
	case ListTimeSeriesResponse_FieldPathSelectorNextPageToken:
		return &ListTimeSeriesResponse_FieldTerminalPathArrayOfValues{ListTimeSeriesResponse_FieldTerminalPath: *fp, values: values.([]string)}
	case ListTimeSeriesResponse_FieldPathSelectorExecutionErrors:
		return &ListTimeSeriesResponse_FieldTerminalPathArrayOfValues{ListTimeSeriesResponse_FieldTerminalPath: *fp, values: values.([][]*rpc.Status)}
	default:
		panic(fmt.Sprintf("Invalid selector for ListTimeSeriesResponse: %d", fp.selector))
	}
	return fpaov
}

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

func (fp *ListTimeSeriesResponse_FieldTerminalPath) WithIArrayItemValue(value interface{}) ListTimeSeriesResponse_FieldPathArrayItemValue {
	switch fp.selector {
	case ListTimeSeriesResponse_FieldPathSelectorTimeSeries:
		return &ListTimeSeriesResponse_FieldTerminalPathArrayItemValue{ListTimeSeriesResponse_FieldTerminalPath: *fp, value: value.(*time_serie.TimeSerie)}
	case ListTimeSeriesResponse_FieldPathSelectorExecutionErrors:
		return &ListTimeSeriesResponse_FieldTerminalPathArrayItemValue{ListTimeSeriesResponse_FieldTerminalPath: *fp, value: value.(*rpc.Status)}
	default:
		panic(fmt.Sprintf("Invalid selector for ListTimeSeriesResponse: %d", fp.selector))
	}
}

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

type ListTimeSeriesResponse_FieldSubPath struct {
	selector ListTimeSeriesResponse_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ ListTimeSeriesResponse_FieldPath = (*ListTimeSeriesResponse_FieldSubPath)(nil)

func (fps *ListTimeSeriesResponse_FieldSubPath) Selector() ListTimeSeriesResponse_FieldPathSelector {
	return fps.selector
}
func (fps *ListTimeSeriesResponse_FieldSubPath) AsTimeSeriesSubPath() (time_serie.TimeSerie_FieldPath, bool) {
	res, ok := fps.subPath.(time_serie.TimeSerie_FieldPath)
	return res, ok
}
func (fps *ListTimeSeriesResponse_FieldSubPath) AsExecutionErrorsSubPath() (rpc.Status_FieldPath, bool) {
	res, ok := fps.subPath.(rpc.Status_FieldPath)
	return res, ok
}

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

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

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

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

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

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

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

func (fps *ListTimeSeriesResponse_FieldSubPath) ClearValue(item *ListTimeSeriesResponse) {
	if item != nil {
		switch fps.selector {
		case ListTimeSeriesResponse_FieldPathSelectorTimeSeries:
			for _, subItem := range item.TimeSeries {
				fps.subPath.ClearValueRaw(subItem)
			}
		case ListTimeSeriesResponse_FieldPathSelectorExecutionErrors:
			for _, subItem := range item.ExecutionErrors {
				fps.subPath.ClearValueRaw(subItem)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for ListTimeSeriesResponse: %d", fps.selector))
		}
	}
}

func (fps *ListTimeSeriesResponse_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*ListTimeSeriesResponse))
}

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

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

func (fps *ListTimeSeriesResponse_FieldSubPath) WithIValue(value interface{}) ListTimeSeriesResponse_FieldPathValue {
	return &ListTimeSeriesResponse_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *ListTimeSeriesResponse_FieldSubPath) WithIArrayOfValues(values interface{}) ListTimeSeriesResponse_FieldPathArrayOfValues {
	return &ListTimeSeriesResponse_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *ListTimeSeriesResponse_FieldSubPath) WithIArrayItemValue(value interface{}) ListTimeSeriesResponse_FieldPathArrayItemValue {
	return &ListTimeSeriesResponse_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

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

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

func MustParseListTimeSeriesResponse_FieldPathValue(pathStr, valueStr string) ListTimeSeriesResponse_FieldPathValue {
	fpv, err := ParseListTimeSeriesResponse_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type ListTimeSeriesResponse_FieldTerminalPathValue struct {
	ListTimeSeriesResponse_FieldTerminalPath
	value interface{}
}

var _ ListTimeSeriesResponse_FieldPathValue = (*ListTimeSeriesResponse_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'ListTimeSeriesResponse' as interface{}
func (fpv *ListTimeSeriesResponse_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *ListTimeSeriesResponse_FieldTerminalPathValue) AsTimeSeriesValue() ([]*time_serie.TimeSerie, bool) {
	res, ok := fpv.value.([]*time_serie.TimeSerie)
	return res, ok
}
func (fpv *ListTimeSeriesResponse_FieldTerminalPathValue) AsNextPageTokenValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *ListTimeSeriesResponse_FieldTerminalPathValue) AsExecutionErrorsValue() ([]*rpc.Status, bool) {
	res, ok := fpv.value.([]*rpc.Status)
	return res, ok
}

// SetTo stores value for selected field for object ListTimeSeriesResponse
func (fpv *ListTimeSeriesResponse_FieldTerminalPathValue) SetTo(target **ListTimeSeriesResponse) {
	if *target == nil {
		*target = new(ListTimeSeriesResponse)
	}
	switch fpv.selector {
	case ListTimeSeriesResponse_FieldPathSelectorTimeSeries:
		(*target).TimeSeries = fpv.value.([]*time_serie.TimeSerie)
	case ListTimeSeriesResponse_FieldPathSelectorNextPageToken:
		(*target).NextPageToken = fpv.value.(string)
	case ListTimeSeriesResponse_FieldPathSelectorExecutionErrors:
		(*target).ExecutionErrors = fpv.value.([]*rpc.Status)
	default:
		panic(fmt.Sprintf("Invalid selector for ListTimeSeriesResponse: %d", fpv.selector))
	}
}

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

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

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

type ListTimeSeriesResponse_FieldSubPathValue struct {
	ListTimeSeriesResponse_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ ListTimeSeriesResponse_FieldPathValue = (*ListTimeSeriesResponse_FieldSubPathValue)(nil)

func (fpvs *ListTimeSeriesResponse_FieldSubPathValue) AsTimeSeriesPathValue() (time_serie.TimeSerie_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(time_serie.TimeSerie_FieldPathValue)
	return res, ok
}
func (fpvs *ListTimeSeriesResponse_FieldSubPathValue) AsExecutionErrorsPathValue() (rpc.Status_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(rpc.Status_FieldPathValue)
	return res, ok
}

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

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

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

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

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

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

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

func MustParseListTimeSeriesResponse_FieldPathArrayItemValue(pathStr, valueStr string) ListTimeSeriesResponse_FieldPathArrayItemValue {
	fpaiv, err := ParseListTimeSeriesResponse_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type ListTimeSeriesResponse_FieldTerminalPathArrayItemValue struct {
	ListTimeSeriesResponse_FieldTerminalPath
	value interface{}
}

var _ ListTimeSeriesResponse_FieldPathArrayItemValue = (*ListTimeSeriesResponse_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object ListTimeSeriesResponse as interface{}
func (fpaiv *ListTimeSeriesResponse_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}
func (fpaiv *ListTimeSeriesResponse_FieldTerminalPathArrayItemValue) AsTimeSeriesItemValue() (*time_serie.TimeSerie, bool) {
	res, ok := fpaiv.value.(*time_serie.TimeSerie)
	return res, ok
}
func (fpaiv *ListTimeSeriesResponse_FieldTerminalPathArrayItemValue) AsExecutionErrorsItemValue() (*rpc.Status, bool) {
	res, ok := fpaiv.value.(*rpc.Status)
	return res, ok
}

func (fpaiv *ListTimeSeriesResponse_FieldTerminalPathArrayItemValue) GetSingle(source *ListTimeSeriesResponse) (interface{}, bool) {
	return nil, false
}

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

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

// GetRawValue returns stored array item value
func (fpaivs *ListTimeSeriesResponse_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *ListTimeSeriesResponse_FieldSubPathArrayItemValue) AsTimeSeriesPathItemValue() (time_serie.TimeSerie_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(time_serie.TimeSerie_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *ListTimeSeriesResponse_FieldSubPathArrayItemValue) AsExecutionErrorsPathItemValue() (rpc.Status_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(rpc.Status_FieldPathArrayItemValue)
	return res, ok
}

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

// ListTimeSeriesResponse_FieldPathArrayOfValues allows storing slice of values for ListTimeSeriesResponse fields according to their type
type ListTimeSeriesResponse_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	ListTimeSeriesResponse_FieldPath
}

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

func MustParseListTimeSeriesResponse_FieldPathArrayOfValues(pathStr, valuesStr string) ListTimeSeriesResponse_FieldPathArrayOfValues {
	fpaov, err := ParseListTimeSeriesResponse_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type ListTimeSeriesResponse_FieldTerminalPathArrayOfValues struct {
	ListTimeSeriesResponse_FieldTerminalPath
	values interface{}
}

var _ ListTimeSeriesResponse_FieldPathArrayOfValues = (*ListTimeSeriesResponse_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *ListTimeSeriesResponse_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case ListTimeSeriesResponse_FieldPathSelectorTimeSeries:
		for _, v := range fpaov.values.([][]*time_serie.TimeSerie) {
			values = append(values, v)
		}
	case ListTimeSeriesResponse_FieldPathSelectorNextPageToken:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case ListTimeSeriesResponse_FieldPathSelectorExecutionErrors:
		for _, v := range fpaov.values.([][]*rpc.Status) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *ListTimeSeriesResponse_FieldTerminalPathArrayOfValues) AsTimeSeriesArrayOfValues() ([][]*time_serie.TimeSerie, bool) {
	res, ok := fpaov.values.([][]*time_serie.TimeSerie)
	return res, ok
}
func (fpaov *ListTimeSeriesResponse_FieldTerminalPathArrayOfValues) AsNextPageTokenArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *ListTimeSeriesResponse_FieldTerminalPathArrayOfValues) AsExecutionErrorsArrayOfValues() ([][]*rpc.Status, bool) {
	res, ok := fpaov.values.([][]*rpc.Status)
	return res, ok
}

type ListTimeSeriesResponse_FieldSubPathArrayOfValues struct {
	ListTimeSeriesResponse_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ ListTimeSeriesResponse_FieldPathArrayOfValues = (*ListTimeSeriesResponse_FieldSubPathArrayOfValues)(nil)

func (fpsaov *ListTimeSeriesResponse_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *ListTimeSeriesResponse_FieldSubPathArrayOfValues) AsTimeSeriesPathArrayOfValues() (time_serie.TimeSerie_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(time_serie.TimeSerie_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *ListTimeSeriesResponse_FieldSubPathArrayOfValues) AsExecutionErrorsPathArrayOfValues() (rpc.Status_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(rpc.Status_FieldPathArrayOfValues)
	return res, ok
}

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

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

type ListTimeSeriesResponseErrorDetails_FieldPathSelector int32

const (
	ListTimeSeriesResponseErrorDetails_FieldPathSelectorRegionId ListTimeSeriesResponseErrorDetails_FieldPathSelector = 0
)

func (s ListTimeSeriesResponseErrorDetails_FieldPathSelector) String() string {
	switch s {
	case ListTimeSeriesResponseErrorDetails_FieldPathSelectorRegionId:
		return "region_id"
	default:
		panic(fmt.Sprintf("Invalid selector for ListTimeSeriesResponse_ErrorDetails: %d", s))
	}
}

func BuildListTimeSeriesResponseErrorDetails_FieldPath(fp gotenobject.RawFieldPath) (ListTimeSeriesResponseErrorDetails_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object ListTimeSeriesResponse_ErrorDetails")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "region_id", "regionId", "region-id":
			return &ListTimeSeriesResponseErrorDetails_FieldTerminalPath{selector: ListTimeSeriesResponseErrorDetails_FieldPathSelectorRegionId}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object ListTimeSeriesResponse_ErrorDetails", fp)
}

func ParseListTimeSeriesResponseErrorDetails_FieldPath(rawField string) (ListTimeSeriesResponseErrorDetails_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildListTimeSeriesResponseErrorDetails_FieldPath(fp)
}

func MustParseListTimeSeriesResponseErrorDetails_FieldPath(rawField string) ListTimeSeriesResponseErrorDetails_FieldPath {
	fp, err := ParseListTimeSeriesResponseErrorDetails_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type ListTimeSeriesResponseErrorDetails_FieldTerminalPath struct {
	selector ListTimeSeriesResponseErrorDetails_FieldPathSelector
}

var _ ListTimeSeriesResponseErrorDetails_FieldPath = (*ListTimeSeriesResponseErrorDetails_FieldTerminalPath)(nil)

func (fp *ListTimeSeriesResponseErrorDetails_FieldTerminalPath) Selector() ListTimeSeriesResponseErrorDetails_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

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

func (fp *ListTimeSeriesResponseErrorDetails_FieldTerminalPath) ClearValue(item *ListTimeSeriesResponse_ErrorDetails) {
	if item != nil {
		switch fp.selector {
		case ListTimeSeriesResponseErrorDetails_FieldPathSelectorRegionId:
			item.RegionId = ""
		default:
			panic(fmt.Sprintf("Invalid selector for ListTimeSeriesResponse_ErrorDetails: %d", fp.selector))
		}
	}
}

func (fp *ListTimeSeriesResponseErrorDetails_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*ListTimeSeriesResponse_ErrorDetails))
}

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

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

func (fp *ListTimeSeriesResponseErrorDetails_FieldTerminalPath) WithIValue(value interface{}) ListTimeSeriesResponseErrorDetails_FieldPathValue {
	switch fp.selector {
	case ListTimeSeriesResponseErrorDetails_FieldPathSelectorRegionId:
		return &ListTimeSeriesResponseErrorDetails_FieldTerminalPathValue{ListTimeSeriesResponseErrorDetails_FieldTerminalPath: *fp, value: value.(string)}
	default:
		panic(fmt.Sprintf("Invalid selector for ListTimeSeriesResponse_ErrorDetails: %d", fp.selector))
	}
}

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

func (fp *ListTimeSeriesResponseErrorDetails_FieldTerminalPath) WithIArrayOfValues(values interface{}) ListTimeSeriesResponseErrorDetails_FieldPathArrayOfValues {
	fpaov := &ListTimeSeriesResponseErrorDetails_FieldTerminalPathArrayOfValues{ListTimeSeriesResponseErrorDetails_FieldTerminalPath: *fp}
	switch fp.selector {
	case ListTimeSeriesResponseErrorDetails_FieldPathSelectorRegionId:
		return &ListTimeSeriesResponseErrorDetails_FieldTerminalPathArrayOfValues{ListTimeSeriesResponseErrorDetails_FieldTerminalPath: *fp, values: values.([]string)}
	default:
		panic(fmt.Sprintf("Invalid selector for ListTimeSeriesResponse_ErrorDetails: %d", fp.selector))
	}
	return fpaov
}

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

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

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

// ListTimeSeriesResponseErrorDetails_FieldPathValue allows storing values for ErrorDetails fields according to their type
type ListTimeSeriesResponseErrorDetails_FieldPathValue interface {
	ListTimeSeriesResponseErrorDetails_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **ListTimeSeriesResponse_ErrorDetails)
	CompareWith(*ListTimeSeriesResponse_ErrorDetails) (cmp int, comparable bool)
}

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

func MustParseListTimeSeriesResponseErrorDetails_FieldPathValue(pathStr, valueStr string) ListTimeSeriesResponseErrorDetails_FieldPathValue {
	fpv, err := ParseListTimeSeriesResponseErrorDetails_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type ListTimeSeriesResponseErrorDetails_FieldTerminalPathValue struct {
	ListTimeSeriesResponseErrorDetails_FieldTerminalPath
	value interface{}
}

var _ ListTimeSeriesResponseErrorDetails_FieldPathValue = (*ListTimeSeriesResponseErrorDetails_FieldTerminalPathValue)(nil)

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

// SetTo stores value for selected field for object ErrorDetails
func (fpv *ListTimeSeriesResponseErrorDetails_FieldTerminalPathValue) SetTo(target **ListTimeSeriesResponse_ErrorDetails) {
	if *target == nil {
		*target = new(ListTimeSeriesResponse_ErrorDetails)
	}
	switch fpv.selector {
	case ListTimeSeriesResponseErrorDetails_FieldPathSelectorRegionId:
		(*target).RegionId = fpv.value.(string)
	default:
		panic(fmt.Sprintf("Invalid selector for ListTimeSeriesResponse_ErrorDetails: %d", fpv.selector))
	}
}

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

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

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

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

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

func MustParseListTimeSeriesResponseErrorDetails_FieldPathArrayItemValue(pathStr, valueStr string) ListTimeSeriesResponseErrorDetails_FieldPathArrayItemValue {
	fpaiv, err := ParseListTimeSeriesResponseErrorDetails_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type ListTimeSeriesResponseErrorDetails_FieldTerminalPathArrayItemValue struct {
	ListTimeSeriesResponseErrorDetails_FieldTerminalPath
	value interface{}
}

var _ ListTimeSeriesResponseErrorDetails_FieldPathArrayItemValue = (*ListTimeSeriesResponseErrorDetails_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *ListTimeSeriesResponseErrorDetails_FieldTerminalPathArrayItemValue) GetSingle(source *ListTimeSeriesResponse_ErrorDetails) (interface{}, bool) {
	return nil, false
}

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

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

// ListTimeSeriesResponseErrorDetails_FieldPathArrayOfValues allows storing slice of values for ErrorDetails fields according to their type
type ListTimeSeriesResponseErrorDetails_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	ListTimeSeriesResponseErrorDetails_FieldPath
}

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

func MustParseListTimeSeriesResponseErrorDetails_FieldPathArrayOfValues(pathStr, valuesStr string) ListTimeSeriesResponseErrorDetails_FieldPathArrayOfValues {
	fpaov, err := ParseListTimeSeriesResponseErrorDetails_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type ListTimeSeriesResponseErrorDetails_FieldTerminalPathArrayOfValues struct {
	ListTimeSeriesResponseErrorDetails_FieldTerminalPath
	values interface{}
}

var _ ListTimeSeriesResponseErrorDetails_FieldPathArrayOfValues = (*ListTimeSeriesResponseErrorDetails_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *ListTimeSeriesResponseErrorDetails_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case ListTimeSeriesResponseErrorDetails_FieldPathSelectorRegionId:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *ListTimeSeriesResponseErrorDetails_FieldTerminalPathArrayOfValues) AsRegionIdArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}

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

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

type CreateTimeSeriesRequest_FieldPathSelector int32

const (
	CreateTimeSeriesRequest_FieldPathSelectorParent     CreateTimeSeriesRequest_FieldPathSelector = 0
	CreateTimeSeriesRequest_FieldPathSelectorTimeSeries CreateTimeSeriesRequest_FieldPathSelector = 1
)

func (s CreateTimeSeriesRequest_FieldPathSelector) String() string {
	switch s {
	case CreateTimeSeriesRequest_FieldPathSelectorParent:
		return "parent"
	case CreateTimeSeriesRequest_FieldPathSelectorTimeSeries:
		return "time_series"
	default:
		panic(fmt.Sprintf("Invalid selector for CreateTimeSeriesRequest: %d", s))
	}
}

func BuildCreateTimeSeriesRequest_FieldPath(fp gotenobject.RawFieldPath) (CreateTimeSeriesRequest_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object CreateTimeSeriesRequest")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "parent":
			return &CreateTimeSeriesRequest_FieldTerminalPath{selector: CreateTimeSeriesRequest_FieldPathSelectorParent}, nil
		case "time_series", "timeSeries", "time-series":
			return &CreateTimeSeriesRequest_FieldTerminalPath{selector: CreateTimeSeriesRequest_FieldPathSelectorTimeSeries}, nil
		}
	} else {
		switch fp[0] {
		case "time_series", "timeSeries", "time-series":
			if subpath, err := time_serie.BuildTimeSerie_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &CreateTimeSeriesRequest_FieldSubPath{selector: CreateTimeSeriesRequest_FieldPathSelectorTimeSeries, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object CreateTimeSeriesRequest", fp)
}

func ParseCreateTimeSeriesRequest_FieldPath(rawField string) (CreateTimeSeriesRequest_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildCreateTimeSeriesRequest_FieldPath(fp)
}

func MustParseCreateTimeSeriesRequest_FieldPath(rawField string) CreateTimeSeriesRequest_FieldPath {
	fp, err := ParseCreateTimeSeriesRequest_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type CreateTimeSeriesRequest_FieldTerminalPath struct {
	selector CreateTimeSeriesRequest_FieldPathSelector
}

var _ CreateTimeSeriesRequest_FieldPath = (*CreateTimeSeriesRequest_FieldTerminalPath)(nil)

func (fp *CreateTimeSeriesRequest_FieldTerminalPath) Selector() CreateTimeSeriesRequest_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source CreateTimeSeriesRequest
func (fp *CreateTimeSeriesRequest_FieldTerminalPath) Get(source *CreateTimeSeriesRequest) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case CreateTimeSeriesRequest_FieldPathSelectorParent:
			if source.Parent != nil {
				values = append(values, source.Parent)
			}
		case CreateTimeSeriesRequest_FieldPathSelectorTimeSeries:
			for _, value := range source.GetTimeSeries() {
				values = append(values, value)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for CreateTimeSeriesRequest: %d", fp.selector))
		}
	}
	return
}

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

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

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

// GetDefault returns a default value of the field type
func (fp *CreateTimeSeriesRequest_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case CreateTimeSeriesRequest_FieldPathSelectorParent:
		return (*project.Name)(nil)
	case CreateTimeSeriesRequest_FieldPathSelectorTimeSeries:
		return ([]*time_serie.TimeSerie)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for CreateTimeSeriesRequest: %d", fp.selector))
	}
}

func (fp *CreateTimeSeriesRequest_FieldTerminalPath) ClearValue(item *CreateTimeSeriesRequest) {
	if item != nil {
		switch fp.selector {
		case CreateTimeSeriesRequest_FieldPathSelectorParent:
			item.Parent = nil
		case CreateTimeSeriesRequest_FieldPathSelectorTimeSeries:
			item.TimeSeries = nil
		default:
			panic(fmt.Sprintf("Invalid selector for CreateTimeSeriesRequest: %d", fp.selector))
		}
	}
}

func (fp *CreateTimeSeriesRequest_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*CreateTimeSeriesRequest))
}

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

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

func (fp *CreateTimeSeriesRequest_FieldTerminalPath) WithIValue(value interface{}) CreateTimeSeriesRequest_FieldPathValue {
	switch fp.selector {
	case CreateTimeSeriesRequest_FieldPathSelectorParent:
		return &CreateTimeSeriesRequest_FieldTerminalPathValue{CreateTimeSeriesRequest_FieldTerminalPath: *fp, value: value.(*project.Name)}
	case CreateTimeSeriesRequest_FieldPathSelectorTimeSeries:
		return &CreateTimeSeriesRequest_FieldTerminalPathValue{CreateTimeSeriesRequest_FieldTerminalPath: *fp, value: value.([]*time_serie.TimeSerie)}
	default:
		panic(fmt.Sprintf("Invalid selector for CreateTimeSeriesRequest: %d", fp.selector))
	}
}

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

func (fp *CreateTimeSeriesRequest_FieldTerminalPath) WithIArrayOfValues(values interface{}) CreateTimeSeriesRequest_FieldPathArrayOfValues {
	fpaov := &CreateTimeSeriesRequest_FieldTerminalPathArrayOfValues{CreateTimeSeriesRequest_FieldTerminalPath: *fp}
	switch fp.selector {
	case CreateTimeSeriesRequest_FieldPathSelectorParent:
		return &CreateTimeSeriesRequest_FieldTerminalPathArrayOfValues{CreateTimeSeriesRequest_FieldTerminalPath: *fp, values: values.([]*project.Name)}
	case CreateTimeSeriesRequest_FieldPathSelectorTimeSeries:
		return &CreateTimeSeriesRequest_FieldTerminalPathArrayOfValues{CreateTimeSeriesRequest_FieldTerminalPath: *fp, values: values.([][]*time_serie.TimeSerie)}
	default:
		panic(fmt.Sprintf("Invalid selector for CreateTimeSeriesRequest: %d", fp.selector))
	}
	return fpaov
}

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

func (fp *CreateTimeSeriesRequest_FieldTerminalPath) WithIArrayItemValue(value interface{}) CreateTimeSeriesRequest_FieldPathArrayItemValue {
	switch fp.selector {
	case CreateTimeSeriesRequest_FieldPathSelectorTimeSeries:
		return &CreateTimeSeriesRequest_FieldTerminalPathArrayItemValue{CreateTimeSeriesRequest_FieldTerminalPath: *fp, value: value.(*time_serie.TimeSerie)}
	default:
		panic(fmt.Sprintf("Invalid selector for CreateTimeSeriesRequest: %d", fp.selector))
	}
}

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

type CreateTimeSeriesRequest_FieldSubPath struct {
	selector CreateTimeSeriesRequest_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ CreateTimeSeriesRequest_FieldPath = (*CreateTimeSeriesRequest_FieldSubPath)(nil)

func (fps *CreateTimeSeriesRequest_FieldSubPath) Selector() CreateTimeSeriesRequest_FieldPathSelector {
	return fps.selector
}
func (fps *CreateTimeSeriesRequest_FieldSubPath) AsTimeSeriesSubPath() (time_serie.TimeSerie_FieldPath, bool) {
	res, ok := fps.subPath.(time_serie.TimeSerie_FieldPath)
	return res, ok
}

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

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

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

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

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

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

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

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

func (fps *CreateTimeSeriesRequest_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*CreateTimeSeriesRequest))
}

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

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

func (fps *CreateTimeSeriesRequest_FieldSubPath) WithIValue(value interface{}) CreateTimeSeriesRequest_FieldPathValue {
	return &CreateTimeSeriesRequest_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *CreateTimeSeriesRequest_FieldSubPath) WithIArrayOfValues(values interface{}) CreateTimeSeriesRequest_FieldPathArrayOfValues {
	return &CreateTimeSeriesRequest_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *CreateTimeSeriesRequest_FieldSubPath) WithIArrayItemValue(value interface{}) CreateTimeSeriesRequest_FieldPathArrayItemValue {
	return &CreateTimeSeriesRequest_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

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

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

func MustParseCreateTimeSeriesRequest_FieldPathValue(pathStr, valueStr string) CreateTimeSeriesRequest_FieldPathValue {
	fpv, err := ParseCreateTimeSeriesRequest_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type CreateTimeSeriesRequest_FieldTerminalPathValue struct {
	CreateTimeSeriesRequest_FieldTerminalPath
	value interface{}
}

var _ CreateTimeSeriesRequest_FieldPathValue = (*CreateTimeSeriesRequest_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'CreateTimeSeriesRequest' as interface{}
func (fpv *CreateTimeSeriesRequest_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *CreateTimeSeriesRequest_FieldTerminalPathValue) AsParentValue() (*project.Name, bool) {
	res, ok := fpv.value.(*project.Name)
	return res, ok
}
func (fpv *CreateTimeSeriesRequest_FieldTerminalPathValue) AsTimeSeriesValue() ([]*time_serie.TimeSerie, bool) {
	res, ok := fpv.value.([]*time_serie.TimeSerie)
	return res, ok
}

// SetTo stores value for selected field for object CreateTimeSeriesRequest
func (fpv *CreateTimeSeriesRequest_FieldTerminalPathValue) SetTo(target **CreateTimeSeriesRequest) {
	if *target == nil {
		*target = new(CreateTimeSeriesRequest)
	}
	switch fpv.selector {
	case CreateTimeSeriesRequest_FieldPathSelectorParent:
		(*target).Parent = fpv.value.(*project.Name)
	case CreateTimeSeriesRequest_FieldPathSelectorTimeSeries:
		(*target).TimeSeries = fpv.value.([]*time_serie.TimeSerie)
	default:
		panic(fmt.Sprintf("Invalid selector for CreateTimeSeriesRequest: %d", fpv.selector))
	}
}

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

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

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

type CreateTimeSeriesRequest_FieldSubPathValue struct {
	CreateTimeSeriesRequest_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ CreateTimeSeriesRequest_FieldPathValue = (*CreateTimeSeriesRequest_FieldSubPathValue)(nil)

func (fpvs *CreateTimeSeriesRequest_FieldSubPathValue) AsTimeSeriesPathValue() (time_serie.TimeSerie_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(time_serie.TimeSerie_FieldPathValue)
	return res, ok
}

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

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

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

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

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

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

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

func MustParseCreateTimeSeriesRequest_FieldPathArrayItemValue(pathStr, valueStr string) CreateTimeSeriesRequest_FieldPathArrayItemValue {
	fpaiv, err := ParseCreateTimeSeriesRequest_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type CreateTimeSeriesRequest_FieldTerminalPathArrayItemValue struct {
	CreateTimeSeriesRequest_FieldTerminalPath
	value interface{}
}

var _ CreateTimeSeriesRequest_FieldPathArrayItemValue = (*CreateTimeSeriesRequest_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object CreateTimeSeriesRequest as interface{}
func (fpaiv *CreateTimeSeriesRequest_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}
func (fpaiv *CreateTimeSeriesRequest_FieldTerminalPathArrayItemValue) AsTimeSeriesItemValue() (*time_serie.TimeSerie, bool) {
	res, ok := fpaiv.value.(*time_serie.TimeSerie)
	return res, ok
}

func (fpaiv *CreateTimeSeriesRequest_FieldTerminalPathArrayItemValue) GetSingle(source *CreateTimeSeriesRequest) (interface{}, bool) {
	return nil, false
}

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

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

// GetRawValue returns stored array item value
func (fpaivs *CreateTimeSeriesRequest_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *CreateTimeSeriesRequest_FieldSubPathArrayItemValue) AsTimeSeriesPathItemValue() (time_serie.TimeSerie_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(time_serie.TimeSerie_FieldPathArrayItemValue)
	return res, ok
}

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

// CreateTimeSeriesRequest_FieldPathArrayOfValues allows storing slice of values for CreateTimeSeriesRequest fields according to their type
type CreateTimeSeriesRequest_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	CreateTimeSeriesRequest_FieldPath
}

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

func MustParseCreateTimeSeriesRequest_FieldPathArrayOfValues(pathStr, valuesStr string) CreateTimeSeriesRequest_FieldPathArrayOfValues {
	fpaov, err := ParseCreateTimeSeriesRequest_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type CreateTimeSeriesRequest_FieldTerminalPathArrayOfValues struct {
	CreateTimeSeriesRequest_FieldTerminalPath
	values interface{}
}

var _ CreateTimeSeriesRequest_FieldPathArrayOfValues = (*CreateTimeSeriesRequest_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *CreateTimeSeriesRequest_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case CreateTimeSeriesRequest_FieldPathSelectorParent:
		for _, v := range fpaov.values.([]*project.Name) {
			values = append(values, v)
		}
	case CreateTimeSeriesRequest_FieldPathSelectorTimeSeries:
		for _, v := range fpaov.values.([][]*time_serie.TimeSerie) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *CreateTimeSeriesRequest_FieldTerminalPathArrayOfValues) AsParentArrayOfValues() ([]*project.Name, bool) {
	res, ok := fpaov.values.([]*project.Name)
	return res, ok
}
func (fpaov *CreateTimeSeriesRequest_FieldTerminalPathArrayOfValues) AsTimeSeriesArrayOfValues() ([][]*time_serie.TimeSerie, bool) {
	res, ok := fpaov.values.([][]*time_serie.TimeSerie)
	return res, ok
}

type CreateTimeSeriesRequest_FieldSubPathArrayOfValues struct {
	CreateTimeSeriesRequest_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ CreateTimeSeriesRequest_FieldPathArrayOfValues = (*CreateTimeSeriesRequest_FieldSubPathArrayOfValues)(nil)

func (fpsaov *CreateTimeSeriesRequest_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *CreateTimeSeriesRequest_FieldSubPathArrayOfValues) AsTimeSeriesPathArrayOfValues() (time_serie.TimeSerie_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(time_serie.TimeSerie_FieldPathArrayOfValues)
	return res, ok
}

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

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

type CreateTimeSeriesResponse_FieldPathSelector int32

const (
	CreateTimeSeriesResponse_FieldPathSelectorTimeSerieKeys    CreateTimeSeriesResponse_FieldPathSelector = 0
	CreateTimeSeriesResponse_FieldPathSelectorFailedTimeSeries CreateTimeSeriesResponse_FieldPathSelector = 1
)

func (s CreateTimeSeriesResponse_FieldPathSelector) String() string {
	switch s {
	case CreateTimeSeriesResponse_FieldPathSelectorTimeSerieKeys:
		return "time_serie_keys"
	case CreateTimeSeriesResponse_FieldPathSelectorFailedTimeSeries:
		return "failed_time_series"
	default:
		panic(fmt.Sprintf("Invalid selector for CreateTimeSeriesResponse: %d", s))
	}
}

func BuildCreateTimeSeriesResponse_FieldPath(fp gotenobject.RawFieldPath) (CreateTimeSeriesResponse_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object CreateTimeSeriesResponse")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "time_serie_keys", "timeSerieKeys", "time-serie-keys":
			return &CreateTimeSeriesResponse_FieldTerminalPath{selector: CreateTimeSeriesResponse_FieldPathSelectorTimeSerieKeys}, nil
		case "failed_time_series", "failedTimeSeries", "failed-time-series":
			return &CreateTimeSeriesResponse_FieldTerminalPath{selector: CreateTimeSeriesResponse_FieldPathSelectorFailedTimeSeries}, nil
		}
	} else {
		switch fp[0] {
		case "failed_time_series", "failedTimeSeries", "failed-time-series":
			if subpath, err := BuildCreateTimeSeriesError_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &CreateTimeSeriesResponse_FieldSubPath{selector: CreateTimeSeriesResponse_FieldPathSelectorFailedTimeSeries, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object CreateTimeSeriesResponse", fp)
}

func ParseCreateTimeSeriesResponse_FieldPath(rawField string) (CreateTimeSeriesResponse_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildCreateTimeSeriesResponse_FieldPath(fp)
}

func MustParseCreateTimeSeriesResponse_FieldPath(rawField string) CreateTimeSeriesResponse_FieldPath {
	fp, err := ParseCreateTimeSeriesResponse_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type CreateTimeSeriesResponse_FieldTerminalPath struct {
	selector CreateTimeSeriesResponse_FieldPathSelector
}

var _ CreateTimeSeriesResponse_FieldPath = (*CreateTimeSeriesResponse_FieldTerminalPath)(nil)

func (fp *CreateTimeSeriesResponse_FieldTerminalPath) Selector() CreateTimeSeriesResponse_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source CreateTimeSeriesResponse
func (fp *CreateTimeSeriesResponse_FieldTerminalPath) Get(source *CreateTimeSeriesResponse) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case CreateTimeSeriesResponse_FieldPathSelectorTimeSerieKeys:
			if source.TimeSerieKeys != nil {
				values = append(values, source.TimeSerieKeys)
			}
		case CreateTimeSeriesResponse_FieldPathSelectorFailedTimeSeries:
			for _, value := range source.GetFailedTimeSeries() {
				values = append(values, value)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for CreateTimeSeriesResponse: %d", fp.selector))
		}
	}
	return
}

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

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

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

// GetDefault returns a default value of the field type
func (fp *CreateTimeSeriesResponse_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case CreateTimeSeriesResponse_FieldPathSelectorTimeSerieKeys:
		return (map[uint32][]byte)(nil)
	case CreateTimeSeriesResponse_FieldPathSelectorFailedTimeSeries:
		return ([]*CreateTimeSeriesError)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for CreateTimeSeriesResponse: %d", fp.selector))
	}
}

func (fp *CreateTimeSeriesResponse_FieldTerminalPath) ClearValue(item *CreateTimeSeriesResponse) {
	if item != nil {
		switch fp.selector {
		case CreateTimeSeriesResponse_FieldPathSelectorTimeSerieKeys:
			item.TimeSerieKeys = nil
		case CreateTimeSeriesResponse_FieldPathSelectorFailedTimeSeries:
			item.FailedTimeSeries = nil
		default:
			panic(fmt.Sprintf("Invalid selector for CreateTimeSeriesResponse: %d", fp.selector))
		}
	}
}

func (fp *CreateTimeSeriesResponse_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*CreateTimeSeriesResponse))
}

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

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

func (fp *CreateTimeSeriesResponse_FieldTerminalPath) WithIValue(value interface{}) CreateTimeSeriesResponse_FieldPathValue {
	switch fp.selector {
	case CreateTimeSeriesResponse_FieldPathSelectorTimeSerieKeys:
		return &CreateTimeSeriesResponse_FieldTerminalPathValue{CreateTimeSeriesResponse_FieldTerminalPath: *fp, value: value.(map[uint32][]byte)}
	case CreateTimeSeriesResponse_FieldPathSelectorFailedTimeSeries:
		return &CreateTimeSeriesResponse_FieldTerminalPathValue{CreateTimeSeriesResponse_FieldTerminalPath: *fp, value: value.([]*CreateTimeSeriesError)}
	default:
		panic(fmt.Sprintf("Invalid selector for CreateTimeSeriesResponse: %d", fp.selector))
	}
}

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

func (fp *CreateTimeSeriesResponse_FieldTerminalPath) WithIArrayOfValues(values interface{}) CreateTimeSeriesResponse_FieldPathArrayOfValues {
	fpaov := &CreateTimeSeriesResponse_FieldTerminalPathArrayOfValues{CreateTimeSeriesResponse_FieldTerminalPath: *fp}
	switch fp.selector {
	case CreateTimeSeriesResponse_FieldPathSelectorTimeSerieKeys:
		return &CreateTimeSeriesResponse_FieldTerminalPathArrayOfValues{CreateTimeSeriesResponse_FieldTerminalPath: *fp, values: values.([]map[uint32][]byte)}
	case CreateTimeSeriesResponse_FieldPathSelectorFailedTimeSeries:
		return &CreateTimeSeriesResponse_FieldTerminalPathArrayOfValues{CreateTimeSeriesResponse_FieldTerminalPath: *fp, values: values.([][]*CreateTimeSeriesError)}
	default:
		panic(fmt.Sprintf("Invalid selector for CreateTimeSeriesResponse: %d", fp.selector))
	}
	return fpaov
}

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

func (fp *CreateTimeSeriesResponse_FieldTerminalPath) WithIArrayItemValue(value interface{}) CreateTimeSeriesResponse_FieldPathArrayItemValue {
	switch fp.selector {
	case CreateTimeSeriesResponse_FieldPathSelectorFailedTimeSeries:
		return &CreateTimeSeriesResponse_FieldTerminalPathArrayItemValue{CreateTimeSeriesResponse_FieldTerminalPath: *fp, value: value.(*CreateTimeSeriesError)}
	default:
		panic(fmt.Sprintf("Invalid selector for CreateTimeSeriesResponse: %d", fp.selector))
	}
}

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

type CreateTimeSeriesResponse_FieldSubPath struct {
	selector CreateTimeSeriesResponse_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ CreateTimeSeriesResponse_FieldPath = (*CreateTimeSeriesResponse_FieldSubPath)(nil)

func (fps *CreateTimeSeriesResponse_FieldSubPath) Selector() CreateTimeSeriesResponse_FieldPathSelector {
	return fps.selector
}
func (fps *CreateTimeSeriesResponse_FieldSubPath) AsFailedTimeSeriesSubPath() (CreateTimeSeriesError_FieldPath, bool) {
	res, ok := fps.subPath.(CreateTimeSeriesError_FieldPath)
	return res, ok
}

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

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

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

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

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

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

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

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

func (fps *CreateTimeSeriesResponse_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*CreateTimeSeriesResponse))
}

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

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

func (fps *CreateTimeSeriesResponse_FieldSubPath) WithIValue(value interface{}) CreateTimeSeriesResponse_FieldPathValue {
	return &CreateTimeSeriesResponse_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *CreateTimeSeriesResponse_FieldSubPath) WithIArrayOfValues(values interface{}) CreateTimeSeriesResponse_FieldPathArrayOfValues {
	return &CreateTimeSeriesResponse_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *CreateTimeSeriesResponse_FieldSubPath) WithIArrayItemValue(value interface{}) CreateTimeSeriesResponse_FieldPathArrayItemValue {
	return &CreateTimeSeriesResponse_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

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

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

func MustParseCreateTimeSeriesResponse_FieldPathValue(pathStr, valueStr string) CreateTimeSeriesResponse_FieldPathValue {
	fpv, err := ParseCreateTimeSeriesResponse_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type CreateTimeSeriesResponse_FieldTerminalPathValue struct {
	CreateTimeSeriesResponse_FieldTerminalPath
	value interface{}
}

var _ CreateTimeSeriesResponse_FieldPathValue = (*CreateTimeSeriesResponse_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'CreateTimeSeriesResponse' as interface{}
func (fpv *CreateTimeSeriesResponse_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *CreateTimeSeriesResponse_FieldTerminalPathValue) AsTimeSerieKeysValue() (map[uint32][]byte, bool) {
	res, ok := fpv.value.(map[uint32][]byte)
	return res, ok
}
func (fpv *CreateTimeSeriesResponse_FieldTerminalPathValue) AsFailedTimeSeriesValue() ([]*CreateTimeSeriesError, bool) {
	res, ok := fpv.value.([]*CreateTimeSeriesError)
	return res, ok
}

// SetTo stores value for selected field for object CreateTimeSeriesResponse
func (fpv *CreateTimeSeriesResponse_FieldTerminalPathValue) SetTo(target **CreateTimeSeriesResponse) {
	if *target == nil {
		*target = new(CreateTimeSeriesResponse)
	}
	switch fpv.selector {
	case CreateTimeSeriesResponse_FieldPathSelectorTimeSerieKeys:
		(*target).TimeSerieKeys = fpv.value.(map[uint32][]byte)
	case CreateTimeSeriesResponse_FieldPathSelectorFailedTimeSeries:
		(*target).FailedTimeSeries = fpv.value.([]*CreateTimeSeriesError)
	default:
		panic(fmt.Sprintf("Invalid selector for CreateTimeSeriesResponse: %d", fpv.selector))
	}
}

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

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

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

type CreateTimeSeriesResponse_FieldSubPathValue struct {
	CreateTimeSeriesResponse_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ CreateTimeSeriesResponse_FieldPathValue = (*CreateTimeSeriesResponse_FieldSubPathValue)(nil)

func (fpvs *CreateTimeSeriesResponse_FieldSubPathValue) AsFailedTimeSeriesPathValue() (CreateTimeSeriesError_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(CreateTimeSeriesError_FieldPathValue)
	return res, ok
}

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

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

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

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

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

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

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

func MustParseCreateTimeSeriesResponse_FieldPathArrayItemValue(pathStr, valueStr string) CreateTimeSeriesResponse_FieldPathArrayItemValue {
	fpaiv, err := ParseCreateTimeSeriesResponse_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type CreateTimeSeriesResponse_FieldTerminalPathArrayItemValue struct {
	CreateTimeSeriesResponse_FieldTerminalPath
	value interface{}
}

var _ CreateTimeSeriesResponse_FieldPathArrayItemValue = (*CreateTimeSeriesResponse_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object CreateTimeSeriesResponse as interface{}
func (fpaiv *CreateTimeSeriesResponse_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}
func (fpaiv *CreateTimeSeriesResponse_FieldTerminalPathArrayItemValue) AsFailedTimeSeriesItemValue() (*CreateTimeSeriesError, bool) {
	res, ok := fpaiv.value.(*CreateTimeSeriesError)
	return res, ok
}

func (fpaiv *CreateTimeSeriesResponse_FieldTerminalPathArrayItemValue) GetSingle(source *CreateTimeSeriesResponse) (interface{}, bool) {
	return nil, false
}

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

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

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

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

// CreateTimeSeriesResponse_FieldPathArrayOfValues allows storing slice of values for CreateTimeSeriesResponse fields according to their type
type CreateTimeSeriesResponse_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	CreateTimeSeriesResponse_FieldPath
}

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

func MustParseCreateTimeSeriesResponse_FieldPathArrayOfValues(pathStr, valuesStr string) CreateTimeSeriesResponse_FieldPathArrayOfValues {
	fpaov, err := ParseCreateTimeSeriesResponse_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type CreateTimeSeriesResponse_FieldTerminalPathArrayOfValues struct {
	CreateTimeSeriesResponse_FieldTerminalPath
	values interface{}
}

var _ CreateTimeSeriesResponse_FieldPathArrayOfValues = (*CreateTimeSeriesResponse_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *CreateTimeSeriesResponse_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case CreateTimeSeriesResponse_FieldPathSelectorTimeSerieKeys:
		for _, v := range fpaov.values.([]map[uint32][]byte) {
			values = append(values, v)
		}
	case CreateTimeSeriesResponse_FieldPathSelectorFailedTimeSeries:
		for _, v := range fpaov.values.([][]*CreateTimeSeriesError) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *CreateTimeSeriesResponse_FieldTerminalPathArrayOfValues) AsTimeSerieKeysArrayOfValues() ([]map[uint32][]byte, bool) {
	res, ok := fpaov.values.([]map[uint32][]byte)
	return res, ok
}
func (fpaov *CreateTimeSeriesResponse_FieldTerminalPathArrayOfValues) AsFailedTimeSeriesArrayOfValues() ([][]*CreateTimeSeriesError, bool) {
	res, ok := fpaov.values.([][]*CreateTimeSeriesError)
	return res, ok
}

type CreateTimeSeriesResponse_FieldSubPathArrayOfValues struct {
	CreateTimeSeriesResponse_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ CreateTimeSeriesResponse_FieldPathArrayOfValues = (*CreateTimeSeriesResponse_FieldSubPathArrayOfValues)(nil)

func (fpsaov *CreateTimeSeriesResponse_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *CreateTimeSeriesResponse_FieldSubPathArrayOfValues) AsFailedTimeSeriesPathArrayOfValues() (CreateTimeSeriesError_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(CreateTimeSeriesError_FieldPathArrayOfValues)
	return res, ok
}

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

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

type CreateTimeSeriesError_FieldPathSelector int32

const (
	CreateTimeSeriesError_FieldPathSelectorTimeSeries CreateTimeSeriesError_FieldPathSelector = 0
	CreateTimeSeriesError_FieldPathSelectorStatus     CreateTimeSeriesError_FieldPathSelector = 1
)

func (s CreateTimeSeriesError_FieldPathSelector) String() string {
	switch s {
	case CreateTimeSeriesError_FieldPathSelectorTimeSeries:
		return "time_series"
	case CreateTimeSeriesError_FieldPathSelectorStatus:
		return "status"
	default:
		panic(fmt.Sprintf("Invalid selector for CreateTimeSeriesError: %d", s))
	}
}

func BuildCreateTimeSeriesError_FieldPath(fp gotenobject.RawFieldPath) (CreateTimeSeriesError_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object CreateTimeSeriesError")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "time_series", "timeSeries", "time-series":
			return &CreateTimeSeriesError_FieldTerminalPath{selector: CreateTimeSeriesError_FieldPathSelectorTimeSeries}, nil
		case "status":
			return &CreateTimeSeriesError_FieldTerminalPath{selector: CreateTimeSeriesError_FieldPathSelectorStatus}, nil
		}
	} else {
		switch fp[0] {
		case "time_series", "timeSeries", "time-series":
			if subpath, err := time_serie.BuildTimeSerie_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &CreateTimeSeriesError_FieldSubPath{selector: CreateTimeSeriesError_FieldPathSelectorTimeSeries, subPath: subpath}, nil
			}
		case "status":
			if subpath, err := rpc.BuildStatus_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &CreateTimeSeriesError_FieldSubPath{selector: CreateTimeSeriesError_FieldPathSelectorStatus, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object CreateTimeSeriesError", fp)
}

func ParseCreateTimeSeriesError_FieldPath(rawField string) (CreateTimeSeriesError_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildCreateTimeSeriesError_FieldPath(fp)
}

func MustParseCreateTimeSeriesError_FieldPath(rawField string) CreateTimeSeriesError_FieldPath {
	fp, err := ParseCreateTimeSeriesError_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type CreateTimeSeriesError_FieldTerminalPath struct {
	selector CreateTimeSeriesError_FieldPathSelector
}

var _ CreateTimeSeriesError_FieldPath = (*CreateTimeSeriesError_FieldTerminalPath)(nil)

func (fp *CreateTimeSeriesError_FieldTerminalPath) Selector() CreateTimeSeriesError_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

// GetDefault returns a default value of the field type
func (fp *CreateTimeSeriesError_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case CreateTimeSeriesError_FieldPathSelectorTimeSeries:
		return (*time_serie.TimeSerie)(nil)
	case CreateTimeSeriesError_FieldPathSelectorStatus:
		return (*rpc.Status)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for CreateTimeSeriesError: %d", fp.selector))
	}
}

func (fp *CreateTimeSeriesError_FieldTerminalPath) ClearValue(item *CreateTimeSeriesError) {
	if item != nil {
		switch fp.selector {
		case CreateTimeSeriesError_FieldPathSelectorTimeSeries:
			item.TimeSeries = nil
		case CreateTimeSeriesError_FieldPathSelectorStatus:
			item.Status = nil
		default:
			panic(fmt.Sprintf("Invalid selector for CreateTimeSeriesError: %d", fp.selector))
		}
	}
}

func (fp *CreateTimeSeriesError_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*CreateTimeSeriesError))
}

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

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

func (fp *CreateTimeSeriesError_FieldTerminalPath) WithIValue(value interface{}) CreateTimeSeriesError_FieldPathValue {
	switch fp.selector {
	case CreateTimeSeriesError_FieldPathSelectorTimeSeries:
		return &CreateTimeSeriesError_FieldTerminalPathValue{CreateTimeSeriesError_FieldTerminalPath: *fp, value: value.(*time_serie.TimeSerie)}
	case CreateTimeSeriesError_FieldPathSelectorStatus:
		return &CreateTimeSeriesError_FieldTerminalPathValue{CreateTimeSeriesError_FieldTerminalPath: *fp, value: value.(*rpc.Status)}
	default:
		panic(fmt.Sprintf("Invalid selector for CreateTimeSeriesError: %d", fp.selector))
	}
}

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

func (fp *CreateTimeSeriesError_FieldTerminalPath) WithIArrayOfValues(values interface{}) CreateTimeSeriesError_FieldPathArrayOfValues {
	fpaov := &CreateTimeSeriesError_FieldTerminalPathArrayOfValues{CreateTimeSeriesError_FieldTerminalPath: *fp}
	switch fp.selector {
	case CreateTimeSeriesError_FieldPathSelectorTimeSeries:
		return &CreateTimeSeriesError_FieldTerminalPathArrayOfValues{CreateTimeSeriesError_FieldTerminalPath: *fp, values: values.([]*time_serie.TimeSerie)}
	case CreateTimeSeriesError_FieldPathSelectorStatus:
		return &CreateTimeSeriesError_FieldTerminalPathArrayOfValues{CreateTimeSeriesError_FieldTerminalPath: *fp, values: values.([]*rpc.Status)}
	default:
		panic(fmt.Sprintf("Invalid selector for CreateTimeSeriesError: %d", fp.selector))
	}
	return fpaov
}

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

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

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

type CreateTimeSeriesError_FieldSubPath struct {
	selector CreateTimeSeriesError_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ CreateTimeSeriesError_FieldPath = (*CreateTimeSeriesError_FieldSubPath)(nil)

func (fps *CreateTimeSeriesError_FieldSubPath) Selector() CreateTimeSeriesError_FieldPathSelector {
	return fps.selector
}
func (fps *CreateTimeSeriesError_FieldSubPath) AsTimeSeriesSubPath() (time_serie.TimeSerie_FieldPath, bool) {
	res, ok := fps.subPath.(time_serie.TimeSerie_FieldPath)
	return res, ok
}
func (fps *CreateTimeSeriesError_FieldSubPath) AsStatusSubPath() (rpc.Status_FieldPath, bool) {
	res, ok := fps.subPath.(rpc.Status_FieldPath)
	return res, ok
}

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

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

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

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

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

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

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

func (fps *CreateTimeSeriesError_FieldSubPath) ClearValue(item *CreateTimeSeriesError) {
	if item != nil {
		switch fps.selector {
		case CreateTimeSeriesError_FieldPathSelectorTimeSeries:
			fps.subPath.ClearValueRaw(item.TimeSeries)
		case CreateTimeSeriesError_FieldPathSelectorStatus:
			fps.subPath.ClearValueRaw(item.Status)
		default:
			panic(fmt.Sprintf("Invalid selector for CreateTimeSeriesError: %d", fps.selector))
		}
	}
}

func (fps *CreateTimeSeriesError_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*CreateTimeSeriesError))
}

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

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

func (fps *CreateTimeSeriesError_FieldSubPath) WithIValue(value interface{}) CreateTimeSeriesError_FieldPathValue {
	return &CreateTimeSeriesError_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *CreateTimeSeriesError_FieldSubPath) WithIArrayOfValues(values interface{}) CreateTimeSeriesError_FieldPathArrayOfValues {
	return &CreateTimeSeriesError_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *CreateTimeSeriesError_FieldSubPath) WithIArrayItemValue(value interface{}) CreateTimeSeriesError_FieldPathArrayItemValue {
	return &CreateTimeSeriesError_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

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

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

func MustParseCreateTimeSeriesError_FieldPathValue(pathStr, valueStr string) CreateTimeSeriesError_FieldPathValue {
	fpv, err := ParseCreateTimeSeriesError_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type CreateTimeSeriesError_FieldTerminalPathValue struct {
	CreateTimeSeriesError_FieldTerminalPath
	value interface{}
}

var _ CreateTimeSeriesError_FieldPathValue = (*CreateTimeSeriesError_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'CreateTimeSeriesError' as interface{}
func (fpv *CreateTimeSeriesError_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *CreateTimeSeriesError_FieldTerminalPathValue) AsTimeSeriesValue() (*time_serie.TimeSerie, bool) {
	res, ok := fpv.value.(*time_serie.TimeSerie)
	return res, ok
}
func (fpv *CreateTimeSeriesError_FieldTerminalPathValue) AsStatusValue() (*rpc.Status, bool) {
	res, ok := fpv.value.(*rpc.Status)
	return res, ok
}

// SetTo stores value for selected field for object CreateTimeSeriesError
func (fpv *CreateTimeSeriesError_FieldTerminalPathValue) SetTo(target **CreateTimeSeriesError) {
	if *target == nil {
		*target = new(CreateTimeSeriesError)
	}
	switch fpv.selector {
	case CreateTimeSeriesError_FieldPathSelectorTimeSeries:
		(*target).TimeSeries = fpv.value.(*time_serie.TimeSerie)
	case CreateTimeSeriesError_FieldPathSelectorStatus:
		(*target).Status = fpv.value.(*rpc.Status)
	default:
		panic(fmt.Sprintf("Invalid selector for CreateTimeSeriesError: %d", fpv.selector))
	}
}

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

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

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

type CreateTimeSeriesError_FieldSubPathValue struct {
	CreateTimeSeriesError_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ CreateTimeSeriesError_FieldPathValue = (*CreateTimeSeriesError_FieldSubPathValue)(nil)

func (fpvs *CreateTimeSeriesError_FieldSubPathValue) AsTimeSeriesPathValue() (time_serie.TimeSerie_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(time_serie.TimeSerie_FieldPathValue)
	return res, ok
}
func (fpvs *CreateTimeSeriesError_FieldSubPathValue) AsStatusPathValue() (rpc.Status_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(rpc.Status_FieldPathValue)
	return res, ok
}

func (fpvs *CreateTimeSeriesError_FieldSubPathValue) SetTo(target **CreateTimeSeriesError) {
	if *target == nil {
		*target = new(CreateTimeSeriesError)
	}
	switch fpvs.Selector() {
	case CreateTimeSeriesError_FieldPathSelectorTimeSeries:
		fpvs.subPathValue.(time_serie.TimeSerie_FieldPathValue).SetTo(&(*target).TimeSeries)
	case CreateTimeSeriesError_FieldPathSelectorStatus:
		fpvs.subPathValue.(rpc.Status_FieldPathValue).SetTo(&(*target).Status)
	default:
		panic(fmt.Sprintf("Invalid selector for CreateTimeSeriesError: %d", fpvs.Selector()))
	}
}

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

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

func (fpvs *CreateTimeSeriesError_FieldSubPathValue) CompareWith(source *CreateTimeSeriesError) (int, bool) {
	switch fpvs.Selector() {
	case CreateTimeSeriesError_FieldPathSelectorTimeSeries:
		return fpvs.subPathValue.(time_serie.TimeSerie_FieldPathValue).CompareWith(source.GetTimeSeries())
	case CreateTimeSeriesError_FieldPathSelectorStatus:
		return fpvs.subPathValue.(rpc.Status_FieldPathValue).CompareWith(source.GetStatus())
	default:
		panic(fmt.Sprintf("Invalid selector for CreateTimeSeriesError: %d", fpvs.Selector()))
	}
}

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

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

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

func MustParseCreateTimeSeriesError_FieldPathArrayItemValue(pathStr, valueStr string) CreateTimeSeriesError_FieldPathArrayItemValue {
	fpaiv, err := ParseCreateTimeSeriesError_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type CreateTimeSeriesError_FieldTerminalPathArrayItemValue struct {
	CreateTimeSeriesError_FieldTerminalPath
	value interface{}
}

var _ CreateTimeSeriesError_FieldPathArrayItemValue = (*CreateTimeSeriesError_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *CreateTimeSeriesError_FieldTerminalPathArrayItemValue) GetSingle(source *CreateTimeSeriesError) (interface{}, bool) {
	return nil, false
}

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

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

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

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

// CreateTimeSeriesError_FieldPathArrayOfValues allows storing slice of values for CreateTimeSeriesError fields according to their type
type CreateTimeSeriesError_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	CreateTimeSeriesError_FieldPath
}

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

func MustParseCreateTimeSeriesError_FieldPathArrayOfValues(pathStr, valuesStr string) CreateTimeSeriesError_FieldPathArrayOfValues {
	fpaov, err := ParseCreateTimeSeriesError_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type CreateTimeSeriesError_FieldTerminalPathArrayOfValues struct {
	CreateTimeSeriesError_FieldTerminalPath
	values interface{}
}

var _ CreateTimeSeriesError_FieldPathArrayOfValues = (*CreateTimeSeriesError_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *CreateTimeSeriesError_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case CreateTimeSeriesError_FieldPathSelectorTimeSeries:
		for _, v := range fpaov.values.([]*time_serie.TimeSerie) {
			values = append(values, v)
		}
	case CreateTimeSeriesError_FieldPathSelectorStatus:
		for _, v := range fpaov.values.([]*rpc.Status) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *CreateTimeSeriesError_FieldTerminalPathArrayOfValues) AsTimeSeriesArrayOfValues() ([]*time_serie.TimeSerie, bool) {
	res, ok := fpaov.values.([]*time_serie.TimeSerie)
	return res, ok
}
func (fpaov *CreateTimeSeriesError_FieldTerminalPathArrayOfValues) AsStatusArrayOfValues() ([]*rpc.Status, bool) {
	res, ok := fpaov.values.([]*rpc.Status)
	return res, ok
}

type CreateTimeSeriesError_FieldSubPathArrayOfValues struct {
	CreateTimeSeriesError_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ CreateTimeSeriesError_FieldPathArrayOfValues = (*CreateTimeSeriesError_FieldSubPathArrayOfValues)(nil)

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