phantom_time_serie.pb.fieldpath.go

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

package phantom_time_serie

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 (
	ntt_meta "github.com/cloudwan/edgelq-sdk/common/types/meta"
	monitoring_common "github.com/cloudwan/edgelq-sdk/monitoring/common/v3"
	metric_descriptor "github.com/cloudwan/edgelq-sdk/monitoring/resources/v3/metric_descriptor"
	project "github.com/cloudwan/edgelq-sdk/monitoring/resources/v3/project"
	timestamp "github.com/golang/protobuf/ptypes/timestamp"
)

// ensure the imports are used
var (
	_ = json.Marshaler(nil)
	_ = fmt.Stringer(nil)
	_ = reflect.DeepEqual
	_ = strings.Builder{}
	_ = time.Second

	_ = strcase.ToLowerCamel
	_ = codes.NotFound
	_ = status.Status{}
	_ = protojson.UnmarshalOptions{}
	_ = proto.Message(nil)
	_ = protoregistry.GlobalTypes
	_ = fieldmaskpb.FieldMask{}

	_ = gotenobject.FieldPath(nil)
)

// make sure we're using proto imports
var (
	_ = &ntt_meta.Meta{}
	_ = &monitoring_common.LabelDescriptor{}
	_ = &metric_descriptor.MetricDescriptor{}
	_ = &project.Project{}
	_ = &timestamp.Timestamp{}
)

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

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

type PhantomTimeSerie_FieldPathSelector int32

const (
	PhantomTimeSerie_FieldPathSelectorMetadata   PhantomTimeSerie_FieldPathSelector = 0
	PhantomTimeSerie_FieldPathSelectorName       PhantomTimeSerie_FieldPathSelector = 1
	PhantomTimeSerie_FieldPathSelectorKey        PhantomTimeSerie_FieldPathSelector = 2
	PhantomTimeSerie_FieldPathSelectorProject    PhantomTimeSerie_FieldPathSelector = 3
	PhantomTimeSerie_FieldPathSelectorMetric     PhantomTimeSerie_FieldPathSelector = 4
	PhantomTimeSerie_FieldPathSelectorResource   PhantomTimeSerie_FieldPathSelector = 5
	PhantomTimeSerie_FieldPathSelectorMetricKind PhantomTimeSerie_FieldPathSelector = 6
	PhantomTimeSerie_FieldPathSelectorValueType  PhantomTimeSerie_FieldPathSelector = 7
	PhantomTimeSerie_FieldPathSelectorValue      PhantomTimeSerie_FieldPathSelector = 8
)

func (s PhantomTimeSerie_FieldPathSelector) String() string {
	switch s {
	case PhantomTimeSerie_FieldPathSelectorMetadata:
		return "metadata"
	case PhantomTimeSerie_FieldPathSelectorName:
		return "name"
	case PhantomTimeSerie_FieldPathSelectorKey:
		return "key"
	case PhantomTimeSerie_FieldPathSelectorProject:
		return "project"
	case PhantomTimeSerie_FieldPathSelectorMetric:
		return "metric"
	case PhantomTimeSerie_FieldPathSelectorResource:
		return "resource"
	case PhantomTimeSerie_FieldPathSelectorMetricKind:
		return "metric_kind"
	case PhantomTimeSerie_FieldPathSelectorValueType:
		return "value_type"
	case PhantomTimeSerie_FieldPathSelectorValue:
		return "value"
	default:
		panic(fmt.Sprintf("Invalid selector for PhantomTimeSerie: %d", s))
	}
}

func BuildPhantomTimeSerie_FieldPath(fp gotenobject.RawFieldPath) (PhantomTimeSerie_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object PhantomTimeSerie")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "metadata":
			return &PhantomTimeSerie_FieldTerminalPath{selector: PhantomTimeSerie_FieldPathSelectorMetadata}, nil
		case "name":
			return &PhantomTimeSerie_FieldTerminalPath{selector: PhantomTimeSerie_FieldPathSelectorName}, nil
		case "key":
			return &PhantomTimeSerie_FieldTerminalPath{selector: PhantomTimeSerie_FieldPathSelectorKey}, nil
		case "project":
			return &PhantomTimeSerie_FieldTerminalPath{selector: PhantomTimeSerie_FieldPathSelectorProject}, nil
		case "metric":
			return &PhantomTimeSerie_FieldTerminalPath{selector: PhantomTimeSerie_FieldPathSelectorMetric}, nil
		case "resource":
			return &PhantomTimeSerie_FieldTerminalPath{selector: PhantomTimeSerie_FieldPathSelectorResource}, nil
		case "metric_kind", "metricKind", "metric-kind":
			return &PhantomTimeSerie_FieldTerminalPath{selector: PhantomTimeSerie_FieldPathSelectorMetricKind}, nil
		case "value_type", "valueType", "value-type":
			return &PhantomTimeSerie_FieldTerminalPath{selector: PhantomTimeSerie_FieldPathSelectorValueType}, nil
		case "value":
			return &PhantomTimeSerie_FieldTerminalPath{selector: PhantomTimeSerie_FieldPathSelectorValue}, nil
		}
	} else {
		switch fp[0] {
		case "metadata":
			if subpath, err := ntt_meta.BuildMeta_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &PhantomTimeSerie_FieldSubPath{selector: PhantomTimeSerie_FieldPathSelectorMetadata, subPath: subpath}, nil
			}
		case "metric":
			if subpath, err := monitoring_common.BuildMetric_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &PhantomTimeSerie_FieldSubPath{selector: PhantomTimeSerie_FieldPathSelectorMetric, subPath: subpath}, nil
			}
		case "resource":
			if subpath, err := monitoring_common.BuildMonitoredResource_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &PhantomTimeSerie_FieldSubPath{selector: PhantomTimeSerie_FieldPathSelectorResource, subPath: subpath}, nil
			}
		case "value":
			if subpath, err := monitoring_common.BuildTypedValue_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &PhantomTimeSerie_FieldSubPath{selector: PhantomTimeSerie_FieldPathSelectorValue, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object PhantomTimeSerie", fp)
}

func ParsePhantomTimeSerie_FieldPath(rawField string) (PhantomTimeSerie_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildPhantomTimeSerie_FieldPath(fp)
}

func MustParsePhantomTimeSerie_FieldPath(rawField string) PhantomTimeSerie_FieldPath {
	fp, err := ParsePhantomTimeSerie_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type PhantomTimeSerie_FieldTerminalPath struct {
	selector PhantomTimeSerie_FieldPathSelector
}

var _ PhantomTimeSerie_FieldPath = (*PhantomTimeSerie_FieldTerminalPath)(nil)

func (fp *PhantomTimeSerie_FieldTerminalPath) Selector() PhantomTimeSerie_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source PhantomTimeSerie
func (fp *PhantomTimeSerie_FieldTerminalPath) Get(source *PhantomTimeSerie) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case PhantomTimeSerie_FieldPathSelectorMetadata:
			if source.Metadata != nil {
				values = append(values, source.Metadata)
			}
		case PhantomTimeSerie_FieldPathSelectorName:
			if source.Name != nil {
				values = append(values, source.Name)
			}
		case PhantomTimeSerie_FieldPathSelectorKey:
			values = append(values, source.Key)
		case PhantomTimeSerie_FieldPathSelectorProject:
			values = append(values, source.Project)
		case PhantomTimeSerie_FieldPathSelectorMetric:
			if source.Metric != nil {
				values = append(values, source.Metric)
			}
		case PhantomTimeSerie_FieldPathSelectorResource:
			if source.Resource != nil {
				values = append(values, source.Resource)
			}
		case PhantomTimeSerie_FieldPathSelectorMetricKind:
			values = append(values, source.MetricKind)
		case PhantomTimeSerie_FieldPathSelectorValueType:
			values = append(values, source.ValueType)
		case PhantomTimeSerie_FieldPathSelectorValue:
			if source.Value != nil {
				values = append(values, source.Value)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for PhantomTimeSerie: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source PhantomTimeSerie
func (fp *PhantomTimeSerie_FieldTerminalPath) GetSingle(source *PhantomTimeSerie) (interface{}, bool) {
	switch fp.selector {
	case PhantomTimeSerie_FieldPathSelectorMetadata:
		res := source.GetMetadata()
		return res, res != nil
	case PhantomTimeSerie_FieldPathSelectorName:
		res := source.GetName()
		return res, res != nil
	case PhantomTimeSerie_FieldPathSelectorKey:
		res := source.GetKey()
		return res, res != nil
	case PhantomTimeSerie_FieldPathSelectorProject:
		return source.GetProject(), source != nil
	case PhantomTimeSerie_FieldPathSelectorMetric:
		res := source.GetMetric()
		return res, res != nil
	case PhantomTimeSerie_FieldPathSelectorResource:
		res := source.GetResource()
		return res, res != nil
	case PhantomTimeSerie_FieldPathSelectorMetricKind:
		return source.GetMetricKind(), source != nil
	case PhantomTimeSerie_FieldPathSelectorValueType:
		return source.GetValueType(), source != nil
	case PhantomTimeSerie_FieldPathSelectorValue:
		res := source.GetValue()
		return res, res != nil
	default:
		panic(fmt.Sprintf("Invalid selector for PhantomTimeSerie: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *PhantomTimeSerie_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case PhantomTimeSerie_FieldPathSelectorMetadata:
		return (*ntt_meta.Meta)(nil)
	case PhantomTimeSerie_FieldPathSelectorName:
		return (*Name)(nil)
	case PhantomTimeSerie_FieldPathSelectorKey:
		return ([]byte)(nil)
	case PhantomTimeSerie_FieldPathSelectorProject:
		return ""
	case PhantomTimeSerie_FieldPathSelectorMetric:
		return (*monitoring_common.Metric)(nil)
	case PhantomTimeSerie_FieldPathSelectorResource:
		return (*monitoring_common.MonitoredResource)(nil)
	case PhantomTimeSerie_FieldPathSelectorMetricKind:
		return metric_descriptor.MetricDescriptor_METRIC_KIND_UNSPECIFIED
	case PhantomTimeSerie_FieldPathSelectorValueType:
		return metric_descriptor.MetricDescriptor_VALUE_TYPE_UNSPECIFIED
	case PhantomTimeSerie_FieldPathSelectorValue:
		return (*monitoring_common.TypedValue)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for PhantomTimeSerie: %d", fp.selector))
	}
}

func (fp *PhantomTimeSerie_FieldTerminalPath) ClearValue(item *PhantomTimeSerie) {
	if item != nil {
		switch fp.selector {
		case PhantomTimeSerie_FieldPathSelectorMetadata:
			item.Metadata = nil
		case PhantomTimeSerie_FieldPathSelectorName:
			item.Name = nil
		case PhantomTimeSerie_FieldPathSelectorKey:
			item.Key = nil
		case PhantomTimeSerie_FieldPathSelectorProject:
			item.Project = ""
		case PhantomTimeSerie_FieldPathSelectorMetric:
			item.Metric = nil
		case PhantomTimeSerie_FieldPathSelectorResource:
			item.Resource = nil
		case PhantomTimeSerie_FieldPathSelectorMetricKind:
			item.MetricKind = metric_descriptor.MetricDescriptor_METRIC_KIND_UNSPECIFIED
		case PhantomTimeSerie_FieldPathSelectorValueType:
			item.ValueType = metric_descriptor.MetricDescriptor_VALUE_TYPE_UNSPECIFIED
		case PhantomTimeSerie_FieldPathSelectorValue:
			item.Value = nil
		default:
			panic(fmt.Sprintf("Invalid selector for PhantomTimeSerie: %d", fp.selector))
		}
	}
}

func (fp *PhantomTimeSerie_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*PhantomTimeSerie))
}

// IsLeaf - whether field path is holds simple value
func (fp *PhantomTimeSerie_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == PhantomTimeSerie_FieldPathSelectorName ||
		fp.selector == PhantomTimeSerie_FieldPathSelectorKey ||
		fp.selector == PhantomTimeSerie_FieldPathSelectorProject ||
		fp.selector == PhantomTimeSerie_FieldPathSelectorMetricKind ||
		fp.selector == PhantomTimeSerie_FieldPathSelectorValueType
}

func (fp *PhantomTimeSerie_FieldTerminalPath) WithIValue(value interface{}) PhantomTimeSerie_FieldPathValue {
	switch fp.selector {
	case PhantomTimeSerie_FieldPathSelectorMetadata:
		return &PhantomTimeSerie_FieldTerminalPathValue{PhantomTimeSerie_FieldTerminalPath: *fp, value: value.(*ntt_meta.Meta)}
	case PhantomTimeSerie_FieldPathSelectorName:
		return &PhantomTimeSerie_FieldTerminalPathValue{PhantomTimeSerie_FieldTerminalPath: *fp, value: value.(*Name)}
	case PhantomTimeSerie_FieldPathSelectorKey:
		return &PhantomTimeSerie_FieldTerminalPathValue{PhantomTimeSerie_FieldTerminalPath: *fp, value: value.([]byte)}
	case PhantomTimeSerie_FieldPathSelectorProject:
		return &PhantomTimeSerie_FieldTerminalPathValue{PhantomTimeSerie_FieldTerminalPath: *fp, value: value.(string)}
	case PhantomTimeSerie_FieldPathSelectorMetric:
		return &PhantomTimeSerie_FieldTerminalPathValue{PhantomTimeSerie_FieldTerminalPath: *fp, value: value.(*monitoring_common.Metric)}
	case PhantomTimeSerie_FieldPathSelectorResource:
		return &PhantomTimeSerie_FieldTerminalPathValue{PhantomTimeSerie_FieldTerminalPath: *fp, value: value.(*monitoring_common.MonitoredResource)}
	case PhantomTimeSerie_FieldPathSelectorMetricKind:
		return &PhantomTimeSerie_FieldTerminalPathValue{PhantomTimeSerie_FieldTerminalPath: *fp, value: value.(metric_descriptor.MetricDescriptor_MetricKind)}
	case PhantomTimeSerie_FieldPathSelectorValueType:
		return &PhantomTimeSerie_FieldTerminalPathValue{PhantomTimeSerie_FieldTerminalPath: *fp, value: value.(metric_descriptor.MetricDescriptor_ValueType)}
	case PhantomTimeSerie_FieldPathSelectorValue:
		return &PhantomTimeSerie_FieldTerminalPathValue{PhantomTimeSerie_FieldTerminalPath: *fp, value: value.(*monitoring_common.TypedValue)}
	default:
		panic(fmt.Sprintf("Invalid selector for PhantomTimeSerie: %d", fp.selector))
	}
}

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

func (fp *PhantomTimeSerie_FieldTerminalPath) WithIArrayOfValues(values interface{}) PhantomTimeSerie_FieldPathArrayOfValues {
	fpaov := &PhantomTimeSerie_FieldTerminalPathArrayOfValues{PhantomTimeSerie_FieldTerminalPath: *fp}
	switch fp.selector {
	case PhantomTimeSerie_FieldPathSelectorMetadata:
		return &PhantomTimeSerie_FieldTerminalPathArrayOfValues{PhantomTimeSerie_FieldTerminalPath: *fp, values: values.([]*ntt_meta.Meta)}
	case PhantomTimeSerie_FieldPathSelectorName:
		return &PhantomTimeSerie_FieldTerminalPathArrayOfValues{PhantomTimeSerie_FieldTerminalPath: *fp, values: values.([]*Name)}
	case PhantomTimeSerie_FieldPathSelectorKey:
		return &PhantomTimeSerie_FieldTerminalPathArrayOfValues{PhantomTimeSerie_FieldTerminalPath: *fp, values: values.([][]byte)}
	case PhantomTimeSerie_FieldPathSelectorProject:
		return &PhantomTimeSerie_FieldTerminalPathArrayOfValues{PhantomTimeSerie_FieldTerminalPath: *fp, values: values.([]string)}
	case PhantomTimeSerie_FieldPathSelectorMetric:
		return &PhantomTimeSerie_FieldTerminalPathArrayOfValues{PhantomTimeSerie_FieldTerminalPath: *fp, values: values.([]*monitoring_common.Metric)}
	case PhantomTimeSerie_FieldPathSelectorResource:
		return &PhantomTimeSerie_FieldTerminalPathArrayOfValues{PhantomTimeSerie_FieldTerminalPath: *fp, values: values.([]*monitoring_common.MonitoredResource)}
	case PhantomTimeSerie_FieldPathSelectorMetricKind:
		return &PhantomTimeSerie_FieldTerminalPathArrayOfValues{PhantomTimeSerie_FieldTerminalPath: *fp, values: values.([]metric_descriptor.MetricDescriptor_MetricKind)}
	case PhantomTimeSerie_FieldPathSelectorValueType:
		return &PhantomTimeSerie_FieldTerminalPathArrayOfValues{PhantomTimeSerie_FieldTerminalPath: *fp, values: values.([]metric_descriptor.MetricDescriptor_ValueType)}
	case PhantomTimeSerie_FieldPathSelectorValue:
		return &PhantomTimeSerie_FieldTerminalPathArrayOfValues{PhantomTimeSerie_FieldTerminalPath: *fp, values: values.([]*monitoring_common.TypedValue)}
	default:
		panic(fmt.Sprintf("Invalid selector for PhantomTimeSerie: %d", fp.selector))
	}
	return fpaov
}

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

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

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

type PhantomTimeSerie_FieldSubPath struct {
	selector PhantomTimeSerie_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ PhantomTimeSerie_FieldPath = (*PhantomTimeSerie_FieldSubPath)(nil)

func (fps *PhantomTimeSerie_FieldSubPath) Selector() PhantomTimeSerie_FieldPathSelector {
	return fps.selector
}
func (fps *PhantomTimeSerie_FieldSubPath) AsMetadataSubPath() (ntt_meta.Meta_FieldPath, bool) {
	res, ok := fps.subPath.(ntt_meta.Meta_FieldPath)
	return res, ok
}
func (fps *PhantomTimeSerie_FieldSubPath) AsMetricSubPath() (monitoring_common.Metric_FieldPath, bool) {
	res, ok := fps.subPath.(monitoring_common.Metric_FieldPath)
	return res, ok
}
func (fps *PhantomTimeSerie_FieldSubPath) AsResourceSubPath() (monitoring_common.MonitoredResource_FieldPath, bool) {
	res, ok := fps.subPath.(monitoring_common.MonitoredResource_FieldPath)
	return res, ok
}
func (fps *PhantomTimeSerie_FieldSubPath) AsValueSubPath() (monitoring_common.TypedValue_FieldPath, bool) {
	res, ok := fps.subPath.(monitoring_common.TypedValue_FieldPath)
	return res, ok
}

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

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

// Get returns all values pointed by selected field from source PhantomTimeSerie
func (fps *PhantomTimeSerie_FieldSubPath) Get(source *PhantomTimeSerie) (values []interface{}) {
	if asMetaFieldPath, ok := fps.AsMetadataSubPath(); ok {
		values = append(values, asMetaFieldPath.Get(source.GetMetadata())...)
	} else if asMetricFieldPath, ok := fps.AsMetricSubPath(); ok {
		values = append(values, asMetricFieldPath.Get(source.GetMetric())...)
	} else if asMonitoredResourceFieldPath, ok := fps.AsResourceSubPath(); ok {
		values = append(values, asMonitoredResourceFieldPath.Get(source.GetResource())...)
	} else if asTypedValueFieldPath, ok := fps.AsValueSubPath(); ok {
		values = append(values, asTypedValueFieldPath.Get(source.GetValue())...)
	} else {
		panic(fmt.Sprintf("Invalid selector for PhantomTimeSerie: %d", fps.selector))
	}
	return
}

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

// GetSingle returns value of selected field from source PhantomTimeSerie
func (fps *PhantomTimeSerie_FieldSubPath) GetSingle(source *PhantomTimeSerie) (interface{}, bool) {
	switch fps.selector {
	case PhantomTimeSerie_FieldPathSelectorMetadata:
		if source.GetMetadata() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetMetadata())
	case PhantomTimeSerie_FieldPathSelectorMetric:
		if source.GetMetric() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetMetric())
	case PhantomTimeSerie_FieldPathSelectorResource:
		if source.GetResource() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetResource())
	case PhantomTimeSerie_FieldPathSelectorValue:
		if source.GetValue() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetValue())
	default:
		panic(fmt.Sprintf("Invalid selector for PhantomTimeSerie: %d", fps.selector))
	}
}

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

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

func (fps *PhantomTimeSerie_FieldSubPath) ClearValue(item *PhantomTimeSerie) {
	if item != nil {
		switch fps.selector {
		case PhantomTimeSerie_FieldPathSelectorMetadata:
			fps.subPath.ClearValueRaw(item.Metadata)
		case PhantomTimeSerie_FieldPathSelectorMetric:
			fps.subPath.ClearValueRaw(item.Metric)
		case PhantomTimeSerie_FieldPathSelectorResource:
			fps.subPath.ClearValueRaw(item.Resource)
		case PhantomTimeSerie_FieldPathSelectorValue:
			fps.subPath.ClearValueRaw(item.Value)
		default:
			panic(fmt.Sprintf("Invalid selector for PhantomTimeSerie: %d", fps.selector))
		}
	}
}

func (fps *PhantomTimeSerie_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*PhantomTimeSerie))
}

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

func (fps *PhantomTimeSerie_FieldSubPath) WithIValue(value interface{}) PhantomTimeSerie_FieldPathValue {
	return &PhantomTimeSerie_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *PhantomTimeSerie_FieldSubPath) WithIArrayOfValues(values interface{}) PhantomTimeSerie_FieldPathArrayOfValues {
	return &PhantomTimeSerie_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *PhantomTimeSerie_FieldSubPath) WithIArrayItemValue(value interface{}) PhantomTimeSerie_FieldPathArrayItemValue {
	return &PhantomTimeSerie_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

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

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

func MustParsePhantomTimeSerie_FieldPathValue(pathStr, valueStr string) PhantomTimeSerie_FieldPathValue {
	fpv, err := ParsePhantomTimeSerie_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type PhantomTimeSerie_FieldTerminalPathValue struct {
	PhantomTimeSerie_FieldTerminalPath
	value interface{}
}

var _ PhantomTimeSerie_FieldPathValue = (*PhantomTimeSerie_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'PhantomTimeSerie' as interface{}
func (fpv *PhantomTimeSerie_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *PhantomTimeSerie_FieldTerminalPathValue) AsMetadataValue() (*ntt_meta.Meta, bool) {
	res, ok := fpv.value.(*ntt_meta.Meta)
	return res, ok
}
func (fpv *PhantomTimeSerie_FieldTerminalPathValue) AsNameValue() (*Name, bool) {
	res, ok := fpv.value.(*Name)
	return res, ok
}
func (fpv *PhantomTimeSerie_FieldTerminalPathValue) AsKeyValue() ([]byte, bool) {
	res, ok := fpv.value.([]byte)
	return res, ok
}
func (fpv *PhantomTimeSerie_FieldTerminalPathValue) AsProjectValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *PhantomTimeSerie_FieldTerminalPathValue) AsMetricValue() (*monitoring_common.Metric, bool) {
	res, ok := fpv.value.(*monitoring_common.Metric)
	return res, ok
}
func (fpv *PhantomTimeSerie_FieldTerminalPathValue) AsResourceValue() (*monitoring_common.MonitoredResource, bool) {
	res, ok := fpv.value.(*monitoring_common.MonitoredResource)
	return res, ok
}
func (fpv *PhantomTimeSerie_FieldTerminalPathValue) AsMetricKindValue() (metric_descriptor.MetricDescriptor_MetricKind, bool) {
	res, ok := fpv.value.(metric_descriptor.MetricDescriptor_MetricKind)
	return res, ok
}
func (fpv *PhantomTimeSerie_FieldTerminalPathValue) AsValueTypeValue() (metric_descriptor.MetricDescriptor_ValueType, bool) {
	res, ok := fpv.value.(metric_descriptor.MetricDescriptor_ValueType)
	return res, ok
}
func (fpv *PhantomTimeSerie_FieldTerminalPathValue) AsValueValue() (*monitoring_common.TypedValue, bool) {
	res, ok := fpv.value.(*monitoring_common.TypedValue)
	return res, ok
}

// SetTo stores value for selected field for object PhantomTimeSerie
func (fpv *PhantomTimeSerie_FieldTerminalPathValue) SetTo(target **PhantomTimeSerie) {
	if *target == nil {
		*target = new(PhantomTimeSerie)
	}
	switch fpv.selector {
	case PhantomTimeSerie_FieldPathSelectorMetadata:
		(*target).Metadata = fpv.value.(*ntt_meta.Meta)
	case PhantomTimeSerie_FieldPathSelectorName:
		(*target).Name = fpv.value.(*Name)
	case PhantomTimeSerie_FieldPathSelectorKey:
		(*target).Key = fpv.value.([]byte)
	case PhantomTimeSerie_FieldPathSelectorProject:
		(*target).Project = fpv.value.(string)
	case PhantomTimeSerie_FieldPathSelectorMetric:
		(*target).Metric = fpv.value.(*monitoring_common.Metric)
	case PhantomTimeSerie_FieldPathSelectorResource:
		(*target).Resource = fpv.value.(*monitoring_common.MonitoredResource)
	case PhantomTimeSerie_FieldPathSelectorMetricKind:
		(*target).MetricKind = fpv.value.(metric_descriptor.MetricDescriptor_MetricKind)
	case PhantomTimeSerie_FieldPathSelectorValueType:
		(*target).ValueType = fpv.value.(metric_descriptor.MetricDescriptor_ValueType)
	case PhantomTimeSerie_FieldPathSelectorValue:
		(*target).Value = fpv.value.(*monitoring_common.TypedValue)
	default:
		panic(fmt.Sprintf("Invalid selector for PhantomTimeSerie: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'PhantomTimeSerie_FieldTerminalPathValue' with the value under path in 'PhantomTimeSerie'.
func (fpv *PhantomTimeSerie_FieldTerminalPathValue) CompareWith(source *PhantomTimeSerie) (int, bool) {
	switch fpv.selector {
	case PhantomTimeSerie_FieldPathSelectorMetadata:
		return 0, false
	case PhantomTimeSerie_FieldPathSelectorName:
		leftValue := fpv.value.(*Name)
		rightValue := source.GetName()
		if leftValue == nil {
			if rightValue != nil {
				return -1, true
			}
			return 0, true
		}
		if rightValue == nil {
			return 1, true
		}
		if leftValue.String() == rightValue.String() {
			return 0, true
		} else if leftValue.String() < rightValue.String() {
			return -1, true
		} else {
			return 1, true
		}
	case PhantomTimeSerie_FieldPathSelectorKey:
		return 0, false
	case PhantomTimeSerie_FieldPathSelectorProject:
		leftValue := fpv.value.(string)
		rightValue := source.GetProject()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case PhantomTimeSerie_FieldPathSelectorMetric:
		return 0, false
	case PhantomTimeSerie_FieldPathSelectorResource:
		return 0, false
	case PhantomTimeSerie_FieldPathSelectorMetricKind:
		leftValue := fpv.value.(metric_descriptor.MetricDescriptor_MetricKind)
		rightValue := source.GetMetricKind()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case PhantomTimeSerie_FieldPathSelectorValueType:
		leftValue := fpv.value.(metric_descriptor.MetricDescriptor_ValueType)
		rightValue := source.GetValueType()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case PhantomTimeSerie_FieldPathSelectorValue:
		return 0, false
	default:
		panic(fmt.Sprintf("Invalid selector for PhantomTimeSerie: %d", fpv.selector))
	}
}

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

type PhantomTimeSerie_FieldSubPathValue struct {
	PhantomTimeSerie_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ PhantomTimeSerie_FieldPathValue = (*PhantomTimeSerie_FieldSubPathValue)(nil)

func (fpvs *PhantomTimeSerie_FieldSubPathValue) AsMetadataPathValue() (ntt_meta.Meta_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(ntt_meta.Meta_FieldPathValue)
	return res, ok
}
func (fpvs *PhantomTimeSerie_FieldSubPathValue) AsMetricPathValue() (monitoring_common.Metric_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(monitoring_common.Metric_FieldPathValue)
	return res, ok
}
func (fpvs *PhantomTimeSerie_FieldSubPathValue) AsResourcePathValue() (monitoring_common.MonitoredResource_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(monitoring_common.MonitoredResource_FieldPathValue)
	return res, ok
}
func (fpvs *PhantomTimeSerie_FieldSubPathValue) AsValuePathValue() (monitoring_common.TypedValue_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(monitoring_common.TypedValue_FieldPathValue)
	return res, ok
}

func (fpvs *PhantomTimeSerie_FieldSubPathValue) SetTo(target **PhantomTimeSerie) {
	if *target == nil {
		*target = new(PhantomTimeSerie)
	}
	switch fpvs.Selector() {
	case PhantomTimeSerie_FieldPathSelectorMetadata:
		fpvs.subPathValue.(ntt_meta.Meta_FieldPathValue).SetTo(&(*target).Metadata)
	case PhantomTimeSerie_FieldPathSelectorMetric:
		fpvs.subPathValue.(monitoring_common.Metric_FieldPathValue).SetTo(&(*target).Metric)
	case PhantomTimeSerie_FieldPathSelectorResource:
		fpvs.subPathValue.(monitoring_common.MonitoredResource_FieldPathValue).SetTo(&(*target).Resource)
	case PhantomTimeSerie_FieldPathSelectorValue:
		fpvs.subPathValue.(monitoring_common.TypedValue_FieldPathValue).SetTo(&(*target).Value)
	default:
		panic(fmt.Sprintf("Invalid selector for PhantomTimeSerie: %d", fpvs.Selector()))
	}
}

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

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

func (fpvs *PhantomTimeSerie_FieldSubPathValue) CompareWith(source *PhantomTimeSerie) (int, bool) {
	switch fpvs.Selector() {
	case PhantomTimeSerie_FieldPathSelectorMetadata:
		return fpvs.subPathValue.(ntt_meta.Meta_FieldPathValue).CompareWith(source.GetMetadata())
	case PhantomTimeSerie_FieldPathSelectorMetric:
		return fpvs.subPathValue.(monitoring_common.Metric_FieldPathValue).CompareWith(source.GetMetric())
	case PhantomTimeSerie_FieldPathSelectorResource:
		return fpvs.subPathValue.(monitoring_common.MonitoredResource_FieldPathValue).CompareWith(source.GetResource())
	case PhantomTimeSerie_FieldPathSelectorValue:
		return fpvs.subPathValue.(monitoring_common.TypedValue_FieldPathValue).CompareWith(source.GetValue())
	default:
		panic(fmt.Sprintf("Invalid selector for PhantomTimeSerie: %d", fpvs.Selector()))
	}
}

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

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

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

func MustParsePhantomTimeSerie_FieldPathArrayItemValue(pathStr, valueStr string) PhantomTimeSerie_FieldPathArrayItemValue {
	fpaiv, err := ParsePhantomTimeSerie_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type PhantomTimeSerie_FieldTerminalPathArrayItemValue struct {
	PhantomTimeSerie_FieldTerminalPath
	value interface{}
}

var _ PhantomTimeSerie_FieldPathArrayItemValue = (*PhantomTimeSerie_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *PhantomTimeSerie_FieldTerminalPathArrayItemValue) GetSingle(source *PhantomTimeSerie) (interface{}, bool) {
	return nil, false
}

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

// Contains returns a boolean indicating if value that is being held is present in given 'PhantomTimeSerie'
func (fpaiv *PhantomTimeSerie_FieldTerminalPathArrayItemValue) ContainsValue(source *PhantomTimeSerie) bool {
	slice := fpaiv.PhantomTimeSerie_FieldTerminalPath.Get(source)
	for _, v := range slice {
		if reflect.DeepEqual(v, fpaiv.value) {
			return true
		}
	}
	return false
}

type PhantomTimeSerie_FieldSubPathArrayItemValue struct {
	PhantomTimeSerie_FieldPath
	subPathItemValue gotenobject.FieldPathArrayItemValue
}

// GetRawValue returns stored array item value
func (fpaivs *PhantomTimeSerie_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *PhantomTimeSerie_FieldSubPathArrayItemValue) AsMetadataPathItemValue() (ntt_meta.Meta_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(ntt_meta.Meta_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *PhantomTimeSerie_FieldSubPathArrayItemValue) AsMetricPathItemValue() (monitoring_common.Metric_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(monitoring_common.Metric_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *PhantomTimeSerie_FieldSubPathArrayItemValue) AsResourcePathItemValue() (monitoring_common.MonitoredResource_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(monitoring_common.MonitoredResource_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *PhantomTimeSerie_FieldSubPathArrayItemValue) AsValuePathItemValue() (monitoring_common.TypedValue_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(monitoring_common.TypedValue_FieldPathArrayItemValue)
	return res, ok
}

// Contains returns a boolean indicating if value that is being held is present in given 'PhantomTimeSerie'
func (fpaivs *PhantomTimeSerie_FieldSubPathArrayItemValue) ContainsValue(source *PhantomTimeSerie) bool {
	switch fpaivs.Selector() {
	case PhantomTimeSerie_FieldPathSelectorMetadata:
		return fpaivs.subPathItemValue.(ntt_meta.Meta_FieldPathArrayItemValue).ContainsValue(source.GetMetadata())
	case PhantomTimeSerie_FieldPathSelectorMetric:
		return fpaivs.subPathItemValue.(monitoring_common.Metric_FieldPathArrayItemValue).ContainsValue(source.GetMetric())
	case PhantomTimeSerie_FieldPathSelectorResource:
		return fpaivs.subPathItemValue.(monitoring_common.MonitoredResource_FieldPathArrayItemValue).ContainsValue(source.GetResource())
	case PhantomTimeSerie_FieldPathSelectorValue:
		return fpaivs.subPathItemValue.(monitoring_common.TypedValue_FieldPathArrayItemValue).ContainsValue(source.GetValue())
	default:
		panic(fmt.Sprintf("Invalid selector for PhantomTimeSerie: %d", fpaivs.Selector()))
	}
}

// PhantomTimeSerie_FieldPathArrayOfValues allows storing slice of values for PhantomTimeSerie fields according to their type
type PhantomTimeSerie_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	PhantomTimeSerie_FieldPath
}

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

func MustParsePhantomTimeSerie_FieldPathArrayOfValues(pathStr, valuesStr string) PhantomTimeSerie_FieldPathArrayOfValues {
	fpaov, err := ParsePhantomTimeSerie_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type PhantomTimeSerie_FieldTerminalPathArrayOfValues struct {
	PhantomTimeSerie_FieldTerminalPath
	values interface{}
}

var _ PhantomTimeSerie_FieldPathArrayOfValues = (*PhantomTimeSerie_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *PhantomTimeSerie_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case PhantomTimeSerie_FieldPathSelectorMetadata:
		for _, v := range fpaov.values.([]*ntt_meta.Meta) {
			values = append(values, v)
		}
	case PhantomTimeSerie_FieldPathSelectorName:
		for _, v := range fpaov.values.([]*Name) {
			values = append(values, v)
		}
	case PhantomTimeSerie_FieldPathSelectorKey:
		for _, v := range fpaov.values.([][]byte) {
			values = append(values, v)
		}
	case PhantomTimeSerie_FieldPathSelectorProject:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case PhantomTimeSerie_FieldPathSelectorMetric:
		for _, v := range fpaov.values.([]*monitoring_common.Metric) {
			values = append(values, v)
		}
	case PhantomTimeSerie_FieldPathSelectorResource:
		for _, v := range fpaov.values.([]*monitoring_common.MonitoredResource) {
			values = append(values, v)
		}
	case PhantomTimeSerie_FieldPathSelectorMetricKind:
		for _, v := range fpaov.values.([]metric_descriptor.MetricDescriptor_MetricKind) {
			values = append(values, v)
		}
	case PhantomTimeSerie_FieldPathSelectorValueType:
		for _, v := range fpaov.values.([]metric_descriptor.MetricDescriptor_ValueType) {
			values = append(values, v)
		}
	case PhantomTimeSerie_FieldPathSelectorValue:
		for _, v := range fpaov.values.([]*monitoring_common.TypedValue) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *PhantomTimeSerie_FieldTerminalPathArrayOfValues) AsMetadataArrayOfValues() ([]*ntt_meta.Meta, bool) {
	res, ok := fpaov.values.([]*ntt_meta.Meta)
	return res, ok
}
func (fpaov *PhantomTimeSerie_FieldTerminalPathArrayOfValues) AsNameArrayOfValues() ([]*Name, bool) {
	res, ok := fpaov.values.([]*Name)
	return res, ok
}
func (fpaov *PhantomTimeSerie_FieldTerminalPathArrayOfValues) AsKeyArrayOfValues() ([][]byte, bool) {
	res, ok := fpaov.values.([][]byte)
	return res, ok
}
func (fpaov *PhantomTimeSerie_FieldTerminalPathArrayOfValues) AsProjectArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *PhantomTimeSerie_FieldTerminalPathArrayOfValues) AsMetricArrayOfValues() ([]*monitoring_common.Metric, bool) {
	res, ok := fpaov.values.([]*monitoring_common.Metric)
	return res, ok
}
func (fpaov *PhantomTimeSerie_FieldTerminalPathArrayOfValues) AsResourceArrayOfValues() ([]*monitoring_common.MonitoredResource, bool) {
	res, ok := fpaov.values.([]*monitoring_common.MonitoredResource)
	return res, ok
}
func (fpaov *PhantomTimeSerie_FieldTerminalPathArrayOfValues) AsMetricKindArrayOfValues() ([]metric_descriptor.MetricDescriptor_MetricKind, bool) {
	res, ok := fpaov.values.([]metric_descriptor.MetricDescriptor_MetricKind)
	return res, ok
}
func (fpaov *PhantomTimeSerie_FieldTerminalPathArrayOfValues) AsValueTypeArrayOfValues() ([]metric_descriptor.MetricDescriptor_ValueType, bool) {
	res, ok := fpaov.values.([]metric_descriptor.MetricDescriptor_ValueType)
	return res, ok
}
func (fpaov *PhantomTimeSerie_FieldTerminalPathArrayOfValues) AsValueArrayOfValues() ([]*monitoring_common.TypedValue, bool) {
	res, ok := fpaov.values.([]*monitoring_common.TypedValue)
	return res, ok
}

type PhantomTimeSerie_FieldSubPathArrayOfValues struct {
	PhantomTimeSerie_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ PhantomTimeSerie_FieldPathArrayOfValues = (*PhantomTimeSerie_FieldSubPathArrayOfValues)(nil)

func (fpsaov *PhantomTimeSerie_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *PhantomTimeSerie_FieldSubPathArrayOfValues) AsMetadataPathArrayOfValues() (ntt_meta.Meta_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(ntt_meta.Meta_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *PhantomTimeSerie_FieldSubPathArrayOfValues) AsMetricPathArrayOfValues() (monitoring_common.Metric_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(monitoring_common.Metric_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *PhantomTimeSerie_FieldSubPathArrayOfValues) AsResourcePathArrayOfValues() (monitoring_common.MonitoredResource_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(monitoring_common.MonitoredResource_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *PhantomTimeSerie_FieldSubPathArrayOfValues) AsValuePathArrayOfValues() (monitoring_common.TypedValue_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(monitoring_common.TypedValue_FieldPathArrayOfValues)
	return res, ok
}

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

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

type PhantomTimeSeriesBulkChange_FieldPathSelector int32

const (
	PhantomTimeSeriesBulkChange_FieldPathSelectorResync    PhantomTimeSeriesBulkChange_FieldPathSelector = 0
	PhantomTimeSeriesBulkChange_FieldPathSelectorPartition PhantomTimeSeriesBulkChange_FieldPathSelector = 1
	PhantomTimeSeriesBulkChange_FieldPathSelectorAdded     PhantomTimeSeriesBulkChange_FieldPathSelector = 2
	PhantomTimeSeriesBulkChange_FieldPathSelectorRemoved   PhantomTimeSeriesBulkChange_FieldPathSelector = 3
	PhantomTimeSeriesBulkChange_FieldPathSelectorStartTime PhantomTimeSeriesBulkChange_FieldPathSelector = 4
	PhantomTimeSeriesBulkChange_FieldPathSelectorMsgTime   PhantomTimeSeriesBulkChange_FieldPathSelector = 5
)

func (s PhantomTimeSeriesBulkChange_FieldPathSelector) String() string {
	switch s {
	case PhantomTimeSeriesBulkChange_FieldPathSelectorResync:
		return "resync"
	case PhantomTimeSeriesBulkChange_FieldPathSelectorPartition:
		return "partition"
	case PhantomTimeSeriesBulkChange_FieldPathSelectorAdded:
		return "added"
	case PhantomTimeSeriesBulkChange_FieldPathSelectorRemoved:
		return "removed"
	case PhantomTimeSeriesBulkChange_FieldPathSelectorStartTime:
		return "start_time"
	case PhantomTimeSeriesBulkChange_FieldPathSelectorMsgTime:
		return "msg_time"
	default:
		panic(fmt.Sprintf("Invalid selector for PhantomTimeSeriesBulkChange: %d", s))
	}
}

func BuildPhantomTimeSeriesBulkChange_FieldPath(fp gotenobject.RawFieldPath) (PhantomTimeSeriesBulkChange_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object PhantomTimeSeriesBulkChange")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "resync":
			return &PhantomTimeSeriesBulkChange_FieldTerminalPath{selector: PhantomTimeSeriesBulkChange_FieldPathSelectorResync}, nil
		case "partition":
			return &PhantomTimeSeriesBulkChange_FieldTerminalPath{selector: PhantomTimeSeriesBulkChange_FieldPathSelectorPartition}, nil
		case "added":
			return &PhantomTimeSeriesBulkChange_FieldTerminalPath{selector: PhantomTimeSeriesBulkChange_FieldPathSelectorAdded}, nil
		case "removed":
			return &PhantomTimeSeriesBulkChange_FieldTerminalPath{selector: PhantomTimeSeriesBulkChange_FieldPathSelectorRemoved}, nil
		case "start_time", "startTime", "start-time":
			return &PhantomTimeSeriesBulkChange_FieldTerminalPath{selector: PhantomTimeSeriesBulkChange_FieldPathSelectorStartTime}, nil
		case "msg_time", "msgTime", "msg-time":
			return &PhantomTimeSeriesBulkChange_FieldTerminalPath{selector: PhantomTimeSeriesBulkChange_FieldPathSelectorMsgTime}, nil
		}
	} else {
		switch fp[0] {
		case "added":
			if subpath, err := BuildPhantomTimeSerie_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &PhantomTimeSeriesBulkChange_FieldSubPath{selector: PhantomTimeSeriesBulkChange_FieldPathSelectorAdded, subPath: subpath}, nil
			}
		case "removed":
			if subpath, err := BuildPhantomTimeSerie_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &PhantomTimeSeriesBulkChange_FieldSubPath{selector: PhantomTimeSeriesBulkChange_FieldPathSelectorRemoved, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object PhantomTimeSeriesBulkChange", fp)
}

func ParsePhantomTimeSeriesBulkChange_FieldPath(rawField string) (PhantomTimeSeriesBulkChange_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildPhantomTimeSeriesBulkChange_FieldPath(fp)
}

func MustParsePhantomTimeSeriesBulkChange_FieldPath(rawField string) PhantomTimeSeriesBulkChange_FieldPath {
	fp, err := ParsePhantomTimeSeriesBulkChange_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type PhantomTimeSeriesBulkChange_FieldTerminalPath struct {
	selector PhantomTimeSeriesBulkChange_FieldPathSelector
}

var _ PhantomTimeSeriesBulkChange_FieldPath = (*PhantomTimeSeriesBulkChange_FieldTerminalPath)(nil)

func (fp *PhantomTimeSeriesBulkChange_FieldTerminalPath) Selector() PhantomTimeSeriesBulkChange_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source PhantomTimeSeriesBulkChange
func (fp *PhantomTimeSeriesBulkChange_FieldTerminalPath) Get(source *PhantomTimeSeriesBulkChange) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case PhantomTimeSeriesBulkChange_FieldPathSelectorResync:
			values = append(values, source.Resync)
		case PhantomTimeSeriesBulkChange_FieldPathSelectorPartition:
			values = append(values, source.Partition)
		case PhantomTimeSeriesBulkChange_FieldPathSelectorAdded:
			for _, value := range source.GetAdded() {
				values = append(values, value)
			}
		case PhantomTimeSeriesBulkChange_FieldPathSelectorRemoved:
			for _, value := range source.GetRemoved() {
				values = append(values, value)
			}
		case PhantomTimeSeriesBulkChange_FieldPathSelectorStartTime:
			if source.StartTime != nil {
				values = append(values, source.StartTime)
			}
		case PhantomTimeSeriesBulkChange_FieldPathSelectorMsgTime:
			if source.MsgTime != nil {
				values = append(values, source.MsgTime)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for PhantomTimeSeriesBulkChange: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source PhantomTimeSeriesBulkChange
func (fp *PhantomTimeSeriesBulkChange_FieldTerminalPath) GetSingle(source *PhantomTimeSeriesBulkChange) (interface{}, bool) {
	switch fp.selector {
	case PhantomTimeSeriesBulkChange_FieldPathSelectorResync:
		return source.GetResync(), source != nil
	case PhantomTimeSeriesBulkChange_FieldPathSelectorPartition:
		res := source.GetPartition()
		return res, res != nil
	case PhantomTimeSeriesBulkChange_FieldPathSelectorAdded:
		res := source.GetAdded()
		return res, res != nil
	case PhantomTimeSeriesBulkChange_FieldPathSelectorRemoved:
		res := source.GetRemoved()
		return res, res != nil
	case PhantomTimeSeriesBulkChange_FieldPathSelectorStartTime:
		res := source.GetStartTime()
		return res, res != nil
	case PhantomTimeSeriesBulkChange_FieldPathSelectorMsgTime:
		res := source.GetMsgTime()
		return res, res != nil
	default:
		panic(fmt.Sprintf("Invalid selector for PhantomTimeSeriesBulkChange: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *PhantomTimeSeriesBulkChange_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case PhantomTimeSeriesBulkChange_FieldPathSelectorResync:
		return false
	case PhantomTimeSeriesBulkChange_FieldPathSelectorPartition:
		return ([]byte)(nil)
	case PhantomTimeSeriesBulkChange_FieldPathSelectorAdded:
		return ([]*PhantomTimeSerie)(nil)
	case PhantomTimeSeriesBulkChange_FieldPathSelectorRemoved:
		return ([]*PhantomTimeSerie)(nil)
	case PhantomTimeSeriesBulkChange_FieldPathSelectorStartTime:
		return (*timestamp.Timestamp)(nil)
	case PhantomTimeSeriesBulkChange_FieldPathSelectorMsgTime:
		return (*timestamp.Timestamp)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for PhantomTimeSeriesBulkChange: %d", fp.selector))
	}
}

func (fp *PhantomTimeSeriesBulkChange_FieldTerminalPath) ClearValue(item *PhantomTimeSeriesBulkChange) {
	if item != nil {
		switch fp.selector {
		case PhantomTimeSeriesBulkChange_FieldPathSelectorResync:
			item.Resync = false
		case PhantomTimeSeriesBulkChange_FieldPathSelectorPartition:
			item.Partition = nil
		case PhantomTimeSeriesBulkChange_FieldPathSelectorAdded:
			item.Added = nil
		case PhantomTimeSeriesBulkChange_FieldPathSelectorRemoved:
			item.Removed = nil
		case PhantomTimeSeriesBulkChange_FieldPathSelectorStartTime:
			item.StartTime = nil
		case PhantomTimeSeriesBulkChange_FieldPathSelectorMsgTime:
			item.MsgTime = nil
		default:
			panic(fmt.Sprintf("Invalid selector for PhantomTimeSeriesBulkChange: %d", fp.selector))
		}
	}
}

func (fp *PhantomTimeSeriesBulkChange_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*PhantomTimeSeriesBulkChange))
}

// IsLeaf - whether field path is holds simple value
func (fp *PhantomTimeSeriesBulkChange_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == PhantomTimeSeriesBulkChange_FieldPathSelectorResync ||
		fp.selector == PhantomTimeSeriesBulkChange_FieldPathSelectorPartition ||
		fp.selector == PhantomTimeSeriesBulkChange_FieldPathSelectorStartTime ||
		fp.selector == PhantomTimeSeriesBulkChange_FieldPathSelectorMsgTime
}

func (fp *PhantomTimeSeriesBulkChange_FieldTerminalPath) WithIValue(value interface{}) PhantomTimeSeriesBulkChange_FieldPathValue {
	switch fp.selector {
	case PhantomTimeSeriesBulkChange_FieldPathSelectorResync:
		return &PhantomTimeSeriesBulkChange_FieldTerminalPathValue{PhantomTimeSeriesBulkChange_FieldTerminalPath: *fp, value: value.(bool)}
	case PhantomTimeSeriesBulkChange_FieldPathSelectorPartition:
		return &PhantomTimeSeriesBulkChange_FieldTerminalPathValue{PhantomTimeSeriesBulkChange_FieldTerminalPath: *fp, value: value.([]byte)}
	case PhantomTimeSeriesBulkChange_FieldPathSelectorAdded:
		return &PhantomTimeSeriesBulkChange_FieldTerminalPathValue{PhantomTimeSeriesBulkChange_FieldTerminalPath: *fp, value: value.([]*PhantomTimeSerie)}
	case PhantomTimeSeriesBulkChange_FieldPathSelectorRemoved:
		return &PhantomTimeSeriesBulkChange_FieldTerminalPathValue{PhantomTimeSeriesBulkChange_FieldTerminalPath: *fp, value: value.([]*PhantomTimeSerie)}
	case PhantomTimeSeriesBulkChange_FieldPathSelectorStartTime:
		return &PhantomTimeSeriesBulkChange_FieldTerminalPathValue{PhantomTimeSeriesBulkChange_FieldTerminalPath: *fp, value: value.(*timestamp.Timestamp)}
	case PhantomTimeSeriesBulkChange_FieldPathSelectorMsgTime:
		return &PhantomTimeSeriesBulkChange_FieldTerminalPathValue{PhantomTimeSeriesBulkChange_FieldTerminalPath: *fp, value: value.(*timestamp.Timestamp)}
	default:
		panic(fmt.Sprintf("Invalid selector for PhantomTimeSeriesBulkChange: %d", fp.selector))
	}
}

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

func (fp *PhantomTimeSeriesBulkChange_FieldTerminalPath) WithIArrayOfValues(values interface{}) PhantomTimeSeriesBulkChange_FieldPathArrayOfValues {
	fpaov := &PhantomTimeSeriesBulkChange_FieldTerminalPathArrayOfValues{PhantomTimeSeriesBulkChange_FieldTerminalPath: *fp}
	switch fp.selector {
	case PhantomTimeSeriesBulkChange_FieldPathSelectorResync:
		return &PhantomTimeSeriesBulkChange_FieldTerminalPathArrayOfValues{PhantomTimeSeriesBulkChange_FieldTerminalPath: *fp, values: values.([]bool)}
	case PhantomTimeSeriesBulkChange_FieldPathSelectorPartition:
		return &PhantomTimeSeriesBulkChange_FieldTerminalPathArrayOfValues{PhantomTimeSeriesBulkChange_FieldTerminalPath: *fp, values: values.([][]byte)}
	case PhantomTimeSeriesBulkChange_FieldPathSelectorAdded:
		return &PhantomTimeSeriesBulkChange_FieldTerminalPathArrayOfValues{PhantomTimeSeriesBulkChange_FieldTerminalPath: *fp, values: values.([][]*PhantomTimeSerie)}
	case PhantomTimeSeriesBulkChange_FieldPathSelectorRemoved:
		return &PhantomTimeSeriesBulkChange_FieldTerminalPathArrayOfValues{PhantomTimeSeriesBulkChange_FieldTerminalPath: *fp, values: values.([][]*PhantomTimeSerie)}
	case PhantomTimeSeriesBulkChange_FieldPathSelectorStartTime:
		return &PhantomTimeSeriesBulkChange_FieldTerminalPathArrayOfValues{PhantomTimeSeriesBulkChange_FieldTerminalPath: *fp, values: values.([]*timestamp.Timestamp)}
	case PhantomTimeSeriesBulkChange_FieldPathSelectorMsgTime:
		return &PhantomTimeSeriesBulkChange_FieldTerminalPathArrayOfValues{PhantomTimeSeriesBulkChange_FieldTerminalPath: *fp, values: values.([]*timestamp.Timestamp)}
	default:
		panic(fmt.Sprintf("Invalid selector for PhantomTimeSeriesBulkChange: %d", fp.selector))
	}
	return fpaov
}

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

func (fp *PhantomTimeSeriesBulkChange_FieldTerminalPath) WithIArrayItemValue(value interface{}) PhantomTimeSeriesBulkChange_FieldPathArrayItemValue {
	switch fp.selector {
	case PhantomTimeSeriesBulkChange_FieldPathSelectorAdded:
		return &PhantomTimeSeriesBulkChange_FieldTerminalPathArrayItemValue{PhantomTimeSeriesBulkChange_FieldTerminalPath: *fp, value: value.(*PhantomTimeSerie)}
	case PhantomTimeSeriesBulkChange_FieldPathSelectorRemoved:
		return &PhantomTimeSeriesBulkChange_FieldTerminalPathArrayItemValue{PhantomTimeSeriesBulkChange_FieldTerminalPath: *fp, value: value.(*PhantomTimeSerie)}
	default:
		panic(fmt.Sprintf("Invalid selector for PhantomTimeSeriesBulkChange: %d", fp.selector))
	}
}

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

type PhantomTimeSeriesBulkChange_FieldSubPath struct {
	selector PhantomTimeSeriesBulkChange_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ PhantomTimeSeriesBulkChange_FieldPath = (*PhantomTimeSeriesBulkChange_FieldSubPath)(nil)

func (fps *PhantomTimeSeriesBulkChange_FieldSubPath) Selector() PhantomTimeSeriesBulkChange_FieldPathSelector {
	return fps.selector
}
func (fps *PhantomTimeSeriesBulkChange_FieldSubPath) AsAddedSubPath() (PhantomTimeSerie_FieldPath, bool) {
	res, ok := fps.subPath.(PhantomTimeSerie_FieldPath)
	return res, ok
}
func (fps *PhantomTimeSeriesBulkChange_FieldSubPath) AsRemovedSubPath() (PhantomTimeSerie_FieldPath, bool) {
	res, ok := fps.subPath.(PhantomTimeSerie_FieldPath)
	return res, ok
}

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

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

// Get returns all values pointed by selected field from source PhantomTimeSeriesBulkChange
func (fps *PhantomTimeSeriesBulkChange_FieldSubPath) Get(source *PhantomTimeSeriesBulkChange) (values []interface{}) {
	if asPhantomTimeSerieFieldPath, ok := fps.AsAddedSubPath(); ok {
		for _, item := range source.GetAdded() {
			values = append(values, asPhantomTimeSerieFieldPath.Get(item)...)
		}
	} else if asPhantomTimeSerieFieldPath, ok := fps.AsRemovedSubPath(); ok {
		for _, item := range source.GetRemoved() {
			values = append(values, asPhantomTimeSerieFieldPath.Get(item)...)
		}
	} else {
		panic(fmt.Sprintf("Invalid selector for PhantomTimeSeriesBulkChange: %d", fps.selector))
	}
	return
}

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

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

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

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

func (fps *PhantomTimeSeriesBulkChange_FieldSubPath) ClearValue(item *PhantomTimeSeriesBulkChange) {
	if item != nil {
		switch fps.selector {
		case PhantomTimeSeriesBulkChange_FieldPathSelectorAdded:
			for _, subItem := range item.Added {
				fps.subPath.ClearValueRaw(subItem)
			}
		case PhantomTimeSeriesBulkChange_FieldPathSelectorRemoved:
			for _, subItem := range item.Removed {
				fps.subPath.ClearValueRaw(subItem)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for PhantomTimeSeriesBulkChange: %d", fps.selector))
		}
	}
}

func (fps *PhantomTimeSeriesBulkChange_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*PhantomTimeSeriesBulkChange))
}

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

func (fps *PhantomTimeSeriesBulkChange_FieldSubPath) WithIValue(value interface{}) PhantomTimeSeriesBulkChange_FieldPathValue {
	return &PhantomTimeSeriesBulkChange_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *PhantomTimeSeriesBulkChange_FieldSubPath) WithIArrayOfValues(values interface{}) PhantomTimeSeriesBulkChange_FieldPathArrayOfValues {
	return &PhantomTimeSeriesBulkChange_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *PhantomTimeSeriesBulkChange_FieldSubPath) WithIArrayItemValue(value interface{}) PhantomTimeSeriesBulkChange_FieldPathArrayItemValue {
	return &PhantomTimeSeriesBulkChange_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

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

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

func MustParsePhantomTimeSeriesBulkChange_FieldPathValue(pathStr, valueStr string) PhantomTimeSeriesBulkChange_FieldPathValue {
	fpv, err := ParsePhantomTimeSeriesBulkChange_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type PhantomTimeSeriesBulkChange_FieldTerminalPathValue struct {
	PhantomTimeSeriesBulkChange_FieldTerminalPath
	value interface{}
}

var _ PhantomTimeSeriesBulkChange_FieldPathValue = (*PhantomTimeSeriesBulkChange_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'PhantomTimeSeriesBulkChange' as interface{}
func (fpv *PhantomTimeSeriesBulkChange_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *PhantomTimeSeriesBulkChange_FieldTerminalPathValue) AsResyncValue() (bool, bool) {
	res, ok := fpv.value.(bool)
	return res, ok
}
func (fpv *PhantomTimeSeriesBulkChange_FieldTerminalPathValue) AsPartitionValue() ([]byte, bool) {
	res, ok := fpv.value.([]byte)
	return res, ok
}
func (fpv *PhantomTimeSeriesBulkChange_FieldTerminalPathValue) AsAddedValue() ([]*PhantomTimeSerie, bool) {
	res, ok := fpv.value.([]*PhantomTimeSerie)
	return res, ok
}
func (fpv *PhantomTimeSeriesBulkChange_FieldTerminalPathValue) AsRemovedValue() ([]*PhantomTimeSerie, bool) {
	res, ok := fpv.value.([]*PhantomTimeSerie)
	return res, ok
}
func (fpv *PhantomTimeSeriesBulkChange_FieldTerminalPathValue) AsStartTimeValue() (*timestamp.Timestamp, bool) {
	res, ok := fpv.value.(*timestamp.Timestamp)
	return res, ok
}
func (fpv *PhantomTimeSeriesBulkChange_FieldTerminalPathValue) AsMsgTimeValue() (*timestamp.Timestamp, bool) {
	res, ok := fpv.value.(*timestamp.Timestamp)
	return res, ok
}

// SetTo stores value for selected field for object PhantomTimeSeriesBulkChange
func (fpv *PhantomTimeSeriesBulkChange_FieldTerminalPathValue) SetTo(target **PhantomTimeSeriesBulkChange) {
	if *target == nil {
		*target = new(PhantomTimeSeriesBulkChange)
	}
	switch fpv.selector {
	case PhantomTimeSeriesBulkChange_FieldPathSelectorResync:
		(*target).Resync = fpv.value.(bool)
	case PhantomTimeSeriesBulkChange_FieldPathSelectorPartition:
		(*target).Partition = fpv.value.([]byte)
	case PhantomTimeSeriesBulkChange_FieldPathSelectorAdded:
		(*target).Added = fpv.value.([]*PhantomTimeSerie)
	case PhantomTimeSeriesBulkChange_FieldPathSelectorRemoved:
		(*target).Removed = fpv.value.([]*PhantomTimeSerie)
	case PhantomTimeSeriesBulkChange_FieldPathSelectorStartTime:
		(*target).StartTime = fpv.value.(*timestamp.Timestamp)
	case PhantomTimeSeriesBulkChange_FieldPathSelectorMsgTime:
		(*target).MsgTime = fpv.value.(*timestamp.Timestamp)
	default:
		panic(fmt.Sprintf("Invalid selector for PhantomTimeSeriesBulkChange: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'PhantomTimeSeriesBulkChange_FieldTerminalPathValue' with the value under path in 'PhantomTimeSeriesBulkChange'.
func (fpv *PhantomTimeSeriesBulkChange_FieldTerminalPathValue) CompareWith(source *PhantomTimeSeriesBulkChange) (int, bool) {
	switch fpv.selector {
	case PhantomTimeSeriesBulkChange_FieldPathSelectorResync:
		leftValue := fpv.value.(bool)
		rightValue := source.GetResync()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if !(leftValue) && (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case PhantomTimeSeriesBulkChange_FieldPathSelectorPartition:
		return 0, false
	case PhantomTimeSeriesBulkChange_FieldPathSelectorAdded:
		return 0, false
	case PhantomTimeSeriesBulkChange_FieldPathSelectorRemoved:
		return 0, false
	case PhantomTimeSeriesBulkChange_FieldPathSelectorStartTime:
		leftValue := fpv.value.(*timestamp.Timestamp)
		rightValue := source.GetStartTime()
		if leftValue == nil {
			if rightValue != nil {
				return -1, true
			}
			return 0, true
		}
		if rightValue == nil {
			return 1, true
		}
		if leftValue.AsTime().Equal(rightValue.AsTime()) {
			return 0, true
		} else if leftValue.AsTime().Before(rightValue.AsTime()) {
			return -1, true
		} else {
			return 1, true
		}
	case PhantomTimeSeriesBulkChange_FieldPathSelectorMsgTime:
		leftValue := fpv.value.(*timestamp.Timestamp)
		rightValue := source.GetMsgTime()
		if leftValue == nil {
			if rightValue != nil {
				return -1, true
			}
			return 0, true
		}
		if rightValue == nil {
			return 1, true
		}
		if leftValue.AsTime().Equal(rightValue.AsTime()) {
			return 0, true
		} else if leftValue.AsTime().Before(rightValue.AsTime()) {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for PhantomTimeSeriesBulkChange: %d", fpv.selector))
	}
}

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

type PhantomTimeSeriesBulkChange_FieldSubPathValue struct {
	PhantomTimeSeriesBulkChange_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ PhantomTimeSeriesBulkChange_FieldPathValue = (*PhantomTimeSeriesBulkChange_FieldSubPathValue)(nil)

func (fpvs *PhantomTimeSeriesBulkChange_FieldSubPathValue) AsAddedPathValue() (PhantomTimeSerie_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(PhantomTimeSerie_FieldPathValue)
	return res, ok
}
func (fpvs *PhantomTimeSeriesBulkChange_FieldSubPathValue) AsRemovedPathValue() (PhantomTimeSerie_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(PhantomTimeSerie_FieldPathValue)
	return res, ok
}

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

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

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

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

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

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

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

func MustParsePhantomTimeSeriesBulkChange_FieldPathArrayItemValue(pathStr, valueStr string) PhantomTimeSeriesBulkChange_FieldPathArrayItemValue {
	fpaiv, err := ParsePhantomTimeSeriesBulkChange_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type PhantomTimeSeriesBulkChange_FieldTerminalPathArrayItemValue struct {
	PhantomTimeSeriesBulkChange_FieldTerminalPath
	value interface{}
}

var _ PhantomTimeSeriesBulkChange_FieldPathArrayItemValue = (*PhantomTimeSeriesBulkChange_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object PhantomTimeSeriesBulkChange as interface{}
func (fpaiv *PhantomTimeSeriesBulkChange_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}
func (fpaiv *PhantomTimeSeriesBulkChange_FieldTerminalPathArrayItemValue) AsAddedItemValue() (*PhantomTimeSerie, bool) {
	res, ok := fpaiv.value.(*PhantomTimeSerie)
	return res, ok
}
func (fpaiv *PhantomTimeSeriesBulkChange_FieldTerminalPathArrayItemValue) AsRemovedItemValue() (*PhantomTimeSerie, bool) {
	res, ok := fpaiv.value.(*PhantomTimeSerie)
	return res, ok
}

func (fpaiv *PhantomTimeSeriesBulkChange_FieldTerminalPathArrayItemValue) GetSingle(source *PhantomTimeSeriesBulkChange) (interface{}, bool) {
	return nil, false
}

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

// Contains returns a boolean indicating if value that is being held is present in given 'PhantomTimeSeriesBulkChange'
func (fpaiv *PhantomTimeSeriesBulkChange_FieldTerminalPathArrayItemValue) ContainsValue(source *PhantomTimeSeriesBulkChange) bool {
	slice := fpaiv.PhantomTimeSeriesBulkChange_FieldTerminalPath.Get(source)
	for _, v := range slice {
		if reflect.DeepEqual(v, fpaiv.value) {
			return true
		}
	}
	return false
}

type PhantomTimeSeriesBulkChange_FieldSubPathArrayItemValue struct {
	PhantomTimeSeriesBulkChange_FieldPath
	subPathItemValue gotenobject.FieldPathArrayItemValue
}

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

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

// PhantomTimeSeriesBulkChange_FieldPathArrayOfValues allows storing slice of values for PhantomTimeSeriesBulkChange fields according to their type
type PhantomTimeSeriesBulkChange_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	PhantomTimeSeriesBulkChange_FieldPath
}

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

func MustParsePhantomTimeSeriesBulkChange_FieldPathArrayOfValues(pathStr, valuesStr string) PhantomTimeSeriesBulkChange_FieldPathArrayOfValues {
	fpaov, err := ParsePhantomTimeSeriesBulkChange_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type PhantomTimeSeriesBulkChange_FieldTerminalPathArrayOfValues struct {
	PhantomTimeSeriesBulkChange_FieldTerminalPath
	values interface{}
}

var _ PhantomTimeSeriesBulkChange_FieldPathArrayOfValues = (*PhantomTimeSeriesBulkChange_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *PhantomTimeSeriesBulkChange_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case PhantomTimeSeriesBulkChange_FieldPathSelectorResync:
		for _, v := range fpaov.values.([]bool) {
			values = append(values, v)
		}
	case PhantomTimeSeriesBulkChange_FieldPathSelectorPartition:
		for _, v := range fpaov.values.([][]byte) {
			values = append(values, v)
		}
	case PhantomTimeSeriesBulkChange_FieldPathSelectorAdded:
		for _, v := range fpaov.values.([][]*PhantomTimeSerie) {
			values = append(values, v)
		}
	case PhantomTimeSeriesBulkChange_FieldPathSelectorRemoved:
		for _, v := range fpaov.values.([][]*PhantomTimeSerie) {
			values = append(values, v)
		}
	case PhantomTimeSeriesBulkChange_FieldPathSelectorStartTime:
		for _, v := range fpaov.values.([]*timestamp.Timestamp) {
			values = append(values, v)
		}
	case PhantomTimeSeriesBulkChange_FieldPathSelectorMsgTime:
		for _, v := range fpaov.values.([]*timestamp.Timestamp) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *PhantomTimeSeriesBulkChange_FieldTerminalPathArrayOfValues) AsResyncArrayOfValues() ([]bool, bool) {
	res, ok := fpaov.values.([]bool)
	return res, ok
}
func (fpaov *PhantomTimeSeriesBulkChange_FieldTerminalPathArrayOfValues) AsPartitionArrayOfValues() ([][]byte, bool) {
	res, ok := fpaov.values.([][]byte)
	return res, ok
}
func (fpaov *PhantomTimeSeriesBulkChange_FieldTerminalPathArrayOfValues) AsAddedArrayOfValues() ([][]*PhantomTimeSerie, bool) {
	res, ok := fpaov.values.([][]*PhantomTimeSerie)
	return res, ok
}
func (fpaov *PhantomTimeSeriesBulkChange_FieldTerminalPathArrayOfValues) AsRemovedArrayOfValues() ([][]*PhantomTimeSerie, bool) {
	res, ok := fpaov.values.([][]*PhantomTimeSerie)
	return res, ok
}
func (fpaov *PhantomTimeSeriesBulkChange_FieldTerminalPathArrayOfValues) AsStartTimeArrayOfValues() ([]*timestamp.Timestamp, bool) {
	res, ok := fpaov.values.([]*timestamp.Timestamp)
	return res, ok
}
func (fpaov *PhantomTimeSeriesBulkChange_FieldTerminalPathArrayOfValues) AsMsgTimeArrayOfValues() ([]*timestamp.Timestamp, bool) {
	res, ok := fpaov.values.([]*timestamp.Timestamp)
	return res, ok
}

type PhantomTimeSeriesBulkChange_FieldSubPathArrayOfValues struct {
	PhantomTimeSeriesBulkChange_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ PhantomTimeSeriesBulkChange_FieldPathArrayOfValues = (*PhantomTimeSeriesBulkChange_FieldSubPathArrayOfValues)(nil)

func (fpsaov *PhantomTimeSeriesBulkChange_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *PhantomTimeSeriesBulkChange_FieldSubPathArrayOfValues) AsAddedPathArrayOfValues() (PhantomTimeSerie_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(PhantomTimeSerie_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *PhantomTimeSeriesBulkChange_FieldSubPathArrayOfValues) AsRemovedPathArrayOfValues() (PhantomTimeSerie_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(PhantomTimeSerie_FieldPathArrayOfValues)
	return res, ok
}