github.com/cloudwan/edgelq-sdk@v1.15.4/alerting/resources/v1/ts_entry/ts_entry.pb.fieldpath.go

// Code generated by protoc-gen-goten-object
// File: edgelq/alerting/proto/v1/ts_entry.proto
// DO NOT EDIT!!!

package ts_entry

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

	"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"

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

// proto imports
import (
	rcommon "github.com/cloudwan/edgelq-sdk/alerting/resources/v1/common"
	ts_condition "github.com/cloudwan/edgelq-sdk/alerting/resources/v1/ts_condition"
	monitoring_common "github.com/cloudwan/edgelq-sdk/monitoring/resources/v4/common"
	meta "github.com/cloudwan/goten-sdk/types/meta"
	durationpb "google.golang.org/protobuf/types/known/durationpb"
	timestamppb "google.golang.org/protobuf/types/known/timestamppb"
)

// 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

	_ = new(gotenobject.FieldPath)
)

// make sure we're using proto imports
var (
	_ = &rcommon.LogCndSpec{}
	_ = &ts_condition.TsCondition{}
	_ = &monitoring_common.LabelDescriptor{}
	_ = &durationpb.Duration{}
	_ = &timestamppb.Timestamp{}
	_ = &meta.Meta{}
)

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

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

type TsEntry_FieldPathSelector int32

const (
	TsEntry_FieldPathSelectorName     TsEntry_FieldPathSelector = 0
	TsEntry_FieldPathSelectorMetadata TsEntry_FieldPathSelector = 1
	TsEntry_FieldPathSelectorInfo     TsEntry_FieldPathSelector = 2
	TsEntry_FieldPathSelectorState    TsEntry_FieldPathSelector = 3
	TsEntry_FieldPathSelectorInternal TsEntry_FieldPathSelector = 4
)

func (s TsEntry_FieldPathSelector) String() string {
	switch s {
	case TsEntry_FieldPathSelectorName:
		return "name"
	case TsEntry_FieldPathSelectorMetadata:
		return "metadata"
	case TsEntry_FieldPathSelectorInfo:
		return "info"
	case TsEntry_FieldPathSelectorState:
		return "state"
	case TsEntry_FieldPathSelectorInternal:
		return "internal"
	default:
		panic(fmt.Sprintf("Invalid selector for TsEntry: %d", s))
	}
}

func BuildTsEntry_FieldPath(fp gotenobject.RawFieldPath) (TsEntry_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object TsEntry")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "name":
			return &TsEntry_FieldTerminalPath{selector: TsEntry_FieldPathSelectorName}, nil
		case "metadata":
			return &TsEntry_FieldTerminalPath{selector: TsEntry_FieldPathSelectorMetadata}, nil
		case "info":
			return &TsEntry_FieldTerminalPath{selector: TsEntry_FieldPathSelectorInfo}, nil
		case "state":
			return &TsEntry_FieldTerminalPath{selector: TsEntry_FieldPathSelectorState}, nil
		case "internal":
			return &TsEntry_FieldTerminalPath{selector: TsEntry_FieldPathSelectorInternal}, nil
		}
	} else {
		switch fp[0] {
		case "metadata":
			if subpath, err := meta.BuildMeta_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &TsEntry_FieldSubPath{selector: TsEntry_FieldPathSelectorMetadata, subPath: subpath}, nil
			}
		case "info":
			if subpath, err := BuildTsEntryInfo_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &TsEntry_FieldSubPath{selector: TsEntry_FieldPathSelectorInfo, subPath: subpath}, nil
			}
		case "state":
			if subpath, err := BuildTsEntryState_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &TsEntry_FieldSubPath{selector: TsEntry_FieldPathSelectorState, subPath: subpath}, nil
			}
		case "internal":
			if subpath, err := BuildTsEntryInternal_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &TsEntry_FieldSubPath{selector: TsEntry_FieldPathSelectorInternal, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object TsEntry", fp)
}

func ParseTsEntry_FieldPath(rawField string) (TsEntry_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildTsEntry_FieldPath(fp)
}

func MustParseTsEntry_FieldPath(rawField string) TsEntry_FieldPath {
	fp, err := ParseTsEntry_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type TsEntry_FieldTerminalPath struct {
	selector TsEntry_FieldPathSelector
}

var _ TsEntry_FieldPath = (*TsEntry_FieldTerminalPath)(nil)

func (fp *TsEntry_FieldTerminalPath) Selector() TsEntry_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source TsEntry
func (fp *TsEntry_FieldTerminalPath) Get(source *TsEntry) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case TsEntry_FieldPathSelectorName:
			if source.Name != nil {
				values = append(values, source.Name)
			}
		case TsEntry_FieldPathSelectorMetadata:
			if source.Metadata != nil {
				values = append(values, source.Metadata)
			}
		case TsEntry_FieldPathSelectorInfo:
			if source.Info != nil {
				values = append(values, source.Info)
			}
		case TsEntry_FieldPathSelectorState:
			if source.State != nil {
				values = append(values, source.State)
			}
		case TsEntry_FieldPathSelectorInternal:
			if source.Internal != nil {
				values = append(values, source.Internal)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for TsEntry: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source TsEntry
func (fp *TsEntry_FieldTerminalPath) GetSingle(source *TsEntry) (interface{}, bool) {
	switch fp.selector {
	case TsEntry_FieldPathSelectorName:
		res := source.GetName()
		return res, res != nil
	case TsEntry_FieldPathSelectorMetadata:
		res := source.GetMetadata()
		return res, res != nil
	case TsEntry_FieldPathSelectorInfo:
		res := source.GetInfo()
		return res, res != nil
	case TsEntry_FieldPathSelectorState:
		res := source.GetState()
		return res, res != nil
	case TsEntry_FieldPathSelectorInternal:
		res := source.GetInternal()
		return res, res != nil
	default:
		panic(fmt.Sprintf("Invalid selector for TsEntry: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *TsEntry_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case TsEntry_FieldPathSelectorName:
		return (*Name)(nil)
	case TsEntry_FieldPathSelectorMetadata:
		return (*meta.Meta)(nil)
	case TsEntry_FieldPathSelectorInfo:
		return (*TsEntry_Info)(nil)
	case TsEntry_FieldPathSelectorState:
		return (*TsEntry_State)(nil)
	case TsEntry_FieldPathSelectorInternal:
		return (*TsEntry_Internal)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for TsEntry: %d", fp.selector))
	}
}

func (fp *TsEntry_FieldTerminalPath) ClearValue(item *TsEntry) {
	if item != nil {
		switch fp.selector {
		case TsEntry_FieldPathSelectorName:
			item.Name = nil
		case TsEntry_FieldPathSelectorMetadata:
			item.Metadata = nil
		case TsEntry_FieldPathSelectorInfo:
			item.Info = nil
		case TsEntry_FieldPathSelectorState:
			item.State = nil
		case TsEntry_FieldPathSelectorInternal:
			item.Internal = nil
		default:
			panic(fmt.Sprintf("Invalid selector for TsEntry: %d", fp.selector))
		}
	}
}

func (fp *TsEntry_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*TsEntry))
}

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

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

func (fp *TsEntry_FieldTerminalPath) WithIValue(value interface{}) TsEntry_FieldPathValue {
	switch fp.selector {
	case TsEntry_FieldPathSelectorName:
		return &TsEntry_FieldTerminalPathValue{TsEntry_FieldTerminalPath: *fp, value: value.(*Name)}
	case TsEntry_FieldPathSelectorMetadata:
		return &TsEntry_FieldTerminalPathValue{TsEntry_FieldTerminalPath: *fp, value: value.(*meta.Meta)}
	case TsEntry_FieldPathSelectorInfo:
		return &TsEntry_FieldTerminalPathValue{TsEntry_FieldTerminalPath: *fp, value: value.(*TsEntry_Info)}
	case TsEntry_FieldPathSelectorState:
		return &TsEntry_FieldTerminalPathValue{TsEntry_FieldTerminalPath: *fp, value: value.(*TsEntry_State)}
	case TsEntry_FieldPathSelectorInternal:
		return &TsEntry_FieldTerminalPathValue{TsEntry_FieldTerminalPath: *fp, value: value.(*TsEntry_Internal)}
	default:
		panic(fmt.Sprintf("Invalid selector for TsEntry: %d", fp.selector))
	}
}

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

func (fp *TsEntry_FieldTerminalPath) WithIArrayOfValues(values interface{}) TsEntry_FieldPathArrayOfValues {
	fpaov := &TsEntry_FieldTerminalPathArrayOfValues{TsEntry_FieldTerminalPath: *fp}
	switch fp.selector {
	case TsEntry_FieldPathSelectorName:
		return &TsEntry_FieldTerminalPathArrayOfValues{TsEntry_FieldTerminalPath: *fp, values: values.([]*Name)}
	case TsEntry_FieldPathSelectorMetadata:
		return &TsEntry_FieldTerminalPathArrayOfValues{TsEntry_FieldTerminalPath: *fp, values: values.([]*meta.Meta)}
	case TsEntry_FieldPathSelectorInfo:
		return &TsEntry_FieldTerminalPathArrayOfValues{TsEntry_FieldTerminalPath: *fp, values: values.([]*TsEntry_Info)}
	case TsEntry_FieldPathSelectorState:
		return &TsEntry_FieldTerminalPathArrayOfValues{TsEntry_FieldTerminalPath: *fp, values: values.([]*TsEntry_State)}
	case TsEntry_FieldPathSelectorInternal:
		return &TsEntry_FieldTerminalPathArrayOfValues{TsEntry_FieldTerminalPath: *fp, values: values.([]*TsEntry_Internal)}
	default:
		panic(fmt.Sprintf("Invalid selector for TsEntry: %d", fp.selector))
	}
	return fpaov
}

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

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

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

type TsEntry_FieldSubPath struct {
	selector TsEntry_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ TsEntry_FieldPath = (*TsEntry_FieldSubPath)(nil)

func (fps *TsEntry_FieldSubPath) Selector() TsEntry_FieldPathSelector {
	return fps.selector
}
func (fps *TsEntry_FieldSubPath) AsMetadataSubPath() (meta.Meta_FieldPath, bool) {
	res, ok := fps.subPath.(meta.Meta_FieldPath)
	return res, ok
}
func (fps *TsEntry_FieldSubPath) AsInfoSubPath() (TsEntryInfo_FieldPath, bool) {
	res, ok := fps.subPath.(TsEntryInfo_FieldPath)
	return res, ok
}
func (fps *TsEntry_FieldSubPath) AsStateSubPath() (TsEntryState_FieldPath, bool) {
	res, ok := fps.subPath.(TsEntryState_FieldPath)
	return res, ok
}
func (fps *TsEntry_FieldSubPath) AsInternalSubPath() (TsEntryInternal_FieldPath, bool) {
	res, ok := fps.subPath.(TsEntryInternal_FieldPath)
	return res, ok
}

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

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

// Get returns all values pointed by selected field from source TsEntry
func (fps *TsEntry_FieldSubPath) Get(source *TsEntry) (values []interface{}) {
	switch fps.selector {
	case TsEntry_FieldPathSelectorMetadata:
		values = append(values, fps.subPath.GetRaw(source.GetMetadata())...)
	case TsEntry_FieldPathSelectorInfo:
		values = append(values, fps.subPath.GetRaw(source.GetInfo())...)
	case TsEntry_FieldPathSelectorState:
		values = append(values, fps.subPath.GetRaw(source.GetState())...)
	case TsEntry_FieldPathSelectorInternal:
		values = append(values, fps.subPath.GetRaw(source.GetInternal())...)
	default:
		panic(fmt.Sprintf("Invalid selector for TsEntry: %d", fps.selector))
	}
	return
}

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

// GetSingle returns value of selected field from source TsEntry
func (fps *TsEntry_FieldSubPath) GetSingle(source *TsEntry) (interface{}, bool) {
	switch fps.selector {
	case TsEntry_FieldPathSelectorMetadata:
		if source.GetMetadata() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetMetadata())
	case TsEntry_FieldPathSelectorInfo:
		if source.GetInfo() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetInfo())
	case TsEntry_FieldPathSelectorState:
		if source.GetState() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetState())
	case TsEntry_FieldPathSelectorInternal:
		if source.GetInternal() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetInternal())
	default:
		panic(fmt.Sprintf("Invalid selector for TsEntry: %d", fps.selector))
	}
}

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

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

func (fps *TsEntry_FieldSubPath) ClearValue(item *TsEntry) {
	if item != nil {
		switch fps.selector {
		case TsEntry_FieldPathSelectorMetadata:
			fps.subPath.ClearValueRaw(item.Metadata)
		case TsEntry_FieldPathSelectorInfo:
			fps.subPath.ClearValueRaw(item.Info)
		case TsEntry_FieldPathSelectorState:
			fps.subPath.ClearValueRaw(item.State)
		case TsEntry_FieldPathSelectorInternal:
			fps.subPath.ClearValueRaw(item.Internal)
		default:
			panic(fmt.Sprintf("Invalid selector for TsEntry: %d", fps.selector))
		}
	}
}

func (fps *TsEntry_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*TsEntry))
}

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

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

func (fps *TsEntry_FieldSubPath) WithIValue(value interface{}) TsEntry_FieldPathValue {
	return &TsEntry_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *TsEntry_FieldSubPath) WithIArrayOfValues(values interface{}) TsEntry_FieldPathArrayOfValues {
	return &TsEntry_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *TsEntry_FieldSubPath) WithIArrayItemValue(value interface{}) TsEntry_FieldPathArrayItemValue {
	return &TsEntry_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

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

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

func MustParseTsEntry_FieldPathValue(pathStr, valueStr string) TsEntry_FieldPathValue {
	fpv, err := ParseTsEntry_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type TsEntry_FieldTerminalPathValue struct {
	TsEntry_FieldTerminalPath
	value interface{}
}

var _ TsEntry_FieldPathValue = (*TsEntry_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'TsEntry' as interface{}
func (fpv *TsEntry_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *TsEntry_FieldTerminalPathValue) AsNameValue() (*Name, bool) {
	res, ok := fpv.value.(*Name)
	return res, ok
}
func (fpv *TsEntry_FieldTerminalPathValue) AsMetadataValue() (*meta.Meta, bool) {
	res, ok := fpv.value.(*meta.Meta)
	return res, ok
}
func (fpv *TsEntry_FieldTerminalPathValue) AsInfoValue() (*TsEntry_Info, bool) {
	res, ok := fpv.value.(*TsEntry_Info)
	return res, ok
}
func (fpv *TsEntry_FieldTerminalPathValue) AsStateValue() (*TsEntry_State, bool) {
	res, ok := fpv.value.(*TsEntry_State)
	return res, ok
}
func (fpv *TsEntry_FieldTerminalPathValue) AsInternalValue() (*TsEntry_Internal, bool) {
	res, ok := fpv.value.(*TsEntry_Internal)
	return res, ok
}

// SetTo stores value for selected field for object TsEntry
func (fpv *TsEntry_FieldTerminalPathValue) SetTo(target **TsEntry) {
	if *target == nil {
		*target = new(TsEntry)
	}
	switch fpv.selector {
	case TsEntry_FieldPathSelectorName:
		(*target).Name = fpv.value.(*Name)
	case TsEntry_FieldPathSelectorMetadata:
		(*target).Metadata = fpv.value.(*meta.Meta)
	case TsEntry_FieldPathSelectorInfo:
		(*target).Info = fpv.value.(*TsEntry_Info)
	case TsEntry_FieldPathSelectorState:
		(*target).State = fpv.value.(*TsEntry_State)
	case TsEntry_FieldPathSelectorInternal:
		(*target).Internal = fpv.value.(*TsEntry_Internal)
	default:
		panic(fmt.Sprintf("Invalid selector for TsEntry: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'TsEntry_FieldTerminalPathValue' with the value under path in 'TsEntry'.
func (fpv *TsEntry_FieldTerminalPathValue) CompareWith(source *TsEntry) (int, bool) {
	switch fpv.selector {
	case TsEntry_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 TsEntry_FieldPathSelectorMetadata:
		return 0, false
	case TsEntry_FieldPathSelectorInfo:
		return 0, false
	case TsEntry_FieldPathSelectorState:
		return 0, false
	case TsEntry_FieldPathSelectorInternal:
		return 0, false
	default:
		panic(fmt.Sprintf("Invalid selector for TsEntry: %d", fpv.selector))
	}
}

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

type TsEntry_FieldSubPathValue struct {
	TsEntry_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ TsEntry_FieldPathValue = (*TsEntry_FieldSubPathValue)(nil)

func (fpvs *TsEntry_FieldSubPathValue) AsMetadataPathValue() (meta.Meta_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(meta.Meta_FieldPathValue)
	return res, ok
}
func (fpvs *TsEntry_FieldSubPathValue) AsInfoPathValue() (TsEntryInfo_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(TsEntryInfo_FieldPathValue)
	return res, ok
}
func (fpvs *TsEntry_FieldSubPathValue) AsStatePathValue() (TsEntryState_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(TsEntryState_FieldPathValue)
	return res, ok
}
func (fpvs *TsEntry_FieldSubPathValue) AsInternalPathValue() (TsEntryInternal_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(TsEntryInternal_FieldPathValue)
	return res, ok
}

func (fpvs *TsEntry_FieldSubPathValue) SetTo(target **TsEntry) {
	if *target == nil {
		*target = new(TsEntry)
	}
	switch fpvs.Selector() {
	case TsEntry_FieldPathSelectorMetadata:
		fpvs.subPathValue.(meta.Meta_FieldPathValue).SetTo(&(*target).Metadata)
	case TsEntry_FieldPathSelectorInfo:
		fpvs.subPathValue.(TsEntryInfo_FieldPathValue).SetTo(&(*target).Info)
	case TsEntry_FieldPathSelectorState:
		fpvs.subPathValue.(TsEntryState_FieldPathValue).SetTo(&(*target).State)
	case TsEntry_FieldPathSelectorInternal:
		fpvs.subPathValue.(TsEntryInternal_FieldPathValue).SetTo(&(*target).Internal)
	default:
		panic(fmt.Sprintf("Invalid selector for TsEntry: %d", fpvs.Selector()))
	}
}

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

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

func (fpvs *TsEntry_FieldSubPathValue) CompareWith(source *TsEntry) (int, bool) {
	switch fpvs.Selector() {
	case TsEntry_FieldPathSelectorMetadata:
		return fpvs.subPathValue.(meta.Meta_FieldPathValue).CompareWith(source.GetMetadata())
	case TsEntry_FieldPathSelectorInfo:
		return fpvs.subPathValue.(TsEntryInfo_FieldPathValue).CompareWith(source.GetInfo())
	case TsEntry_FieldPathSelectorState:
		return fpvs.subPathValue.(TsEntryState_FieldPathValue).CompareWith(source.GetState())
	case TsEntry_FieldPathSelectorInternal:
		return fpvs.subPathValue.(TsEntryInternal_FieldPathValue).CompareWith(source.GetInternal())
	default:
		panic(fmt.Sprintf("Invalid selector for TsEntry: %d", fpvs.Selector()))
	}
}

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

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

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

func MustParseTsEntry_FieldPathArrayItemValue(pathStr, valueStr string) TsEntry_FieldPathArrayItemValue {
	fpaiv, err := ParseTsEntry_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type TsEntry_FieldTerminalPathArrayItemValue struct {
	TsEntry_FieldTerminalPath
	value interface{}
}

var _ TsEntry_FieldPathArrayItemValue = (*TsEntry_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *TsEntry_FieldTerminalPathArrayItemValue) GetSingle(source *TsEntry) (interface{}, bool) {
	return nil, false
}

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

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

// GetRawValue returns stored array item value
func (fpaivs *TsEntry_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *TsEntry_FieldSubPathArrayItemValue) AsMetadataPathItemValue() (meta.Meta_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(meta.Meta_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *TsEntry_FieldSubPathArrayItemValue) AsInfoPathItemValue() (TsEntryInfo_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(TsEntryInfo_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *TsEntry_FieldSubPathArrayItemValue) AsStatePathItemValue() (TsEntryState_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(TsEntryState_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *TsEntry_FieldSubPathArrayItemValue) AsInternalPathItemValue() (TsEntryInternal_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(TsEntryInternal_FieldPathArrayItemValue)
	return res, ok
}

// Contains returns a boolean indicating if value that is being held is present in given 'TsEntry'
func (fpaivs *TsEntry_FieldSubPathArrayItemValue) ContainsValue(source *TsEntry) bool {
	switch fpaivs.Selector() {
	case TsEntry_FieldPathSelectorMetadata:
		return fpaivs.subPathItemValue.(meta.Meta_FieldPathArrayItemValue).ContainsValue(source.GetMetadata())
	case TsEntry_FieldPathSelectorInfo:
		return fpaivs.subPathItemValue.(TsEntryInfo_FieldPathArrayItemValue).ContainsValue(source.GetInfo())
	case TsEntry_FieldPathSelectorState:
		return fpaivs.subPathItemValue.(TsEntryState_FieldPathArrayItemValue).ContainsValue(source.GetState())
	case TsEntry_FieldPathSelectorInternal:
		return fpaivs.subPathItemValue.(TsEntryInternal_FieldPathArrayItemValue).ContainsValue(source.GetInternal())
	default:
		panic(fmt.Sprintf("Invalid selector for TsEntry: %d", fpaivs.Selector()))
	}
}

// TsEntry_FieldPathArrayOfValues allows storing slice of values for TsEntry fields according to their type
type TsEntry_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	TsEntry_FieldPath
}

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

func MustParseTsEntry_FieldPathArrayOfValues(pathStr, valuesStr string) TsEntry_FieldPathArrayOfValues {
	fpaov, err := ParseTsEntry_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type TsEntry_FieldTerminalPathArrayOfValues struct {
	TsEntry_FieldTerminalPath
	values interface{}
}

var _ TsEntry_FieldPathArrayOfValues = (*TsEntry_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *TsEntry_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case TsEntry_FieldPathSelectorName:
		for _, v := range fpaov.values.([]*Name) {
			values = append(values, v)
		}
	case TsEntry_FieldPathSelectorMetadata:
		for _, v := range fpaov.values.([]*meta.Meta) {
			values = append(values, v)
		}
	case TsEntry_FieldPathSelectorInfo:
		for _, v := range fpaov.values.([]*TsEntry_Info) {
			values = append(values, v)
		}
	case TsEntry_FieldPathSelectorState:
		for _, v := range fpaov.values.([]*TsEntry_State) {
			values = append(values, v)
		}
	case TsEntry_FieldPathSelectorInternal:
		for _, v := range fpaov.values.([]*TsEntry_Internal) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *TsEntry_FieldTerminalPathArrayOfValues) AsNameArrayOfValues() ([]*Name, bool) {
	res, ok := fpaov.values.([]*Name)
	return res, ok
}
func (fpaov *TsEntry_FieldTerminalPathArrayOfValues) AsMetadataArrayOfValues() ([]*meta.Meta, bool) {
	res, ok := fpaov.values.([]*meta.Meta)
	return res, ok
}
func (fpaov *TsEntry_FieldTerminalPathArrayOfValues) AsInfoArrayOfValues() ([]*TsEntry_Info, bool) {
	res, ok := fpaov.values.([]*TsEntry_Info)
	return res, ok
}
func (fpaov *TsEntry_FieldTerminalPathArrayOfValues) AsStateArrayOfValues() ([]*TsEntry_State, bool) {
	res, ok := fpaov.values.([]*TsEntry_State)
	return res, ok
}
func (fpaov *TsEntry_FieldTerminalPathArrayOfValues) AsInternalArrayOfValues() ([]*TsEntry_Internal, bool) {
	res, ok := fpaov.values.([]*TsEntry_Internal)
	return res, ok
}

type TsEntry_FieldSubPathArrayOfValues struct {
	TsEntry_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ TsEntry_FieldPathArrayOfValues = (*TsEntry_FieldSubPathArrayOfValues)(nil)

func (fpsaov *TsEntry_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *TsEntry_FieldSubPathArrayOfValues) AsMetadataPathArrayOfValues() (meta.Meta_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(meta.Meta_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *TsEntry_FieldSubPathArrayOfValues) AsInfoPathArrayOfValues() (TsEntryInfo_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(TsEntryInfo_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *TsEntry_FieldSubPathArrayOfValues) AsStatePathArrayOfValues() (TsEntryState_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(TsEntryState_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *TsEntry_FieldSubPathArrayOfValues) AsInternalPathArrayOfValues() (TsEntryInternal_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(TsEntryInternal_FieldPathArrayOfValues)
	return res, ok
}

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

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

type TsEntryInfo_FieldPathSelector int32

const (
	TsEntryInfo_FieldPathSelectorAlertingResource     TsEntryInfo_FieldPathSelector = 0
	TsEntryInfo_FieldPathSelectorGroupByKey           TsEntryInfo_FieldPathSelector = 1
	TsEntryInfo_FieldPathSelectorCommonMetricLabels   TsEntryInfo_FieldPathSelector = 2
	TsEntryInfo_FieldPathSelectorCommonResourceLabels TsEntryInfo_FieldPathSelector = 3
)

func (s TsEntryInfo_FieldPathSelector) String() string {
	switch s {
	case TsEntryInfo_FieldPathSelectorAlertingResource:
		return "alerting_resource"
	case TsEntryInfo_FieldPathSelectorGroupByKey:
		return "group_by_key"
	case TsEntryInfo_FieldPathSelectorCommonMetricLabels:
		return "common_metric_labels"
	case TsEntryInfo_FieldPathSelectorCommonResourceLabels:
		return "common_resource_labels"
	default:
		panic(fmt.Sprintf("Invalid selector for TsEntry_Info: %d", s))
	}
}

func BuildTsEntryInfo_FieldPath(fp gotenobject.RawFieldPath) (TsEntryInfo_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object TsEntry_Info")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "alerting_resource", "alertingResource", "alerting-resource":
			return &TsEntryInfo_FieldTerminalPath{selector: TsEntryInfo_FieldPathSelectorAlertingResource}, nil
		case "group_by_key", "groupByKey", "group-by-key":
			return &TsEntryInfo_FieldTerminalPath{selector: TsEntryInfo_FieldPathSelectorGroupByKey}, nil
		case "common_metric_labels", "commonMetricLabels", "common-metric-labels":
			return &TsEntryInfo_FieldTerminalPath{selector: TsEntryInfo_FieldPathSelectorCommonMetricLabels}, nil
		case "common_resource_labels", "commonResourceLabels", "common-resource-labels":
			return &TsEntryInfo_FieldTerminalPath{selector: TsEntryInfo_FieldPathSelectorCommonResourceLabels}, nil
		}
	} else {
		switch fp[0] {
		case "alerting_resource", "alertingResource", "alerting-resource":
			if subpath, err := meta.BuildOwnerReference_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &TsEntryInfo_FieldSubPath{selector: TsEntryInfo_FieldPathSelectorAlertingResource, subPath: subpath}, nil
			}
		case "common_metric_labels", "commonMetricLabels", "common-metric-labels":
			if len(fp) > 2 {
				return nil, status.Errorf(codes.InvalidArgument, "sub path for maps ('%s') are not supported (object TsEntry_Info)", fp)
			}
			return &TsEntryInfo_FieldPathMap{selector: TsEntryInfo_FieldPathSelectorCommonMetricLabels, key: fp[1]}, nil
		case "common_resource_labels", "commonResourceLabels", "common-resource-labels":
			if len(fp) > 2 {
				return nil, status.Errorf(codes.InvalidArgument, "sub path for maps ('%s') are not supported (object TsEntry_Info)", fp)
			}
			return &TsEntryInfo_FieldPathMap{selector: TsEntryInfo_FieldPathSelectorCommonResourceLabels, key: fp[1]}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object TsEntry_Info", fp)
}

func ParseTsEntryInfo_FieldPath(rawField string) (TsEntryInfo_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildTsEntryInfo_FieldPath(fp)
}

func MustParseTsEntryInfo_FieldPath(rawField string) TsEntryInfo_FieldPath {
	fp, err := ParseTsEntryInfo_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type TsEntryInfo_FieldTerminalPath struct {
	selector TsEntryInfo_FieldPathSelector
}

var _ TsEntryInfo_FieldPath = (*TsEntryInfo_FieldTerminalPath)(nil)

func (fp *TsEntryInfo_FieldTerminalPath) Selector() TsEntryInfo_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source TsEntry_Info
func (fp *TsEntryInfo_FieldTerminalPath) Get(source *TsEntry_Info) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case TsEntryInfo_FieldPathSelectorAlertingResource:
			if source.AlertingResource != nil {
				values = append(values, source.AlertingResource)
			}
		case TsEntryInfo_FieldPathSelectorGroupByKey:
			values = append(values, source.GroupByKey)
		case TsEntryInfo_FieldPathSelectorCommonMetricLabels:
			values = append(values, source.CommonMetricLabels)
		case TsEntryInfo_FieldPathSelectorCommonResourceLabels:
			values = append(values, source.CommonResourceLabels)
		default:
			panic(fmt.Sprintf("Invalid selector for TsEntry_Info: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source TsEntry_Info
func (fp *TsEntryInfo_FieldTerminalPath) GetSingle(source *TsEntry_Info) (interface{}, bool) {
	switch fp.selector {
	case TsEntryInfo_FieldPathSelectorAlertingResource:
		res := source.GetAlertingResource()
		return res, res != nil
	case TsEntryInfo_FieldPathSelectorGroupByKey:
		res := source.GetGroupByKey()
		return res, res != nil
	case TsEntryInfo_FieldPathSelectorCommonMetricLabels:
		res := source.GetCommonMetricLabels()
		return res, res != nil
	case TsEntryInfo_FieldPathSelectorCommonResourceLabels:
		res := source.GetCommonResourceLabels()
		return res, res != nil
	default:
		panic(fmt.Sprintf("Invalid selector for TsEntry_Info: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *TsEntryInfo_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case TsEntryInfo_FieldPathSelectorAlertingResource:
		return (*meta.OwnerReference)(nil)
	case TsEntryInfo_FieldPathSelectorGroupByKey:
		return ([]byte)(nil)
	case TsEntryInfo_FieldPathSelectorCommonMetricLabels:
		return (map[string]string)(nil)
	case TsEntryInfo_FieldPathSelectorCommonResourceLabels:
		return (map[string]string)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for TsEntry_Info: %d", fp.selector))
	}
}

func (fp *TsEntryInfo_FieldTerminalPath) ClearValue(item *TsEntry_Info) {
	if item != nil {
		switch fp.selector {
		case TsEntryInfo_FieldPathSelectorAlertingResource:
			item.AlertingResource = nil
		case TsEntryInfo_FieldPathSelectorGroupByKey:
			item.GroupByKey = nil
		case TsEntryInfo_FieldPathSelectorCommonMetricLabels:
			item.CommonMetricLabels = nil
		case TsEntryInfo_FieldPathSelectorCommonResourceLabels:
			item.CommonResourceLabels = nil
		default:
			panic(fmt.Sprintf("Invalid selector for TsEntry_Info: %d", fp.selector))
		}
	}
}

func (fp *TsEntryInfo_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*TsEntry_Info))
}

// IsLeaf - whether field path is holds simple value
func (fp *TsEntryInfo_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == TsEntryInfo_FieldPathSelectorGroupByKey ||
		fp.selector == TsEntryInfo_FieldPathSelectorCommonMetricLabels ||
		fp.selector == TsEntryInfo_FieldPathSelectorCommonResourceLabels
}

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

func (fp *TsEntryInfo_FieldTerminalPath) WithIValue(value interface{}) TsEntryInfo_FieldPathValue {
	switch fp.selector {
	case TsEntryInfo_FieldPathSelectorAlertingResource:
		return &TsEntryInfo_FieldTerminalPathValue{TsEntryInfo_FieldTerminalPath: *fp, value: value.(*meta.OwnerReference)}
	case TsEntryInfo_FieldPathSelectorGroupByKey:
		return &TsEntryInfo_FieldTerminalPathValue{TsEntryInfo_FieldTerminalPath: *fp, value: value.([]byte)}
	case TsEntryInfo_FieldPathSelectorCommonMetricLabels:
		return &TsEntryInfo_FieldTerminalPathValue{TsEntryInfo_FieldTerminalPath: *fp, value: value.(map[string]string)}
	case TsEntryInfo_FieldPathSelectorCommonResourceLabels:
		return &TsEntryInfo_FieldTerminalPathValue{TsEntryInfo_FieldTerminalPath: *fp, value: value.(map[string]string)}
	default:
		panic(fmt.Sprintf("Invalid selector for TsEntry_Info: %d", fp.selector))
	}
}

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

func (fp *TsEntryInfo_FieldTerminalPath) WithIArrayOfValues(values interface{}) TsEntryInfo_FieldPathArrayOfValues {
	fpaov := &TsEntryInfo_FieldTerminalPathArrayOfValues{TsEntryInfo_FieldTerminalPath: *fp}
	switch fp.selector {
	case TsEntryInfo_FieldPathSelectorAlertingResource:
		return &TsEntryInfo_FieldTerminalPathArrayOfValues{TsEntryInfo_FieldTerminalPath: *fp, values: values.([]*meta.OwnerReference)}
	case TsEntryInfo_FieldPathSelectorGroupByKey:
		return &TsEntryInfo_FieldTerminalPathArrayOfValues{TsEntryInfo_FieldTerminalPath: *fp, values: values.([][]byte)}
	case TsEntryInfo_FieldPathSelectorCommonMetricLabels:
		return &TsEntryInfo_FieldTerminalPathArrayOfValues{TsEntryInfo_FieldTerminalPath: *fp, values: values.([]map[string]string)}
	case TsEntryInfo_FieldPathSelectorCommonResourceLabels:
		return &TsEntryInfo_FieldTerminalPathArrayOfValues{TsEntryInfo_FieldTerminalPath: *fp, values: values.([]map[string]string)}
	default:
		panic(fmt.Sprintf("Invalid selector for TsEntry_Info: %d", fp.selector))
	}
	return fpaov
}

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

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

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

// FieldPath for map type with additional Key information
type TsEntryInfo_FieldPathMap struct {
	key      string
	selector TsEntryInfo_FieldPathSelector
}

var _ TsEntryInfo_FieldPath = (*TsEntryInfo_FieldPathMap)(nil)

func (fpm *TsEntryInfo_FieldPathMap) Selector() TsEntryInfo_FieldPathSelector {
	return fpm.selector
}

func (fpm *TsEntryInfo_FieldPathMap) Key() string {
	return fpm.key
}

// String returns path representation in proto convention
func (fpm *TsEntryInfo_FieldPathMap) String() string {
	return fpm.selector.String() + "." + fpm.key
}

// JSONString returns path representation is JSON convention. Note that map keys are not transformed
func (fpm *TsEntryInfo_FieldPathMap) JSONString() string {
	return strcase.ToLowerCamel(fpm.selector.String()) + "." + fpm.key
}

// Get returns all values pointed by selected field map key from source TsEntry_Info
func (fpm *TsEntryInfo_FieldPathMap) Get(source *TsEntry_Info) (values []interface{}) {
	switch fpm.selector {
	case TsEntryInfo_FieldPathSelectorCommonMetricLabels:
		if value, ok := source.GetCommonMetricLabels()[fpm.key]; ok {
			values = append(values, value)
		}
	case TsEntryInfo_FieldPathSelectorCommonResourceLabels:
		if value, ok := source.GetCommonResourceLabels()[fpm.key]; ok {
			values = append(values, value)
		}
	default:
		panic(fmt.Sprintf("Invalid selector for TsEntry_Info: %d", fpm.selector))
	}
	return
}

func (fpm *TsEntryInfo_FieldPathMap) GetRaw(source proto.Message) []interface{} {
	return fpm.Get(source.(*TsEntry_Info))
}

// GetSingle returns value by selected field map key from source TsEntry_Info
func (fpm *TsEntryInfo_FieldPathMap) GetSingle(source *TsEntry_Info) (interface{}, bool) {
	switch fpm.selector {
	case TsEntryInfo_FieldPathSelectorCommonMetricLabels:
		res, ok := source.GetCommonMetricLabels()[fpm.key]
		return res, ok
	case TsEntryInfo_FieldPathSelectorCommonResourceLabels:
		res, ok := source.GetCommonResourceLabels()[fpm.key]
		return res, ok
	default:
		panic(fmt.Sprintf("Invalid selector for TsEntry_Info: %d", fpm.selector))
	}
}

func (fpm *TsEntryInfo_FieldPathMap) GetSingleRaw(source proto.Message) (interface{}, bool) {
	return fpm.GetSingle(source.(*TsEntry_Info))
}

// GetDefault returns a default value of the field type
func (fpm *TsEntryInfo_FieldPathMap) GetDefault() interface{} {
	switch fpm.selector {
	case TsEntryInfo_FieldPathSelectorCommonMetricLabels:
		var v string
		return v
	case TsEntryInfo_FieldPathSelectorCommonResourceLabels:
		var v string
		return v
	default:
		panic(fmt.Sprintf("Invalid selector for TsEntry_Info: %d", fpm.selector))
	}
}

func (fpm *TsEntryInfo_FieldPathMap) ClearValue(item *TsEntry_Info) {
	if item != nil {
		switch fpm.selector {
		case TsEntryInfo_FieldPathSelectorCommonMetricLabels:
			delete(item.CommonMetricLabels, fpm.key)
		case TsEntryInfo_FieldPathSelectorCommonResourceLabels:
			delete(item.CommonResourceLabels, fpm.key)
		default:
			panic(fmt.Sprintf("Invalid selector for TsEntry_Info: %d", fpm.selector))
		}
	}
}

func (fpm *TsEntryInfo_FieldPathMap) ClearValueRaw(item proto.Message) {
	fpm.ClearValue(item.(*TsEntry_Info))
}

// IsLeaf - whether field path is holds simple value
func (fpm *TsEntryInfo_FieldPathMap) IsLeaf() bool {
	switch fpm.selector {
	case TsEntryInfo_FieldPathSelectorCommonMetricLabels:
		return true
	case TsEntryInfo_FieldPathSelectorCommonResourceLabels:
		return true
	default:
		panic(fmt.Sprintf("Invalid selector for TsEntry_Info: %d", fpm.selector))
	}
}

func (fpm *TsEntryInfo_FieldPathMap) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
	return []gotenobject.FieldPath{fpm}
}

func (fpm *TsEntryInfo_FieldPathMap) WithIValue(value interface{}) TsEntryInfo_FieldPathValue {
	switch fpm.selector {
	case TsEntryInfo_FieldPathSelectorCommonMetricLabels:
		return &TsEntryInfo_FieldPathMapValue{TsEntryInfo_FieldPathMap: *fpm, value: value.(string)}
	case TsEntryInfo_FieldPathSelectorCommonResourceLabels:
		return &TsEntryInfo_FieldPathMapValue{TsEntryInfo_FieldPathMap: *fpm, value: value.(string)}
	default:
		panic(fmt.Sprintf("Invalid selector for TsEntry_Info: %d", fpm.selector))
	}
}

func (fpm *TsEntryInfo_FieldPathMap) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
	return fpm.WithIValue(value)
}

func (fpm *TsEntryInfo_FieldPathMap) WithIArrayOfValues(values interface{}) TsEntryInfo_FieldPathArrayOfValues {
	switch fpm.selector {
	case TsEntryInfo_FieldPathSelectorCommonMetricLabels:
		return &TsEntryInfo_FieldPathMapArrayOfValues{TsEntryInfo_FieldPathMap: *fpm, values: values.([]string)}
	case TsEntryInfo_FieldPathSelectorCommonResourceLabels:
		return &TsEntryInfo_FieldPathMapArrayOfValues{TsEntryInfo_FieldPathMap: *fpm, values: values.([]string)}
	default:
		panic(fmt.Sprintf("Invalid selector for TsEntry_Info: %d", fpm.selector))
	}
}

func (fpm *TsEntryInfo_FieldPathMap) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
	return fpm.WithIArrayOfValues(values)
}

func (fpm *TsEntryInfo_FieldPathMap) WithIArrayItemValue(value interface{}) TsEntryInfo_FieldPathArrayItemValue {
	panic("Cannot create array item value from map fieldpath")
}

func (fpm *TsEntryInfo_FieldPathMap) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
	return fpm.WithIArrayItemValue(value)
}

type TsEntryInfo_FieldSubPath struct {
	selector TsEntryInfo_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ TsEntryInfo_FieldPath = (*TsEntryInfo_FieldSubPath)(nil)

func (fps *TsEntryInfo_FieldSubPath) Selector() TsEntryInfo_FieldPathSelector {
	return fps.selector
}
func (fps *TsEntryInfo_FieldSubPath) AsAlertingResourceSubPath() (meta.OwnerReference_FieldPath, bool) {
	res, ok := fps.subPath.(meta.OwnerReference_FieldPath)
	return res, ok
}

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

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

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

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

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

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

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

func (fps *TsEntryInfo_FieldSubPath) ClearValue(item *TsEntry_Info) {
	if item != nil {
		switch fps.selector {
		case TsEntryInfo_FieldPathSelectorAlertingResource:
			fps.subPath.ClearValueRaw(item.AlertingResource)
		default:
			panic(fmt.Sprintf("Invalid selector for TsEntry_Info: %d", fps.selector))
		}
	}
}

func (fps *TsEntryInfo_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*TsEntry_Info))
}

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

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

func (fps *TsEntryInfo_FieldSubPath) WithIValue(value interface{}) TsEntryInfo_FieldPathValue {
	return &TsEntryInfo_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *TsEntryInfo_FieldSubPath) WithIArrayOfValues(values interface{}) TsEntryInfo_FieldPathArrayOfValues {
	return &TsEntryInfo_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *TsEntryInfo_FieldSubPath) WithIArrayItemValue(value interface{}) TsEntryInfo_FieldPathArrayItemValue {
	return &TsEntryInfo_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

// TsEntryInfo_FieldPathValue allows storing values for Info fields according to their type
type TsEntryInfo_FieldPathValue interface {
	TsEntryInfo_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **TsEntry_Info)
	CompareWith(*TsEntry_Info) (cmp int, comparable bool)
}

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

func MustParseTsEntryInfo_FieldPathValue(pathStr, valueStr string) TsEntryInfo_FieldPathValue {
	fpv, err := ParseTsEntryInfo_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type TsEntryInfo_FieldTerminalPathValue struct {
	TsEntryInfo_FieldTerminalPath
	value interface{}
}

var _ TsEntryInfo_FieldPathValue = (*TsEntryInfo_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'Info' as interface{}
func (fpv *TsEntryInfo_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *TsEntryInfo_FieldTerminalPathValue) AsAlertingResourceValue() (*meta.OwnerReference, bool) {
	res, ok := fpv.value.(*meta.OwnerReference)
	return res, ok
}
func (fpv *TsEntryInfo_FieldTerminalPathValue) AsGroupByKeyValue() ([]byte, bool) {
	res, ok := fpv.value.([]byte)
	return res, ok
}
func (fpv *TsEntryInfo_FieldTerminalPathValue) AsCommonMetricLabelsValue() (map[string]string, bool) {
	res, ok := fpv.value.(map[string]string)
	return res, ok
}
func (fpv *TsEntryInfo_FieldTerminalPathValue) AsCommonResourceLabelsValue() (map[string]string, bool) {
	res, ok := fpv.value.(map[string]string)
	return res, ok
}

// SetTo stores value for selected field for object Info
func (fpv *TsEntryInfo_FieldTerminalPathValue) SetTo(target **TsEntry_Info) {
	if *target == nil {
		*target = new(TsEntry_Info)
	}
	switch fpv.selector {
	case TsEntryInfo_FieldPathSelectorAlertingResource:
		(*target).AlertingResource = fpv.value.(*meta.OwnerReference)
	case TsEntryInfo_FieldPathSelectorGroupByKey:
		(*target).GroupByKey = fpv.value.([]byte)
	case TsEntryInfo_FieldPathSelectorCommonMetricLabels:
		(*target).CommonMetricLabels = fpv.value.(map[string]string)
	case TsEntryInfo_FieldPathSelectorCommonResourceLabels:
		(*target).CommonResourceLabels = fpv.value.(map[string]string)
	default:
		panic(fmt.Sprintf("Invalid selector for TsEntry_Info: %d", fpv.selector))
	}
}

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

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

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

type TsEntryInfo_FieldPathMapValue struct {
	TsEntryInfo_FieldPathMap
	value interface{}
}

var _ TsEntryInfo_FieldPathValue = (*TsEntryInfo_FieldPathMapValue)(nil)

// GetValue returns value stored under selected field in Info as interface{}
func (fpmv *TsEntryInfo_FieldPathMapValue) GetRawValue() interface{} {
	return fpmv.value
}
func (fpmv *TsEntryInfo_FieldPathMapValue) AsCommonMetricLabelsElementValue() (string, bool) {
	res, ok := fpmv.value.(string)
	return res, ok
}
func (fpmv *TsEntryInfo_FieldPathMapValue) AsCommonResourceLabelsElementValue() (string, bool) {
	res, ok := fpmv.value.(string)
	return res, ok
}

// SetTo stores value for selected field in Info
func (fpmv *TsEntryInfo_FieldPathMapValue) SetTo(target **TsEntry_Info) {
	if *target == nil {
		*target = new(TsEntry_Info)
	}
	switch fpmv.selector {
	case TsEntryInfo_FieldPathSelectorCommonMetricLabels:
		if (*target).CommonMetricLabels == nil {
			(*target).CommonMetricLabels = make(map[string]string)
		}
		(*target).CommonMetricLabels[fpmv.key] = fpmv.value.(string)
	case TsEntryInfo_FieldPathSelectorCommonResourceLabels:
		if (*target).CommonResourceLabels == nil {
			(*target).CommonResourceLabels = make(map[string]string)
		}
		(*target).CommonResourceLabels[fpmv.key] = fpmv.value.(string)
	default:
		panic(fmt.Sprintf("Invalid selector for TsEntry_Info: %d", fpmv.selector))
	}
}

func (fpmv *TsEntryInfo_FieldPathMapValue) SetToRaw(target proto.Message) {
	typedObject := target.(*TsEntry_Info)
	fpmv.SetTo(&typedObject)
}

// CompareWith compares value in the 'TsEntryInfo_FieldPathMapValue' with the value under path in 'TsEntry_Info'.
func (fpmv *TsEntryInfo_FieldPathMapValue) CompareWith(source *TsEntry_Info) (int, bool) {
	switch fpmv.selector {
	case TsEntryInfo_FieldPathSelectorCommonMetricLabels:
		leftValue := fpmv.value.(string)
		rightValue := source.GetCommonMetricLabels()[fpmv.key]
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case TsEntryInfo_FieldPathSelectorCommonResourceLabels:
		leftValue := fpmv.value.(string)
		rightValue := source.GetCommonResourceLabels()[fpmv.key]
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for TsEntry_Info: %d", fpmv.selector))
	}
}

func (fpmv *TsEntryInfo_FieldPathMapValue) CompareWithRaw(source proto.Message) (int, bool) {
	return fpmv.CompareWith(source.(*TsEntry_Info))
}

type TsEntryInfo_FieldSubPathValue struct {
	TsEntryInfo_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ TsEntryInfo_FieldPathValue = (*TsEntryInfo_FieldSubPathValue)(nil)

func (fpvs *TsEntryInfo_FieldSubPathValue) AsAlertingResourcePathValue() (meta.OwnerReference_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(meta.OwnerReference_FieldPathValue)
	return res, ok
}

func (fpvs *TsEntryInfo_FieldSubPathValue) SetTo(target **TsEntry_Info) {
	if *target == nil {
		*target = new(TsEntry_Info)
	}
	switch fpvs.Selector() {
	case TsEntryInfo_FieldPathSelectorAlertingResource:
		fpvs.subPathValue.(meta.OwnerReference_FieldPathValue).SetTo(&(*target).AlertingResource)
	default:
		panic(fmt.Sprintf("Invalid selector for TsEntry_Info: %d", fpvs.Selector()))
	}
}

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

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

func (fpvs *TsEntryInfo_FieldSubPathValue) CompareWith(source *TsEntry_Info) (int, bool) {
	switch fpvs.Selector() {
	case TsEntryInfo_FieldPathSelectorAlertingResource:
		return fpvs.subPathValue.(meta.OwnerReference_FieldPathValue).CompareWith(source.GetAlertingResource())
	default:
		panic(fmt.Sprintf("Invalid selector for TsEntry_Info: %d", fpvs.Selector()))
	}
}

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

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

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

func MustParseTsEntryInfo_FieldPathArrayItemValue(pathStr, valueStr string) TsEntryInfo_FieldPathArrayItemValue {
	fpaiv, err := ParseTsEntryInfo_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type TsEntryInfo_FieldTerminalPathArrayItemValue struct {
	TsEntryInfo_FieldTerminalPath
	value interface{}
}

var _ TsEntryInfo_FieldPathArrayItemValue = (*TsEntryInfo_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *TsEntryInfo_FieldTerminalPathArrayItemValue) GetSingle(source *TsEntry_Info) (interface{}, bool) {
	return nil, false
}

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

// Contains returns a boolean indicating if value that is being held is present in given 'Info'
func (fpaiv *TsEntryInfo_FieldTerminalPathArrayItemValue) ContainsValue(source *TsEntry_Info) bool {
	slice := fpaiv.TsEntryInfo_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 TsEntryInfo_FieldSubPathArrayItemValue struct {
	TsEntryInfo_FieldPath
	subPathItemValue gotenobject.FieldPathArrayItemValue
}

// GetRawValue returns stored array item value
func (fpaivs *TsEntryInfo_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *TsEntryInfo_FieldSubPathArrayItemValue) AsAlertingResourcePathItemValue() (meta.OwnerReference_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(meta.OwnerReference_FieldPathArrayItemValue)
	return res, ok
}

// Contains returns a boolean indicating if value that is being held is present in given 'Info'
func (fpaivs *TsEntryInfo_FieldSubPathArrayItemValue) ContainsValue(source *TsEntry_Info) bool {
	switch fpaivs.Selector() {
	case TsEntryInfo_FieldPathSelectorAlertingResource:
		return fpaivs.subPathItemValue.(meta.OwnerReference_FieldPathArrayItemValue).ContainsValue(source.GetAlertingResource())
	default:
		panic(fmt.Sprintf("Invalid selector for TsEntry_Info: %d", fpaivs.Selector()))
	}
}

// TsEntryInfo_FieldPathArrayOfValues allows storing slice of values for Info fields according to their type
type TsEntryInfo_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	TsEntryInfo_FieldPath
}

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

func MustParseTsEntryInfo_FieldPathArrayOfValues(pathStr, valuesStr string) TsEntryInfo_FieldPathArrayOfValues {
	fpaov, err := ParseTsEntryInfo_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type TsEntryInfo_FieldTerminalPathArrayOfValues struct {
	TsEntryInfo_FieldTerminalPath
	values interface{}
}

var _ TsEntryInfo_FieldPathArrayOfValues = (*TsEntryInfo_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *TsEntryInfo_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case TsEntryInfo_FieldPathSelectorAlertingResource:
		for _, v := range fpaov.values.([]*meta.OwnerReference) {
			values = append(values, v)
		}
	case TsEntryInfo_FieldPathSelectorGroupByKey:
		for _, v := range fpaov.values.([][]byte) {
			values = append(values, v)
		}
	case TsEntryInfo_FieldPathSelectorCommonMetricLabels:
		for _, v := range fpaov.values.([]map[string]string) {
			values = append(values, v)
		}
	case TsEntryInfo_FieldPathSelectorCommonResourceLabels:
		for _, v := range fpaov.values.([]map[string]string) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *TsEntryInfo_FieldTerminalPathArrayOfValues) AsAlertingResourceArrayOfValues() ([]*meta.OwnerReference, bool) {
	res, ok := fpaov.values.([]*meta.OwnerReference)
	return res, ok
}
func (fpaov *TsEntryInfo_FieldTerminalPathArrayOfValues) AsGroupByKeyArrayOfValues() ([][]byte, bool) {
	res, ok := fpaov.values.([][]byte)
	return res, ok
}
func (fpaov *TsEntryInfo_FieldTerminalPathArrayOfValues) AsCommonMetricLabelsArrayOfValues() ([]map[string]string, bool) {
	res, ok := fpaov.values.([]map[string]string)
	return res, ok
}
func (fpaov *TsEntryInfo_FieldTerminalPathArrayOfValues) AsCommonResourceLabelsArrayOfValues() ([]map[string]string, bool) {
	res, ok := fpaov.values.([]map[string]string)
	return res, ok
}

type TsEntryInfo_FieldPathMapArrayOfValues struct {
	TsEntryInfo_FieldPathMap
	values interface{}
}

var _ TsEntryInfo_FieldPathArrayOfValues = (*TsEntryInfo_FieldPathMapArrayOfValues)(nil)

func (fpmaov *TsEntryInfo_FieldPathMapArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpmaov.selector {
	case TsEntryInfo_FieldPathSelectorCommonMetricLabels:
		for _, v := range fpmaov.values.([]string) {
			values = append(values, v)
		}
	case TsEntryInfo_FieldPathSelectorCommonResourceLabels:
		for _, v := range fpmaov.values.([]string) {
			values = append(values, v)
		}
	}
	return
}
func (fpmaov *TsEntryInfo_FieldPathMapArrayOfValues) AsCommonMetricLabelsArrayOfElementValues() ([]string, bool) {
	res, ok := fpmaov.values.([]string)
	return res, ok
}
func (fpmaov *TsEntryInfo_FieldPathMapArrayOfValues) AsCommonResourceLabelsArrayOfElementValues() ([]string, bool) {
	res, ok := fpmaov.values.([]string)
	return res, ok
}

type TsEntryInfo_FieldSubPathArrayOfValues struct {
	TsEntryInfo_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ TsEntryInfo_FieldPathArrayOfValues = (*TsEntryInfo_FieldSubPathArrayOfValues)(nil)

func (fpsaov *TsEntryInfo_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *TsEntryInfo_FieldSubPathArrayOfValues) AsAlertingResourcePathArrayOfValues() (meta.OwnerReference_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(meta.OwnerReference_FieldPathArrayOfValues)
	return res, ok
}

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

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

type TsEntryState_FieldPathSelector int32

const (
	TsEntryState_FieldPathSelectorModels     TsEntryState_FieldPathSelector = 0
	TsEntryState_FieldPathSelectorThresholds TsEntryState_FieldPathSelector = 1
)

func (s TsEntryState_FieldPathSelector) String() string {
	switch s {
	case TsEntryState_FieldPathSelectorModels:
		return "models"
	case TsEntryState_FieldPathSelectorThresholds:
		return "thresholds"
	default:
		panic(fmt.Sprintf("Invalid selector for TsEntry_State: %d", s))
	}
}

func BuildTsEntryState_FieldPath(fp gotenobject.RawFieldPath) (TsEntryState_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object TsEntry_State")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "models":
			return &TsEntryState_FieldTerminalPath{selector: TsEntryState_FieldPathSelectorModels}, nil
		case "thresholds":
			return &TsEntryState_FieldTerminalPath{selector: TsEntryState_FieldPathSelectorThresholds}, nil
		}
	} else {
		switch fp[0] {
		case "models":
			if subpath, err := BuildTsEntryStateAnomalyModelData_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &TsEntryState_FieldSubPath{selector: TsEntryState_FieldPathSelectorModels, subPath: subpath}, nil
			}
		case "thresholds":
			if subpath, err := BuildTsEntryStateAdaptiveThresholdInfo_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &TsEntryState_FieldSubPath{selector: TsEntryState_FieldPathSelectorThresholds, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object TsEntry_State", fp)
}

func ParseTsEntryState_FieldPath(rawField string) (TsEntryState_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildTsEntryState_FieldPath(fp)
}

func MustParseTsEntryState_FieldPath(rawField string) TsEntryState_FieldPath {
	fp, err := ParseTsEntryState_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type TsEntryState_FieldTerminalPath struct {
	selector TsEntryState_FieldPathSelector
}

var _ TsEntryState_FieldPath = (*TsEntryState_FieldTerminalPath)(nil)

func (fp *TsEntryState_FieldTerminalPath) Selector() TsEntryState_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source TsEntry_State
func (fp *TsEntryState_FieldTerminalPath) Get(source *TsEntry_State) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case TsEntryState_FieldPathSelectorModels:
			for _, value := range source.GetModels() {
				values = append(values, value)
			}
		case TsEntryState_FieldPathSelectorThresholds:
			for _, value := range source.GetThresholds() {
				values = append(values, value)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for TsEntry_State: %d", fp.selector))
		}
	}
	return
}

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

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

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

// GetDefault returns a default value of the field type
func (fp *TsEntryState_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case TsEntryState_FieldPathSelectorModels:
		return ([]*TsEntry_State_AnomalyModelData)(nil)
	case TsEntryState_FieldPathSelectorThresholds:
		return ([]*TsEntry_State_AdaptiveThresholdInfo)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for TsEntry_State: %d", fp.selector))
	}
}

func (fp *TsEntryState_FieldTerminalPath) ClearValue(item *TsEntry_State) {
	if item != nil {
		switch fp.selector {
		case TsEntryState_FieldPathSelectorModels:
			item.Models = nil
		case TsEntryState_FieldPathSelectorThresholds:
			item.Thresholds = nil
		default:
			panic(fmt.Sprintf("Invalid selector for TsEntry_State: %d", fp.selector))
		}
	}
}

func (fp *TsEntryState_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*TsEntry_State))
}

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

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

func (fp *TsEntryState_FieldTerminalPath) WithIValue(value interface{}) TsEntryState_FieldPathValue {
	switch fp.selector {
	case TsEntryState_FieldPathSelectorModels:
		return &TsEntryState_FieldTerminalPathValue{TsEntryState_FieldTerminalPath: *fp, value: value.([]*TsEntry_State_AnomalyModelData)}
	case TsEntryState_FieldPathSelectorThresholds:
		return &TsEntryState_FieldTerminalPathValue{TsEntryState_FieldTerminalPath: *fp, value: value.([]*TsEntry_State_AdaptiveThresholdInfo)}
	default:
		panic(fmt.Sprintf("Invalid selector for TsEntry_State: %d", fp.selector))
	}
}

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

func (fp *TsEntryState_FieldTerminalPath) WithIArrayOfValues(values interface{}) TsEntryState_FieldPathArrayOfValues {
	fpaov := &TsEntryState_FieldTerminalPathArrayOfValues{TsEntryState_FieldTerminalPath: *fp}
	switch fp.selector {
	case TsEntryState_FieldPathSelectorModels:
		return &TsEntryState_FieldTerminalPathArrayOfValues{TsEntryState_FieldTerminalPath: *fp, values: values.([][]*TsEntry_State_AnomalyModelData)}
	case TsEntryState_FieldPathSelectorThresholds:
		return &TsEntryState_FieldTerminalPathArrayOfValues{TsEntryState_FieldTerminalPath: *fp, values: values.([][]*TsEntry_State_AdaptiveThresholdInfo)}
	default:
		panic(fmt.Sprintf("Invalid selector for TsEntry_State: %d", fp.selector))
	}
	return fpaov
}

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

func (fp *TsEntryState_FieldTerminalPath) WithIArrayItemValue(value interface{}) TsEntryState_FieldPathArrayItemValue {
	switch fp.selector {
	case TsEntryState_FieldPathSelectorModels:
		return &TsEntryState_FieldTerminalPathArrayItemValue{TsEntryState_FieldTerminalPath: *fp, value: value.(*TsEntry_State_AnomalyModelData)}
	case TsEntryState_FieldPathSelectorThresholds:
		return &TsEntryState_FieldTerminalPathArrayItemValue{TsEntryState_FieldTerminalPath: *fp, value: value.(*TsEntry_State_AdaptiveThresholdInfo)}
	default:
		panic(fmt.Sprintf("Invalid selector for TsEntry_State: %d", fp.selector))
	}
}

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

type TsEntryState_FieldSubPath struct {
	selector TsEntryState_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ TsEntryState_FieldPath = (*TsEntryState_FieldSubPath)(nil)

func (fps *TsEntryState_FieldSubPath) Selector() TsEntryState_FieldPathSelector {
	return fps.selector
}
func (fps *TsEntryState_FieldSubPath) AsModelsSubPath() (TsEntryStateAnomalyModelData_FieldPath, bool) {
	res, ok := fps.subPath.(TsEntryStateAnomalyModelData_FieldPath)
	return res, ok
}
func (fps *TsEntryState_FieldSubPath) AsThresholdsSubPath() (TsEntryStateAdaptiveThresholdInfo_FieldPath, bool) {
	res, ok := fps.subPath.(TsEntryStateAdaptiveThresholdInfo_FieldPath)
	return res, ok
}

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

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

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

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

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

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

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

func (fps *TsEntryState_FieldSubPath) ClearValue(item *TsEntry_State) {
	if item != nil {
		switch fps.selector {
		case TsEntryState_FieldPathSelectorModels:
			for _, subItem := range item.Models {
				fps.subPath.ClearValueRaw(subItem)
			}
		case TsEntryState_FieldPathSelectorThresholds:
			for _, subItem := range item.Thresholds {
				fps.subPath.ClearValueRaw(subItem)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for TsEntry_State: %d", fps.selector))
		}
	}
}

func (fps *TsEntryState_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*TsEntry_State))
}

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

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

func (fps *TsEntryState_FieldSubPath) WithIValue(value interface{}) TsEntryState_FieldPathValue {
	return &TsEntryState_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *TsEntryState_FieldSubPath) WithIArrayOfValues(values interface{}) TsEntryState_FieldPathArrayOfValues {
	return &TsEntryState_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *TsEntryState_FieldSubPath) WithIArrayItemValue(value interface{}) TsEntryState_FieldPathArrayItemValue {
	return &TsEntryState_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

// TsEntryState_FieldPathValue allows storing values for State fields according to their type
type TsEntryState_FieldPathValue interface {
	TsEntryState_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **TsEntry_State)
	CompareWith(*TsEntry_State) (cmp int, comparable bool)
}

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

func MustParseTsEntryState_FieldPathValue(pathStr, valueStr string) TsEntryState_FieldPathValue {
	fpv, err := ParseTsEntryState_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type TsEntryState_FieldTerminalPathValue struct {
	TsEntryState_FieldTerminalPath
	value interface{}
}

var _ TsEntryState_FieldPathValue = (*TsEntryState_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'State' as interface{}
func (fpv *TsEntryState_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *TsEntryState_FieldTerminalPathValue) AsModelsValue() ([]*TsEntry_State_AnomalyModelData, bool) {
	res, ok := fpv.value.([]*TsEntry_State_AnomalyModelData)
	return res, ok
}
func (fpv *TsEntryState_FieldTerminalPathValue) AsThresholdsValue() ([]*TsEntry_State_AdaptiveThresholdInfo, bool) {
	res, ok := fpv.value.([]*TsEntry_State_AdaptiveThresholdInfo)
	return res, ok
}

// SetTo stores value for selected field for object State
func (fpv *TsEntryState_FieldTerminalPathValue) SetTo(target **TsEntry_State) {
	if *target == nil {
		*target = new(TsEntry_State)
	}
	switch fpv.selector {
	case TsEntryState_FieldPathSelectorModels:
		(*target).Models = fpv.value.([]*TsEntry_State_AnomalyModelData)
	case TsEntryState_FieldPathSelectorThresholds:
		(*target).Thresholds = fpv.value.([]*TsEntry_State_AdaptiveThresholdInfo)
	default:
		panic(fmt.Sprintf("Invalid selector for TsEntry_State: %d", fpv.selector))
	}
}

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

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

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

type TsEntryState_FieldSubPathValue struct {
	TsEntryState_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ TsEntryState_FieldPathValue = (*TsEntryState_FieldSubPathValue)(nil)

func (fpvs *TsEntryState_FieldSubPathValue) AsModelsPathValue() (TsEntryStateAnomalyModelData_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(TsEntryStateAnomalyModelData_FieldPathValue)
	return res, ok
}
func (fpvs *TsEntryState_FieldSubPathValue) AsThresholdsPathValue() (TsEntryStateAdaptiveThresholdInfo_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(TsEntryStateAdaptiveThresholdInfo_FieldPathValue)
	return res, ok
}

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

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

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

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

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

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

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

func MustParseTsEntryState_FieldPathArrayItemValue(pathStr, valueStr string) TsEntryState_FieldPathArrayItemValue {
	fpaiv, err := ParseTsEntryState_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type TsEntryState_FieldTerminalPathArrayItemValue struct {
	TsEntryState_FieldTerminalPath
	value interface{}
}

var _ TsEntryState_FieldPathArrayItemValue = (*TsEntryState_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object TsEntry_State as interface{}
func (fpaiv *TsEntryState_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}
func (fpaiv *TsEntryState_FieldTerminalPathArrayItemValue) AsModelsItemValue() (*TsEntry_State_AnomalyModelData, bool) {
	res, ok := fpaiv.value.(*TsEntry_State_AnomalyModelData)
	return res, ok
}
func (fpaiv *TsEntryState_FieldTerminalPathArrayItemValue) AsThresholdsItemValue() (*TsEntry_State_AdaptiveThresholdInfo, bool) {
	res, ok := fpaiv.value.(*TsEntry_State_AdaptiveThresholdInfo)
	return res, ok
}

func (fpaiv *TsEntryState_FieldTerminalPathArrayItemValue) GetSingle(source *TsEntry_State) (interface{}, bool) {
	return nil, false
}

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

// Contains returns a boolean indicating if value that is being held is present in given 'State'
func (fpaiv *TsEntryState_FieldTerminalPathArrayItemValue) ContainsValue(source *TsEntry_State) bool {
	slice := fpaiv.TsEntryState_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 TsEntryState_FieldSubPathArrayItemValue struct {
	TsEntryState_FieldPath
	subPathItemValue gotenobject.FieldPathArrayItemValue
}

// GetRawValue returns stored array item value
func (fpaivs *TsEntryState_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *TsEntryState_FieldSubPathArrayItemValue) AsModelsPathItemValue() (TsEntryStateAnomalyModelData_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(TsEntryStateAnomalyModelData_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *TsEntryState_FieldSubPathArrayItemValue) AsThresholdsPathItemValue() (TsEntryStateAdaptiveThresholdInfo_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(TsEntryStateAdaptiveThresholdInfo_FieldPathArrayItemValue)
	return res, ok
}

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

// TsEntryState_FieldPathArrayOfValues allows storing slice of values for State fields according to their type
type TsEntryState_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	TsEntryState_FieldPath
}

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

func MustParseTsEntryState_FieldPathArrayOfValues(pathStr, valuesStr string) TsEntryState_FieldPathArrayOfValues {
	fpaov, err := ParseTsEntryState_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type TsEntryState_FieldTerminalPathArrayOfValues struct {
	TsEntryState_FieldTerminalPath
	values interface{}
}

var _ TsEntryState_FieldPathArrayOfValues = (*TsEntryState_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *TsEntryState_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case TsEntryState_FieldPathSelectorModels:
		for _, v := range fpaov.values.([][]*TsEntry_State_AnomalyModelData) {
			values = append(values, v)
		}
	case TsEntryState_FieldPathSelectorThresholds:
		for _, v := range fpaov.values.([][]*TsEntry_State_AdaptiveThresholdInfo) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *TsEntryState_FieldTerminalPathArrayOfValues) AsModelsArrayOfValues() ([][]*TsEntry_State_AnomalyModelData, bool) {
	res, ok := fpaov.values.([][]*TsEntry_State_AnomalyModelData)
	return res, ok
}
func (fpaov *TsEntryState_FieldTerminalPathArrayOfValues) AsThresholdsArrayOfValues() ([][]*TsEntry_State_AdaptiveThresholdInfo, bool) {
	res, ok := fpaov.values.([][]*TsEntry_State_AdaptiveThresholdInfo)
	return res, ok
}

type TsEntryState_FieldSubPathArrayOfValues struct {
	TsEntryState_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ TsEntryState_FieldPathArrayOfValues = (*TsEntryState_FieldSubPathArrayOfValues)(nil)

func (fpsaov *TsEntryState_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *TsEntryState_FieldSubPathArrayOfValues) AsModelsPathArrayOfValues() (TsEntryStateAnomalyModelData_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(TsEntryStateAnomalyModelData_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *TsEntryState_FieldSubPathArrayOfValues) AsThresholdsPathArrayOfValues() (TsEntryStateAdaptiveThresholdInfo_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(TsEntryStateAdaptiveThresholdInfo_FieldPathArrayOfValues)
	return res, ok
}

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

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

type TsEntryInternal_FieldPathSelector int32

const (
	TsEntryInternal_FieldPathSelectorAlertingLocation TsEntryInternal_FieldPathSelector = 0
	TsEntryInternal_FieldPathSelectorSpecGeneration   TsEntryInternal_FieldPathSelector = 1
)

func (s TsEntryInternal_FieldPathSelector) String() string {
	switch s {
	case TsEntryInternal_FieldPathSelectorAlertingLocation:
		return "alerting_location"
	case TsEntryInternal_FieldPathSelectorSpecGeneration:
		return "spec_generation"
	default:
		panic(fmt.Sprintf("Invalid selector for TsEntry_Internal: %d", s))
	}
}

func BuildTsEntryInternal_FieldPath(fp gotenobject.RawFieldPath) (TsEntryInternal_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object TsEntry_Internal")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "alerting_location", "alertingLocation", "alerting-location":
			return &TsEntryInternal_FieldTerminalPath{selector: TsEntryInternal_FieldPathSelectorAlertingLocation}, nil
		case "spec_generation", "specGeneration", "spec-generation":
			return &TsEntryInternal_FieldTerminalPath{selector: TsEntryInternal_FieldPathSelectorSpecGeneration}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object TsEntry_Internal", fp)
}

func ParseTsEntryInternal_FieldPath(rawField string) (TsEntryInternal_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildTsEntryInternal_FieldPath(fp)
}

func MustParseTsEntryInternal_FieldPath(rawField string) TsEntryInternal_FieldPath {
	fp, err := ParseTsEntryInternal_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type TsEntryInternal_FieldTerminalPath struct {
	selector TsEntryInternal_FieldPathSelector
}

var _ TsEntryInternal_FieldPath = (*TsEntryInternal_FieldTerminalPath)(nil)

func (fp *TsEntryInternal_FieldTerminalPath) Selector() TsEntryInternal_FieldPathSelector {
	return fp.selector
}

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

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

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

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

// GetSingle returns value pointed by specific field of from source TsEntry_Internal
func (fp *TsEntryInternal_FieldTerminalPath) GetSingle(source *TsEntry_Internal) (interface{}, bool) {
	switch fp.selector {
	case TsEntryInternal_FieldPathSelectorAlertingLocation:
		return source.GetAlertingLocation(), source != nil
	case TsEntryInternal_FieldPathSelectorSpecGeneration:
		return source.GetSpecGeneration(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for TsEntry_Internal: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *TsEntryInternal_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case TsEntryInternal_FieldPathSelectorAlertingLocation:
		return rcommon.PolicySpec_UNDEFINED
	case TsEntryInternal_FieldPathSelectorSpecGeneration:
		return int32(0)
	default:
		panic(fmt.Sprintf("Invalid selector for TsEntry_Internal: %d", fp.selector))
	}
}

func (fp *TsEntryInternal_FieldTerminalPath) ClearValue(item *TsEntry_Internal) {
	if item != nil {
		switch fp.selector {
		case TsEntryInternal_FieldPathSelectorAlertingLocation:
			item.AlertingLocation = rcommon.PolicySpec_UNDEFINED
		case TsEntryInternal_FieldPathSelectorSpecGeneration:
			item.SpecGeneration = int32(0)
		default:
			panic(fmt.Sprintf("Invalid selector for TsEntry_Internal: %d", fp.selector))
		}
	}
}

func (fp *TsEntryInternal_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*TsEntry_Internal))
}

// IsLeaf - whether field path is holds simple value
func (fp *TsEntryInternal_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == TsEntryInternal_FieldPathSelectorAlertingLocation ||
		fp.selector == TsEntryInternal_FieldPathSelectorSpecGeneration
}

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

func (fp *TsEntryInternal_FieldTerminalPath) WithIValue(value interface{}) TsEntryInternal_FieldPathValue {
	switch fp.selector {
	case TsEntryInternal_FieldPathSelectorAlertingLocation:
		return &TsEntryInternal_FieldTerminalPathValue{TsEntryInternal_FieldTerminalPath: *fp, value: value.(rcommon.PolicySpec_ProcessingLocation)}
	case TsEntryInternal_FieldPathSelectorSpecGeneration:
		return &TsEntryInternal_FieldTerminalPathValue{TsEntryInternal_FieldTerminalPath: *fp, value: value.(int32)}
	default:
		panic(fmt.Sprintf("Invalid selector for TsEntry_Internal: %d", fp.selector))
	}
}

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

func (fp *TsEntryInternal_FieldTerminalPath) WithIArrayOfValues(values interface{}) TsEntryInternal_FieldPathArrayOfValues {
	fpaov := &TsEntryInternal_FieldTerminalPathArrayOfValues{TsEntryInternal_FieldTerminalPath: *fp}
	switch fp.selector {
	case TsEntryInternal_FieldPathSelectorAlertingLocation:
		return &TsEntryInternal_FieldTerminalPathArrayOfValues{TsEntryInternal_FieldTerminalPath: *fp, values: values.([]rcommon.PolicySpec_ProcessingLocation)}
	case TsEntryInternal_FieldPathSelectorSpecGeneration:
		return &TsEntryInternal_FieldTerminalPathArrayOfValues{TsEntryInternal_FieldTerminalPath: *fp, values: values.([]int32)}
	default:
		panic(fmt.Sprintf("Invalid selector for TsEntry_Internal: %d", fp.selector))
	}
	return fpaov
}

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

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

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

// TsEntryInternal_FieldPathValue allows storing values for Internal fields according to their type
type TsEntryInternal_FieldPathValue interface {
	TsEntryInternal_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **TsEntry_Internal)
	CompareWith(*TsEntry_Internal) (cmp int, comparable bool)
}

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

func MustParseTsEntryInternal_FieldPathValue(pathStr, valueStr string) TsEntryInternal_FieldPathValue {
	fpv, err := ParseTsEntryInternal_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type TsEntryInternal_FieldTerminalPathValue struct {
	TsEntryInternal_FieldTerminalPath
	value interface{}
}

var _ TsEntryInternal_FieldPathValue = (*TsEntryInternal_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'Internal' as interface{}
func (fpv *TsEntryInternal_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *TsEntryInternal_FieldTerminalPathValue) AsAlertingLocationValue() (rcommon.PolicySpec_ProcessingLocation, bool) {
	res, ok := fpv.value.(rcommon.PolicySpec_ProcessingLocation)
	return res, ok
}
func (fpv *TsEntryInternal_FieldTerminalPathValue) AsSpecGenerationValue() (int32, bool) {
	res, ok := fpv.value.(int32)
	return res, ok
}

// SetTo stores value for selected field for object Internal
func (fpv *TsEntryInternal_FieldTerminalPathValue) SetTo(target **TsEntry_Internal) {
	if *target == nil {
		*target = new(TsEntry_Internal)
	}
	switch fpv.selector {
	case TsEntryInternal_FieldPathSelectorAlertingLocation:
		(*target).AlertingLocation = fpv.value.(rcommon.PolicySpec_ProcessingLocation)
	case TsEntryInternal_FieldPathSelectorSpecGeneration:
		(*target).SpecGeneration = fpv.value.(int32)
	default:
		panic(fmt.Sprintf("Invalid selector for TsEntry_Internal: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'TsEntryInternal_FieldTerminalPathValue' with the value under path in 'TsEntry_Internal'.
func (fpv *TsEntryInternal_FieldTerminalPathValue) CompareWith(source *TsEntry_Internal) (int, bool) {
	switch fpv.selector {
	case TsEntryInternal_FieldPathSelectorAlertingLocation:
		leftValue := fpv.value.(rcommon.PolicySpec_ProcessingLocation)
		rightValue := source.GetAlertingLocation()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case TsEntryInternal_FieldPathSelectorSpecGeneration:
		leftValue := fpv.value.(int32)
		rightValue := source.GetSpecGeneration()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for TsEntry_Internal: %d", fpv.selector))
	}
}

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

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

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

func MustParseTsEntryInternal_FieldPathArrayItemValue(pathStr, valueStr string) TsEntryInternal_FieldPathArrayItemValue {
	fpaiv, err := ParseTsEntryInternal_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type TsEntryInternal_FieldTerminalPathArrayItemValue struct {
	TsEntryInternal_FieldTerminalPath
	value interface{}
}

var _ TsEntryInternal_FieldPathArrayItemValue = (*TsEntryInternal_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *TsEntryInternal_FieldTerminalPathArrayItemValue) GetSingle(source *TsEntry_Internal) (interface{}, bool) {
	return nil, false
}

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

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

// TsEntryInternal_FieldPathArrayOfValues allows storing slice of values for Internal fields according to their type
type TsEntryInternal_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	TsEntryInternal_FieldPath
}

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

func MustParseTsEntryInternal_FieldPathArrayOfValues(pathStr, valuesStr string) TsEntryInternal_FieldPathArrayOfValues {
	fpaov, err := ParseTsEntryInternal_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type TsEntryInternal_FieldTerminalPathArrayOfValues struct {
	TsEntryInternal_FieldTerminalPath
	values interface{}
}

var _ TsEntryInternal_FieldPathArrayOfValues = (*TsEntryInternal_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *TsEntryInternal_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case TsEntryInternal_FieldPathSelectorAlertingLocation:
		for _, v := range fpaov.values.([]rcommon.PolicySpec_ProcessingLocation) {
			values = append(values, v)
		}
	case TsEntryInternal_FieldPathSelectorSpecGeneration:
		for _, v := range fpaov.values.([]int32) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *TsEntryInternal_FieldTerminalPathArrayOfValues) AsAlertingLocationArrayOfValues() ([]rcommon.PolicySpec_ProcessingLocation, bool) {
	res, ok := fpaov.values.([]rcommon.PolicySpec_ProcessingLocation)
	return res, ok
}
func (fpaov *TsEntryInternal_FieldTerminalPathArrayOfValues) AsSpecGenerationArrayOfValues() ([]int32, bool) {
	res, ok := fpaov.values.([]int32)
	return res, ok
}

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

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

type TsEntryStateAnomalyModelData_FieldPathSelector int32

const (
	TsEntryStateAnomalyModelData_FieldPathSelectorAnalysisWindow  TsEntryStateAnomalyModelData_FieldPathSelector = 0
	TsEntryStateAnomalyModelData_FieldPathSelectorModelData       TsEntryStateAnomalyModelData_FieldPathSelector = 1
	TsEntryStateAnomalyModelData_FieldPathSelectorTrainingMeanErr TsEntryStateAnomalyModelData_FieldPathSelector = 2
	TsEntryStateAnomalyModelData_FieldPathSelectorTrainingMaxErr  TsEntryStateAnomalyModelData_FieldPathSelector = 3
	TsEntryStateAnomalyModelData_FieldPathSelectorTrainedInEpochs TsEntryStateAnomalyModelData_FieldPathSelector = 4
	TsEntryStateAnomalyModelData_FieldPathSelectorTrainedIn       TsEntryStateAnomalyModelData_FieldPathSelector = 5
	TsEntryStateAnomalyModelData_FieldPathSelectorTrainAfter      TsEntryStateAnomalyModelData_FieldPathSelector = 6
	TsEntryStateAnomalyModelData_FieldPathSelectorTrainingPeriod  TsEntryStateAnomalyModelData_FieldPathSelector = 7
	TsEntryStateAnomalyModelData_FieldPathSelectorSensitiveness   TsEntryStateAnomalyModelData_FieldPathSelector = 8
)

func (s TsEntryStateAnomalyModelData_FieldPathSelector) String() string {
	switch s {
	case TsEntryStateAnomalyModelData_FieldPathSelectorAnalysisWindow:
		return "analysis_window"
	case TsEntryStateAnomalyModelData_FieldPathSelectorModelData:
		return "model_data"
	case TsEntryStateAnomalyModelData_FieldPathSelectorTrainingMeanErr:
		return "training_mean_err"
	case TsEntryStateAnomalyModelData_FieldPathSelectorTrainingMaxErr:
		return "training_max_err"
	case TsEntryStateAnomalyModelData_FieldPathSelectorTrainedInEpochs:
		return "trained_in_epochs"
	case TsEntryStateAnomalyModelData_FieldPathSelectorTrainedIn:
		return "trained_in"
	case TsEntryStateAnomalyModelData_FieldPathSelectorTrainAfter:
		return "train_after"
	case TsEntryStateAnomalyModelData_FieldPathSelectorTrainingPeriod:
		return "training_period"
	case TsEntryStateAnomalyModelData_FieldPathSelectorSensitiveness:
		return "sensitiveness"
	default:
		panic(fmt.Sprintf("Invalid selector for TsEntry_State_AnomalyModelData: %d", s))
	}
}

func BuildTsEntryStateAnomalyModelData_FieldPath(fp gotenobject.RawFieldPath) (TsEntryStateAnomalyModelData_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object TsEntry_State_AnomalyModelData")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "analysis_window", "analysisWindow", "analysis-window":
			return &TsEntryStateAnomalyModelData_FieldTerminalPath{selector: TsEntryStateAnomalyModelData_FieldPathSelectorAnalysisWindow}, nil
		case "model_data", "modelData", "model-data":
			return &TsEntryStateAnomalyModelData_FieldTerminalPath{selector: TsEntryStateAnomalyModelData_FieldPathSelectorModelData}, nil
		case "training_mean_err", "trainingMeanErr", "training-mean-err":
			return &TsEntryStateAnomalyModelData_FieldTerminalPath{selector: TsEntryStateAnomalyModelData_FieldPathSelectorTrainingMeanErr}, nil
		case "training_max_err", "trainingMaxErr", "training-max-err":
			return &TsEntryStateAnomalyModelData_FieldTerminalPath{selector: TsEntryStateAnomalyModelData_FieldPathSelectorTrainingMaxErr}, nil
		case "trained_in_epochs", "trainedInEpochs", "trained-in-epochs":
			return &TsEntryStateAnomalyModelData_FieldTerminalPath{selector: TsEntryStateAnomalyModelData_FieldPathSelectorTrainedInEpochs}, nil
		case "trained_in", "trainedIn", "trained-in":
			return &TsEntryStateAnomalyModelData_FieldTerminalPath{selector: TsEntryStateAnomalyModelData_FieldPathSelectorTrainedIn}, nil
		case "train_after", "trainAfter", "train-after":
			return &TsEntryStateAnomalyModelData_FieldTerminalPath{selector: TsEntryStateAnomalyModelData_FieldPathSelectorTrainAfter}, nil
		case "training_period", "trainingPeriod", "training-period":
			return &TsEntryStateAnomalyModelData_FieldTerminalPath{selector: TsEntryStateAnomalyModelData_FieldPathSelectorTrainingPeriod}, nil
		case "sensitiveness":
			return &TsEntryStateAnomalyModelData_FieldTerminalPath{selector: TsEntryStateAnomalyModelData_FieldPathSelectorSensitiveness}, nil
		}
	} else {
		switch fp[0] {
		case "training_period", "trainingPeriod", "training-period":
			if subpath, err := monitoring_common.BuildTimeInterval_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &TsEntryStateAnomalyModelData_FieldSubPath{selector: TsEntryStateAnomalyModelData_FieldPathSelectorTrainingPeriod, subPath: subpath}, nil
			}
		case "sensitiveness":
			if subpath, err := BuildTsEntryStateAnomalyModelSensitiveness_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &TsEntryStateAnomalyModelData_FieldSubPath{selector: TsEntryStateAnomalyModelData_FieldPathSelectorSensitiveness, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object TsEntry_State_AnomalyModelData", fp)
}

func ParseTsEntryStateAnomalyModelData_FieldPath(rawField string) (TsEntryStateAnomalyModelData_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildTsEntryStateAnomalyModelData_FieldPath(fp)
}

func MustParseTsEntryStateAnomalyModelData_FieldPath(rawField string) TsEntryStateAnomalyModelData_FieldPath {
	fp, err := ParseTsEntryStateAnomalyModelData_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type TsEntryStateAnomalyModelData_FieldTerminalPath struct {
	selector TsEntryStateAnomalyModelData_FieldPathSelector
}

var _ TsEntryStateAnomalyModelData_FieldPath = (*TsEntryStateAnomalyModelData_FieldTerminalPath)(nil)

func (fp *TsEntryStateAnomalyModelData_FieldTerminalPath) Selector() TsEntryStateAnomalyModelData_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source TsEntry_State_AnomalyModelData
func (fp *TsEntryStateAnomalyModelData_FieldTerminalPath) Get(source *TsEntry_State_AnomalyModelData) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case TsEntryStateAnomalyModelData_FieldPathSelectorAnalysisWindow:
			if source.AnalysisWindow != nil {
				values = append(values, source.AnalysisWindow)
			}
		case TsEntryStateAnomalyModelData_FieldPathSelectorModelData:
			values = append(values, source.ModelData)
		case TsEntryStateAnomalyModelData_FieldPathSelectorTrainingMeanErr:
			for _, value := range source.GetTrainingMeanErr() {
				values = append(values, value)
			}
		case TsEntryStateAnomalyModelData_FieldPathSelectorTrainingMaxErr:
			for _, value := range source.GetTrainingMaxErr() {
				values = append(values, value)
			}
		case TsEntryStateAnomalyModelData_FieldPathSelectorTrainedInEpochs:
			values = append(values, source.TrainedInEpochs)
		case TsEntryStateAnomalyModelData_FieldPathSelectorTrainedIn:
			if source.TrainedIn != nil {
				values = append(values, source.TrainedIn)
			}
		case TsEntryStateAnomalyModelData_FieldPathSelectorTrainAfter:
			if source.TrainAfter != nil {
				values = append(values, source.TrainAfter)
			}
		case TsEntryStateAnomalyModelData_FieldPathSelectorTrainingPeriod:
			if source.TrainingPeriod != nil {
				values = append(values, source.TrainingPeriod)
			}
		case TsEntryStateAnomalyModelData_FieldPathSelectorSensitiveness:
			for _, value := range source.GetSensitiveness() {
				values = append(values, value)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for TsEntry_State_AnomalyModelData: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source TsEntry_State_AnomalyModelData
func (fp *TsEntryStateAnomalyModelData_FieldTerminalPath) GetSingle(source *TsEntry_State_AnomalyModelData) (interface{}, bool) {
	switch fp.selector {
	case TsEntryStateAnomalyModelData_FieldPathSelectorAnalysisWindow:
		res := source.GetAnalysisWindow()
		return res, res != nil
	case TsEntryStateAnomalyModelData_FieldPathSelectorModelData:
		res := source.GetModelData()
		return res, res != nil
	case TsEntryStateAnomalyModelData_FieldPathSelectorTrainingMeanErr:
		res := source.GetTrainingMeanErr()
		return res, res != nil
	case TsEntryStateAnomalyModelData_FieldPathSelectorTrainingMaxErr:
		res := source.GetTrainingMaxErr()
		return res, res != nil
	case TsEntryStateAnomalyModelData_FieldPathSelectorTrainedInEpochs:
		return source.GetTrainedInEpochs(), source != nil
	case TsEntryStateAnomalyModelData_FieldPathSelectorTrainedIn:
		res := source.GetTrainedIn()
		return res, res != nil
	case TsEntryStateAnomalyModelData_FieldPathSelectorTrainAfter:
		res := source.GetTrainAfter()
		return res, res != nil
	case TsEntryStateAnomalyModelData_FieldPathSelectorTrainingPeriod:
		res := source.GetTrainingPeriod()
		return res, res != nil
	case TsEntryStateAnomalyModelData_FieldPathSelectorSensitiveness:
		res := source.GetSensitiveness()
		return res, res != nil
	default:
		panic(fmt.Sprintf("Invalid selector for TsEntry_State_AnomalyModelData: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *TsEntryStateAnomalyModelData_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case TsEntryStateAnomalyModelData_FieldPathSelectorAnalysisWindow:
		return (*durationpb.Duration)(nil)
	case TsEntryStateAnomalyModelData_FieldPathSelectorModelData:
		return ([]byte)(nil)
	case TsEntryStateAnomalyModelData_FieldPathSelectorTrainingMeanErr:
		return ([]float64)(nil)
	case TsEntryStateAnomalyModelData_FieldPathSelectorTrainingMaxErr:
		return ([]float64)(nil)
	case TsEntryStateAnomalyModelData_FieldPathSelectorTrainedInEpochs:
		return int32(0)
	case TsEntryStateAnomalyModelData_FieldPathSelectorTrainedIn:
		return (*durationpb.Duration)(nil)
	case TsEntryStateAnomalyModelData_FieldPathSelectorTrainAfter:
		return (*timestamppb.Timestamp)(nil)
	case TsEntryStateAnomalyModelData_FieldPathSelectorTrainingPeriod:
		return (*monitoring_common.TimeInterval)(nil)
	case TsEntryStateAnomalyModelData_FieldPathSelectorSensitiveness:
		return ([]*TsEntry_State_AnomalyModelSensitiveness)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for TsEntry_State_AnomalyModelData: %d", fp.selector))
	}
}

func (fp *TsEntryStateAnomalyModelData_FieldTerminalPath) ClearValue(item *TsEntry_State_AnomalyModelData) {
	if item != nil {
		switch fp.selector {
		case TsEntryStateAnomalyModelData_FieldPathSelectorAnalysisWindow:
			item.AnalysisWindow = nil
		case TsEntryStateAnomalyModelData_FieldPathSelectorModelData:
			item.ModelData = nil
		case TsEntryStateAnomalyModelData_FieldPathSelectorTrainingMeanErr:
			item.TrainingMeanErr = nil
		case TsEntryStateAnomalyModelData_FieldPathSelectorTrainingMaxErr:
			item.TrainingMaxErr = nil
		case TsEntryStateAnomalyModelData_FieldPathSelectorTrainedInEpochs:
			item.TrainedInEpochs = int32(0)
		case TsEntryStateAnomalyModelData_FieldPathSelectorTrainedIn:
			item.TrainedIn = nil
		case TsEntryStateAnomalyModelData_FieldPathSelectorTrainAfter:
			item.TrainAfter = nil
		case TsEntryStateAnomalyModelData_FieldPathSelectorTrainingPeriod:
			item.TrainingPeriod = nil
		case TsEntryStateAnomalyModelData_FieldPathSelectorSensitiveness:
			item.Sensitiveness = nil
		default:
			panic(fmt.Sprintf("Invalid selector for TsEntry_State_AnomalyModelData: %d", fp.selector))
		}
	}
}

func (fp *TsEntryStateAnomalyModelData_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*TsEntry_State_AnomalyModelData))
}

// IsLeaf - whether field path is holds simple value
func (fp *TsEntryStateAnomalyModelData_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == TsEntryStateAnomalyModelData_FieldPathSelectorAnalysisWindow ||
		fp.selector == TsEntryStateAnomalyModelData_FieldPathSelectorModelData ||
		fp.selector == TsEntryStateAnomalyModelData_FieldPathSelectorTrainingMeanErr ||
		fp.selector == TsEntryStateAnomalyModelData_FieldPathSelectorTrainingMaxErr ||
		fp.selector == TsEntryStateAnomalyModelData_FieldPathSelectorTrainedInEpochs ||
		fp.selector == TsEntryStateAnomalyModelData_FieldPathSelectorTrainedIn ||
		fp.selector == TsEntryStateAnomalyModelData_FieldPathSelectorTrainAfter
}

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

func (fp *TsEntryStateAnomalyModelData_FieldTerminalPath) WithIValue(value interface{}) TsEntryStateAnomalyModelData_FieldPathValue {
	switch fp.selector {
	case TsEntryStateAnomalyModelData_FieldPathSelectorAnalysisWindow:
		return &TsEntryStateAnomalyModelData_FieldTerminalPathValue{TsEntryStateAnomalyModelData_FieldTerminalPath: *fp, value: value.(*durationpb.Duration)}
	case TsEntryStateAnomalyModelData_FieldPathSelectorModelData:
		return &TsEntryStateAnomalyModelData_FieldTerminalPathValue{TsEntryStateAnomalyModelData_FieldTerminalPath: *fp, value: value.([]byte)}
	case TsEntryStateAnomalyModelData_FieldPathSelectorTrainingMeanErr:
		return &TsEntryStateAnomalyModelData_FieldTerminalPathValue{TsEntryStateAnomalyModelData_FieldTerminalPath: *fp, value: value.([]float64)}
	case TsEntryStateAnomalyModelData_FieldPathSelectorTrainingMaxErr:
		return &TsEntryStateAnomalyModelData_FieldTerminalPathValue{TsEntryStateAnomalyModelData_FieldTerminalPath: *fp, value: value.([]float64)}
	case TsEntryStateAnomalyModelData_FieldPathSelectorTrainedInEpochs:
		return &TsEntryStateAnomalyModelData_FieldTerminalPathValue{TsEntryStateAnomalyModelData_FieldTerminalPath: *fp, value: value.(int32)}
	case TsEntryStateAnomalyModelData_FieldPathSelectorTrainedIn:
		return &TsEntryStateAnomalyModelData_FieldTerminalPathValue{TsEntryStateAnomalyModelData_FieldTerminalPath: *fp, value: value.(*durationpb.Duration)}
	case TsEntryStateAnomalyModelData_FieldPathSelectorTrainAfter:
		return &TsEntryStateAnomalyModelData_FieldTerminalPathValue{TsEntryStateAnomalyModelData_FieldTerminalPath: *fp, value: value.(*timestamppb.Timestamp)}
	case TsEntryStateAnomalyModelData_FieldPathSelectorTrainingPeriod:
		return &TsEntryStateAnomalyModelData_FieldTerminalPathValue{TsEntryStateAnomalyModelData_FieldTerminalPath: *fp, value: value.(*monitoring_common.TimeInterval)}
	case TsEntryStateAnomalyModelData_FieldPathSelectorSensitiveness:
		return &TsEntryStateAnomalyModelData_FieldTerminalPathValue{TsEntryStateAnomalyModelData_FieldTerminalPath: *fp, value: value.([]*TsEntry_State_AnomalyModelSensitiveness)}
	default:
		panic(fmt.Sprintf("Invalid selector for TsEntry_State_AnomalyModelData: %d", fp.selector))
	}
}

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

func (fp *TsEntryStateAnomalyModelData_FieldTerminalPath) WithIArrayOfValues(values interface{}) TsEntryStateAnomalyModelData_FieldPathArrayOfValues {
	fpaov := &TsEntryStateAnomalyModelData_FieldTerminalPathArrayOfValues{TsEntryStateAnomalyModelData_FieldTerminalPath: *fp}
	switch fp.selector {
	case TsEntryStateAnomalyModelData_FieldPathSelectorAnalysisWindow:
		return &TsEntryStateAnomalyModelData_FieldTerminalPathArrayOfValues{TsEntryStateAnomalyModelData_FieldTerminalPath: *fp, values: values.([]*durationpb.Duration)}
	case TsEntryStateAnomalyModelData_FieldPathSelectorModelData:
		return &TsEntryStateAnomalyModelData_FieldTerminalPathArrayOfValues{TsEntryStateAnomalyModelData_FieldTerminalPath: *fp, values: values.([][]byte)}
	case TsEntryStateAnomalyModelData_FieldPathSelectorTrainingMeanErr:
		return &TsEntryStateAnomalyModelData_FieldTerminalPathArrayOfValues{TsEntryStateAnomalyModelData_FieldTerminalPath: *fp, values: values.([][]float64)}
	case TsEntryStateAnomalyModelData_FieldPathSelectorTrainingMaxErr:
		return &TsEntryStateAnomalyModelData_FieldTerminalPathArrayOfValues{TsEntryStateAnomalyModelData_FieldTerminalPath: *fp, values: values.([][]float64)}
	case TsEntryStateAnomalyModelData_FieldPathSelectorTrainedInEpochs:
		return &TsEntryStateAnomalyModelData_FieldTerminalPathArrayOfValues{TsEntryStateAnomalyModelData_FieldTerminalPath: *fp, values: values.([]int32)}
	case TsEntryStateAnomalyModelData_FieldPathSelectorTrainedIn:
		return &TsEntryStateAnomalyModelData_FieldTerminalPathArrayOfValues{TsEntryStateAnomalyModelData_FieldTerminalPath: *fp, values: values.([]*durationpb.Duration)}
	case TsEntryStateAnomalyModelData_FieldPathSelectorTrainAfter:
		return &TsEntryStateAnomalyModelData_FieldTerminalPathArrayOfValues{TsEntryStateAnomalyModelData_FieldTerminalPath: *fp, values: values.([]*timestamppb.Timestamp)}
	case TsEntryStateAnomalyModelData_FieldPathSelectorTrainingPeriod:
		return &TsEntryStateAnomalyModelData_FieldTerminalPathArrayOfValues{TsEntryStateAnomalyModelData_FieldTerminalPath: *fp, values: values.([]*monitoring_common.TimeInterval)}
	case TsEntryStateAnomalyModelData_FieldPathSelectorSensitiveness:
		return &TsEntryStateAnomalyModelData_FieldTerminalPathArrayOfValues{TsEntryStateAnomalyModelData_FieldTerminalPath: *fp, values: values.([][]*TsEntry_State_AnomalyModelSensitiveness)}
	default:
		panic(fmt.Sprintf("Invalid selector for TsEntry_State_AnomalyModelData: %d", fp.selector))
	}
	return fpaov
}

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

func (fp *TsEntryStateAnomalyModelData_FieldTerminalPath) WithIArrayItemValue(value interface{}) TsEntryStateAnomalyModelData_FieldPathArrayItemValue {
	switch fp.selector {
	case TsEntryStateAnomalyModelData_FieldPathSelectorTrainingMeanErr:
		return &TsEntryStateAnomalyModelData_FieldTerminalPathArrayItemValue{TsEntryStateAnomalyModelData_FieldTerminalPath: *fp, value: value.(float64)}
	case TsEntryStateAnomalyModelData_FieldPathSelectorTrainingMaxErr:
		return &TsEntryStateAnomalyModelData_FieldTerminalPathArrayItemValue{TsEntryStateAnomalyModelData_FieldTerminalPath: *fp, value: value.(float64)}
	case TsEntryStateAnomalyModelData_FieldPathSelectorSensitiveness:
		return &TsEntryStateAnomalyModelData_FieldTerminalPathArrayItemValue{TsEntryStateAnomalyModelData_FieldTerminalPath: *fp, value: value.(*TsEntry_State_AnomalyModelSensitiveness)}
	default:
		panic(fmt.Sprintf("Invalid selector for TsEntry_State_AnomalyModelData: %d", fp.selector))
	}
}

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

type TsEntryStateAnomalyModelData_FieldSubPath struct {
	selector TsEntryStateAnomalyModelData_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ TsEntryStateAnomalyModelData_FieldPath = (*TsEntryStateAnomalyModelData_FieldSubPath)(nil)

func (fps *TsEntryStateAnomalyModelData_FieldSubPath) Selector() TsEntryStateAnomalyModelData_FieldPathSelector {
	return fps.selector
}
func (fps *TsEntryStateAnomalyModelData_FieldSubPath) AsTrainingPeriodSubPath() (monitoring_common.TimeInterval_FieldPath, bool) {
	res, ok := fps.subPath.(monitoring_common.TimeInterval_FieldPath)
	return res, ok
}
func (fps *TsEntryStateAnomalyModelData_FieldSubPath) AsSensitivenessSubPath() (TsEntryStateAnomalyModelSensitiveness_FieldPath, bool) {
	res, ok := fps.subPath.(TsEntryStateAnomalyModelSensitiveness_FieldPath)
	return res, ok
}

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

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

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

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

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

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

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

func (fps *TsEntryStateAnomalyModelData_FieldSubPath) ClearValue(item *TsEntry_State_AnomalyModelData) {
	if item != nil {
		switch fps.selector {
		case TsEntryStateAnomalyModelData_FieldPathSelectorTrainingPeriod:
			fps.subPath.ClearValueRaw(item.TrainingPeriod)
		case TsEntryStateAnomalyModelData_FieldPathSelectorSensitiveness:
			for _, subItem := range item.Sensitiveness {
				fps.subPath.ClearValueRaw(subItem)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for TsEntry_State_AnomalyModelData: %d", fps.selector))
		}
	}
}

func (fps *TsEntryStateAnomalyModelData_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*TsEntry_State_AnomalyModelData))
}

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

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

func (fps *TsEntryStateAnomalyModelData_FieldSubPath) WithIValue(value interface{}) TsEntryStateAnomalyModelData_FieldPathValue {
	return &TsEntryStateAnomalyModelData_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *TsEntryStateAnomalyModelData_FieldSubPath) WithIArrayOfValues(values interface{}) TsEntryStateAnomalyModelData_FieldPathArrayOfValues {
	return &TsEntryStateAnomalyModelData_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *TsEntryStateAnomalyModelData_FieldSubPath) WithIArrayItemValue(value interface{}) TsEntryStateAnomalyModelData_FieldPathArrayItemValue {
	return &TsEntryStateAnomalyModelData_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

// TsEntryStateAnomalyModelData_FieldPathValue allows storing values for AnomalyModelData fields according to their type
type TsEntryStateAnomalyModelData_FieldPathValue interface {
	TsEntryStateAnomalyModelData_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **TsEntry_State_AnomalyModelData)
	CompareWith(*TsEntry_State_AnomalyModelData) (cmp int, comparable bool)
}

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

func MustParseTsEntryStateAnomalyModelData_FieldPathValue(pathStr, valueStr string) TsEntryStateAnomalyModelData_FieldPathValue {
	fpv, err := ParseTsEntryStateAnomalyModelData_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type TsEntryStateAnomalyModelData_FieldTerminalPathValue struct {
	TsEntryStateAnomalyModelData_FieldTerminalPath
	value interface{}
}

var _ TsEntryStateAnomalyModelData_FieldPathValue = (*TsEntryStateAnomalyModelData_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'AnomalyModelData' as interface{}
func (fpv *TsEntryStateAnomalyModelData_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *TsEntryStateAnomalyModelData_FieldTerminalPathValue) AsAnalysisWindowValue() (*durationpb.Duration, bool) {
	res, ok := fpv.value.(*durationpb.Duration)
	return res, ok
}
func (fpv *TsEntryStateAnomalyModelData_FieldTerminalPathValue) AsModelDataValue() ([]byte, bool) {
	res, ok := fpv.value.([]byte)
	return res, ok
}
func (fpv *TsEntryStateAnomalyModelData_FieldTerminalPathValue) AsTrainingMeanErrValue() ([]float64, bool) {
	res, ok := fpv.value.([]float64)
	return res, ok
}
func (fpv *TsEntryStateAnomalyModelData_FieldTerminalPathValue) AsTrainingMaxErrValue() ([]float64, bool) {
	res, ok := fpv.value.([]float64)
	return res, ok
}
func (fpv *TsEntryStateAnomalyModelData_FieldTerminalPathValue) AsTrainedInEpochsValue() (int32, bool) {
	res, ok := fpv.value.(int32)
	return res, ok
}
func (fpv *TsEntryStateAnomalyModelData_FieldTerminalPathValue) AsTrainedInValue() (*durationpb.Duration, bool) {
	res, ok := fpv.value.(*durationpb.Duration)
	return res, ok
}
func (fpv *TsEntryStateAnomalyModelData_FieldTerminalPathValue) AsTrainAfterValue() (*timestamppb.Timestamp, bool) {
	res, ok := fpv.value.(*timestamppb.Timestamp)
	return res, ok
}
func (fpv *TsEntryStateAnomalyModelData_FieldTerminalPathValue) AsTrainingPeriodValue() (*monitoring_common.TimeInterval, bool) {
	res, ok := fpv.value.(*monitoring_common.TimeInterval)
	return res, ok
}
func (fpv *TsEntryStateAnomalyModelData_FieldTerminalPathValue) AsSensitivenessValue() ([]*TsEntry_State_AnomalyModelSensitiveness, bool) {
	res, ok := fpv.value.([]*TsEntry_State_AnomalyModelSensitiveness)
	return res, ok
}

// SetTo stores value for selected field for object AnomalyModelData
func (fpv *TsEntryStateAnomalyModelData_FieldTerminalPathValue) SetTo(target **TsEntry_State_AnomalyModelData) {
	if *target == nil {
		*target = new(TsEntry_State_AnomalyModelData)
	}
	switch fpv.selector {
	case TsEntryStateAnomalyModelData_FieldPathSelectorAnalysisWindow:
		(*target).AnalysisWindow = fpv.value.(*durationpb.Duration)
	case TsEntryStateAnomalyModelData_FieldPathSelectorModelData:
		(*target).ModelData = fpv.value.([]byte)
	case TsEntryStateAnomalyModelData_FieldPathSelectorTrainingMeanErr:
		(*target).TrainingMeanErr = fpv.value.([]float64)
	case TsEntryStateAnomalyModelData_FieldPathSelectorTrainingMaxErr:
		(*target).TrainingMaxErr = fpv.value.([]float64)
	case TsEntryStateAnomalyModelData_FieldPathSelectorTrainedInEpochs:
		(*target).TrainedInEpochs = fpv.value.(int32)
	case TsEntryStateAnomalyModelData_FieldPathSelectorTrainedIn:
		(*target).TrainedIn = fpv.value.(*durationpb.Duration)
	case TsEntryStateAnomalyModelData_FieldPathSelectorTrainAfter:
		(*target).TrainAfter = fpv.value.(*timestamppb.Timestamp)
	case TsEntryStateAnomalyModelData_FieldPathSelectorTrainingPeriod:
		(*target).TrainingPeriod = fpv.value.(*monitoring_common.TimeInterval)
	case TsEntryStateAnomalyModelData_FieldPathSelectorSensitiveness:
		(*target).Sensitiveness = fpv.value.([]*TsEntry_State_AnomalyModelSensitiveness)
	default:
		panic(fmt.Sprintf("Invalid selector for TsEntry_State_AnomalyModelData: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'TsEntryStateAnomalyModelData_FieldTerminalPathValue' with the value under path in 'TsEntry_State_AnomalyModelData'.
func (fpv *TsEntryStateAnomalyModelData_FieldTerminalPathValue) CompareWith(source *TsEntry_State_AnomalyModelData) (int, bool) {
	switch fpv.selector {
	case TsEntryStateAnomalyModelData_FieldPathSelectorAnalysisWindow:
		leftValue := fpv.value.(*durationpb.Duration)
		rightValue := source.GetAnalysisWindow()
		if leftValue == nil {
			if rightValue != nil {
				return -1, true
			}
			return 0, true
		}
		if rightValue == nil {
			return 1, true
		}
		if leftValue.AsDuration() == rightValue.AsDuration() {
			return 0, true
		} else if leftValue.AsDuration() < rightValue.AsDuration() {
			return -1, true
		} else {
			return 1, true
		}
	case TsEntryStateAnomalyModelData_FieldPathSelectorModelData:
		return 0, false
	case TsEntryStateAnomalyModelData_FieldPathSelectorTrainingMeanErr:
		return 0, false
	case TsEntryStateAnomalyModelData_FieldPathSelectorTrainingMaxErr:
		return 0, false
	case TsEntryStateAnomalyModelData_FieldPathSelectorTrainedInEpochs:
		leftValue := fpv.value.(int32)
		rightValue := source.GetTrainedInEpochs()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case TsEntryStateAnomalyModelData_FieldPathSelectorTrainedIn:
		leftValue := fpv.value.(*durationpb.Duration)
		rightValue := source.GetTrainedIn()
		if leftValue == nil {
			if rightValue != nil {
				return -1, true
			}
			return 0, true
		}
		if rightValue == nil {
			return 1, true
		}
		if leftValue.AsDuration() == rightValue.AsDuration() {
			return 0, true
		} else if leftValue.AsDuration() < rightValue.AsDuration() {
			return -1, true
		} else {
			return 1, true
		}
	case TsEntryStateAnomalyModelData_FieldPathSelectorTrainAfter:
		leftValue := fpv.value.(*timestamppb.Timestamp)
		rightValue := source.GetTrainAfter()
		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 TsEntryStateAnomalyModelData_FieldPathSelectorTrainingPeriod:
		return 0, false
	case TsEntryStateAnomalyModelData_FieldPathSelectorSensitiveness:
		return 0, false
	default:
		panic(fmt.Sprintf("Invalid selector for TsEntry_State_AnomalyModelData: %d", fpv.selector))
	}
}

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

type TsEntryStateAnomalyModelData_FieldSubPathValue struct {
	TsEntryStateAnomalyModelData_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ TsEntryStateAnomalyModelData_FieldPathValue = (*TsEntryStateAnomalyModelData_FieldSubPathValue)(nil)

func (fpvs *TsEntryStateAnomalyModelData_FieldSubPathValue) AsTrainingPeriodPathValue() (monitoring_common.TimeInterval_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(monitoring_common.TimeInterval_FieldPathValue)
	return res, ok
}
func (fpvs *TsEntryStateAnomalyModelData_FieldSubPathValue) AsSensitivenessPathValue() (TsEntryStateAnomalyModelSensitiveness_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(TsEntryStateAnomalyModelSensitiveness_FieldPathValue)
	return res, ok
}

func (fpvs *TsEntryStateAnomalyModelData_FieldSubPathValue) SetTo(target **TsEntry_State_AnomalyModelData) {
	if *target == nil {
		*target = new(TsEntry_State_AnomalyModelData)
	}
	switch fpvs.Selector() {
	case TsEntryStateAnomalyModelData_FieldPathSelectorTrainingPeriod:
		fpvs.subPathValue.(monitoring_common.TimeInterval_FieldPathValue).SetTo(&(*target).TrainingPeriod)
	case TsEntryStateAnomalyModelData_FieldPathSelectorSensitiveness:
		panic("FieldPath setter is unsupported for array subpaths")
	default:
		panic(fmt.Sprintf("Invalid selector for TsEntry_State_AnomalyModelData: %d", fpvs.Selector()))
	}
}

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

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

func (fpvs *TsEntryStateAnomalyModelData_FieldSubPathValue) CompareWith(source *TsEntry_State_AnomalyModelData) (int, bool) {
	switch fpvs.Selector() {
	case TsEntryStateAnomalyModelData_FieldPathSelectorTrainingPeriod:
		return fpvs.subPathValue.(monitoring_common.TimeInterval_FieldPathValue).CompareWith(source.GetTrainingPeriod())
	case TsEntryStateAnomalyModelData_FieldPathSelectorSensitiveness:
		return 0, false // repeated field
	default:
		panic(fmt.Sprintf("Invalid selector for TsEntry_State_AnomalyModelData: %d", fpvs.Selector()))
	}
}

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

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

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

func MustParseTsEntryStateAnomalyModelData_FieldPathArrayItemValue(pathStr, valueStr string) TsEntryStateAnomalyModelData_FieldPathArrayItemValue {
	fpaiv, err := ParseTsEntryStateAnomalyModelData_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type TsEntryStateAnomalyModelData_FieldTerminalPathArrayItemValue struct {
	TsEntryStateAnomalyModelData_FieldTerminalPath
	value interface{}
}

var _ TsEntryStateAnomalyModelData_FieldPathArrayItemValue = (*TsEntryStateAnomalyModelData_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object TsEntry_State_AnomalyModelData as interface{}
func (fpaiv *TsEntryStateAnomalyModelData_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}
func (fpaiv *TsEntryStateAnomalyModelData_FieldTerminalPathArrayItemValue) AsTrainingMeanErrItemValue() (float64, bool) {
	res, ok := fpaiv.value.(float64)
	return res, ok
}
func (fpaiv *TsEntryStateAnomalyModelData_FieldTerminalPathArrayItemValue) AsTrainingMaxErrItemValue() (float64, bool) {
	res, ok := fpaiv.value.(float64)
	return res, ok
}
func (fpaiv *TsEntryStateAnomalyModelData_FieldTerminalPathArrayItemValue) AsSensitivenessItemValue() (*TsEntry_State_AnomalyModelSensitiveness, bool) {
	res, ok := fpaiv.value.(*TsEntry_State_AnomalyModelSensitiveness)
	return res, ok
}

func (fpaiv *TsEntryStateAnomalyModelData_FieldTerminalPathArrayItemValue) GetSingle(source *TsEntry_State_AnomalyModelData) (interface{}, bool) {
	return nil, false
}

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

// Contains returns a boolean indicating if value that is being held is present in given 'AnomalyModelData'
func (fpaiv *TsEntryStateAnomalyModelData_FieldTerminalPathArrayItemValue) ContainsValue(source *TsEntry_State_AnomalyModelData) bool {
	slice := fpaiv.TsEntryStateAnomalyModelData_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 TsEntryStateAnomalyModelData_FieldSubPathArrayItemValue struct {
	TsEntryStateAnomalyModelData_FieldPath
	subPathItemValue gotenobject.FieldPathArrayItemValue
}

// GetRawValue returns stored array item value
func (fpaivs *TsEntryStateAnomalyModelData_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *TsEntryStateAnomalyModelData_FieldSubPathArrayItemValue) AsTrainingPeriodPathItemValue() (monitoring_common.TimeInterval_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(monitoring_common.TimeInterval_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *TsEntryStateAnomalyModelData_FieldSubPathArrayItemValue) AsSensitivenessPathItemValue() (TsEntryStateAnomalyModelSensitiveness_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(TsEntryStateAnomalyModelSensitiveness_FieldPathArrayItemValue)
	return res, ok
}

// Contains returns a boolean indicating if value that is being held is present in given 'AnomalyModelData'
func (fpaivs *TsEntryStateAnomalyModelData_FieldSubPathArrayItemValue) ContainsValue(source *TsEntry_State_AnomalyModelData) bool {
	switch fpaivs.Selector() {
	case TsEntryStateAnomalyModelData_FieldPathSelectorTrainingPeriod:
		return fpaivs.subPathItemValue.(monitoring_common.TimeInterval_FieldPathArrayItemValue).ContainsValue(source.GetTrainingPeriod())
	case TsEntryStateAnomalyModelData_FieldPathSelectorSensitiveness:
		return false // repeated/map field
	default:
		panic(fmt.Sprintf("Invalid selector for TsEntry_State_AnomalyModelData: %d", fpaivs.Selector()))
	}
}

// TsEntryStateAnomalyModelData_FieldPathArrayOfValues allows storing slice of values for AnomalyModelData fields according to their type
type TsEntryStateAnomalyModelData_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	TsEntryStateAnomalyModelData_FieldPath
}

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

func MustParseTsEntryStateAnomalyModelData_FieldPathArrayOfValues(pathStr, valuesStr string) TsEntryStateAnomalyModelData_FieldPathArrayOfValues {
	fpaov, err := ParseTsEntryStateAnomalyModelData_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type TsEntryStateAnomalyModelData_FieldTerminalPathArrayOfValues struct {
	TsEntryStateAnomalyModelData_FieldTerminalPath
	values interface{}
}

var _ TsEntryStateAnomalyModelData_FieldPathArrayOfValues = (*TsEntryStateAnomalyModelData_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *TsEntryStateAnomalyModelData_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case TsEntryStateAnomalyModelData_FieldPathSelectorAnalysisWindow:
		for _, v := range fpaov.values.([]*durationpb.Duration) {
			values = append(values, v)
		}
	case TsEntryStateAnomalyModelData_FieldPathSelectorModelData:
		for _, v := range fpaov.values.([][]byte) {
			values = append(values, v)
		}
	case TsEntryStateAnomalyModelData_FieldPathSelectorTrainingMeanErr:
		for _, v := range fpaov.values.([][]float64) {
			values = append(values, v)
		}
	case TsEntryStateAnomalyModelData_FieldPathSelectorTrainingMaxErr:
		for _, v := range fpaov.values.([][]float64) {
			values = append(values, v)
		}
	case TsEntryStateAnomalyModelData_FieldPathSelectorTrainedInEpochs:
		for _, v := range fpaov.values.([]int32) {
			values = append(values, v)
		}
	case TsEntryStateAnomalyModelData_FieldPathSelectorTrainedIn:
		for _, v := range fpaov.values.([]*durationpb.Duration) {
			values = append(values, v)
		}
	case TsEntryStateAnomalyModelData_FieldPathSelectorTrainAfter:
		for _, v := range fpaov.values.([]*timestamppb.Timestamp) {
			values = append(values, v)
		}
	case TsEntryStateAnomalyModelData_FieldPathSelectorTrainingPeriod:
		for _, v := range fpaov.values.([]*monitoring_common.TimeInterval) {
			values = append(values, v)
		}
	case TsEntryStateAnomalyModelData_FieldPathSelectorSensitiveness:
		for _, v := range fpaov.values.([][]*TsEntry_State_AnomalyModelSensitiveness) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *TsEntryStateAnomalyModelData_FieldTerminalPathArrayOfValues) AsAnalysisWindowArrayOfValues() ([]*durationpb.Duration, bool) {
	res, ok := fpaov.values.([]*durationpb.Duration)
	return res, ok
}
func (fpaov *TsEntryStateAnomalyModelData_FieldTerminalPathArrayOfValues) AsModelDataArrayOfValues() ([][]byte, bool) {
	res, ok := fpaov.values.([][]byte)
	return res, ok
}
func (fpaov *TsEntryStateAnomalyModelData_FieldTerminalPathArrayOfValues) AsTrainingMeanErrArrayOfValues() ([][]float64, bool) {
	res, ok := fpaov.values.([][]float64)
	return res, ok
}
func (fpaov *TsEntryStateAnomalyModelData_FieldTerminalPathArrayOfValues) AsTrainingMaxErrArrayOfValues() ([][]float64, bool) {
	res, ok := fpaov.values.([][]float64)
	return res, ok
}
func (fpaov *TsEntryStateAnomalyModelData_FieldTerminalPathArrayOfValues) AsTrainedInEpochsArrayOfValues() ([]int32, bool) {
	res, ok := fpaov.values.([]int32)
	return res, ok
}
func (fpaov *TsEntryStateAnomalyModelData_FieldTerminalPathArrayOfValues) AsTrainedInArrayOfValues() ([]*durationpb.Duration, bool) {
	res, ok := fpaov.values.([]*durationpb.Duration)
	return res, ok
}
func (fpaov *TsEntryStateAnomalyModelData_FieldTerminalPathArrayOfValues) AsTrainAfterArrayOfValues() ([]*timestamppb.Timestamp, bool) {
	res, ok := fpaov.values.([]*timestamppb.Timestamp)
	return res, ok
}
func (fpaov *TsEntryStateAnomalyModelData_FieldTerminalPathArrayOfValues) AsTrainingPeriodArrayOfValues() ([]*monitoring_common.TimeInterval, bool) {
	res, ok := fpaov.values.([]*monitoring_common.TimeInterval)
	return res, ok
}
func (fpaov *TsEntryStateAnomalyModelData_FieldTerminalPathArrayOfValues) AsSensitivenessArrayOfValues() ([][]*TsEntry_State_AnomalyModelSensitiveness, bool) {
	res, ok := fpaov.values.([][]*TsEntry_State_AnomalyModelSensitiveness)
	return res, ok
}

type TsEntryStateAnomalyModelData_FieldSubPathArrayOfValues struct {
	TsEntryStateAnomalyModelData_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ TsEntryStateAnomalyModelData_FieldPathArrayOfValues = (*TsEntryStateAnomalyModelData_FieldSubPathArrayOfValues)(nil)

func (fpsaov *TsEntryStateAnomalyModelData_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *TsEntryStateAnomalyModelData_FieldSubPathArrayOfValues) AsTrainingPeriodPathArrayOfValues() (monitoring_common.TimeInterval_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(monitoring_common.TimeInterval_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *TsEntryStateAnomalyModelData_FieldSubPathArrayOfValues) AsSensitivenessPathArrayOfValues() (TsEntryStateAnomalyModelSensitiveness_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(TsEntryStateAnomalyModelSensitiveness_FieldPathArrayOfValues)
	return res, ok
}

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

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

type TsEntryStateAnomalyModelSensitiveness_FieldPathSelector int32

const (
	TsEntryStateAnomalyModelSensitiveness_FieldPathSelectorQueryName        TsEntryStateAnomalyModelSensitiveness_FieldPathSelector = 0
	TsEntryStateAnomalyModelSensitiveness_FieldPathSelectorAnomalyThreshold TsEntryStateAnomalyModelSensitiveness_FieldPathSelector = 1
)

func (s TsEntryStateAnomalyModelSensitiveness_FieldPathSelector) String() string {
	switch s {
	case TsEntryStateAnomalyModelSensitiveness_FieldPathSelectorQueryName:
		return "query_name"
	case TsEntryStateAnomalyModelSensitiveness_FieldPathSelectorAnomalyThreshold:
		return "anomaly_threshold"
	default:
		panic(fmt.Sprintf("Invalid selector for TsEntry_State_AnomalyModelSensitiveness: %d", s))
	}
}

func BuildTsEntryStateAnomalyModelSensitiveness_FieldPath(fp gotenobject.RawFieldPath) (TsEntryStateAnomalyModelSensitiveness_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object TsEntry_State_AnomalyModelSensitiveness")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "query_name", "queryName", "query-name":
			return &TsEntryStateAnomalyModelSensitiveness_FieldTerminalPath{selector: TsEntryStateAnomalyModelSensitiveness_FieldPathSelectorQueryName}, nil
		case "anomaly_threshold", "anomalyThreshold", "anomaly-threshold":
			return &TsEntryStateAnomalyModelSensitiveness_FieldTerminalPath{selector: TsEntryStateAnomalyModelSensitiveness_FieldPathSelectorAnomalyThreshold}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object TsEntry_State_AnomalyModelSensitiveness", fp)
}

func ParseTsEntryStateAnomalyModelSensitiveness_FieldPath(rawField string) (TsEntryStateAnomalyModelSensitiveness_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildTsEntryStateAnomalyModelSensitiveness_FieldPath(fp)
}

func MustParseTsEntryStateAnomalyModelSensitiveness_FieldPath(rawField string) TsEntryStateAnomalyModelSensitiveness_FieldPath {
	fp, err := ParseTsEntryStateAnomalyModelSensitiveness_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type TsEntryStateAnomalyModelSensitiveness_FieldTerminalPath struct {
	selector TsEntryStateAnomalyModelSensitiveness_FieldPathSelector
}

var _ TsEntryStateAnomalyModelSensitiveness_FieldPath = (*TsEntryStateAnomalyModelSensitiveness_FieldTerminalPath)(nil)

func (fp *TsEntryStateAnomalyModelSensitiveness_FieldTerminalPath) Selector() TsEntryStateAnomalyModelSensitiveness_FieldPathSelector {
	return fp.selector
}

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

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

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

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

// GetSingle returns value pointed by specific field of from source TsEntry_State_AnomalyModelSensitiveness
func (fp *TsEntryStateAnomalyModelSensitiveness_FieldTerminalPath) GetSingle(source *TsEntry_State_AnomalyModelSensitiveness) (interface{}, bool) {
	switch fp.selector {
	case TsEntryStateAnomalyModelSensitiveness_FieldPathSelectorQueryName:
		return source.GetQueryName(), source != nil
	case TsEntryStateAnomalyModelSensitiveness_FieldPathSelectorAnomalyThreshold:
		return source.GetAnomalyThreshold(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for TsEntry_State_AnomalyModelSensitiveness: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *TsEntryStateAnomalyModelSensitiveness_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case TsEntryStateAnomalyModelSensitiveness_FieldPathSelectorQueryName:
		return ""
	case TsEntryStateAnomalyModelSensitiveness_FieldPathSelectorAnomalyThreshold:
		return float64(0)
	default:
		panic(fmt.Sprintf("Invalid selector for TsEntry_State_AnomalyModelSensitiveness: %d", fp.selector))
	}
}

func (fp *TsEntryStateAnomalyModelSensitiveness_FieldTerminalPath) ClearValue(item *TsEntry_State_AnomalyModelSensitiveness) {
	if item != nil {
		switch fp.selector {
		case TsEntryStateAnomalyModelSensitiveness_FieldPathSelectorQueryName:
			item.QueryName = ""
		case TsEntryStateAnomalyModelSensitiveness_FieldPathSelectorAnomalyThreshold:
			item.AnomalyThreshold = float64(0)
		default:
			panic(fmt.Sprintf("Invalid selector for TsEntry_State_AnomalyModelSensitiveness: %d", fp.selector))
		}
	}
}

func (fp *TsEntryStateAnomalyModelSensitiveness_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*TsEntry_State_AnomalyModelSensitiveness))
}

// IsLeaf - whether field path is holds simple value
func (fp *TsEntryStateAnomalyModelSensitiveness_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == TsEntryStateAnomalyModelSensitiveness_FieldPathSelectorQueryName ||
		fp.selector == TsEntryStateAnomalyModelSensitiveness_FieldPathSelectorAnomalyThreshold
}

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

func (fp *TsEntryStateAnomalyModelSensitiveness_FieldTerminalPath) WithIValue(value interface{}) TsEntryStateAnomalyModelSensitiveness_FieldPathValue {
	switch fp.selector {
	case TsEntryStateAnomalyModelSensitiveness_FieldPathSelectorQueryName:
		return &TsEntryStateAnomalyModelSensitiveness_FieldTerminalPathValue{TsEntryStateAnomalyModelSensitiveness_FieldTerminalPath: *fp, value: value.(string)}
	case TsEntryStateAnomalyModelSensitiveness_FieldPathSelectorAnomalyThreshold:
		return &TsEntryStateAnomalyModelSensitiveness_FieldTerminalPathValue{TsEntryStateAnomalyModelSensitiveness_FieldTerminalPath: *fp, value: value.(float64)}
	default:
		panic(fmt.Sprintf("Invalid selector for TsEntry_State_AnomalyModelSensitiveness: %d", fp.selector))
	}
}

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

func (fp *TsEntryStateAnomalyModelSensitiveness_FieldTerminalPath) WithIArrayOfValues(values interface{}) TsEntryStateAnomalyModelSensitiveness_FieldPathArrayOfValues {
	fpaov := &TsEntryStateAnomalyModelSensitiveness_FieldTerminalPathArrayOfValues{TsEntryStateAnomalyModelSensitiveness_FieldTerminalPath: *fp}
	switch fp.selector {
	case TsEntryStateAnomalyModelSensitiveness_FieldPathSelectorQueryName:
		return &TsEntryStateAnomalyModelSensitiveness_FieldTerminalPathArrayOfValues{TsEntryStateAnomalyModelSensitiveness_FieldTerminalPath: *fp, values: values.([]string)}
	case TsEntryStateAnomalyModelSensitiveness_FieldPathSelectorAnomalyThreshold:
		return &TsEntryStateAnomalyModelSensitiveness_FieldTerminalPathArrayOfValues{TsEntryStateAnomalyModelSensitiveness_FieldTerminalPath: *fp, values: values.([]float64)}
	default:
		panic(fmt.Sprintf("Invalid selector for TsEntry_State_AnomalyModelSensitiveness: %d", fp.selector))
	}
	return fpaov
}

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

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

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

// TsEntryStateAnomalyModelSensitiveness_FieldPathValue allows storing values for AnomalyModelSensitiveness fields according to their type
type TsEntryStateAnomalyModelSensitiveness_FieldPathValue interface {
	TsEntryStateAnomalyModelSensitiveness_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **TsEntry_State_AnomalyModelSensitiveness)
	CompareWith(*TsEntry_State_AnomalyModelSensitiveness) (cmp int, comparable bool)
}

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

func MustParseTsEntryStateAnomalyModelSensitiveness_FieldPathValue(pathStr, valueStr string) TsEntryStateAnomalyModelSensitiveness_FieldPathValue {
	fpv, err := ParseTsEntryStateAnomalyModelSensitiveness_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type TsEntryStateAnomalyModelSensitiveness_FieldTerminalPathValue struct {
	TsEntryStateAnomalyModelSensitiveness_FieldTerminalPath
	value interface{}
}

var _ TsEntryStateAnomalyModelSensitiveness_FieldPathValue = (*TsEntryStateAnomalyModelSensitiveness_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'AnomalyModelSensitiveness' as interface{}
func (fpv *TsEntryStateAnomalyModelSensitiveness_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *TsEntryStateAnomalyModelSensitiveness_FieldTerminalPathValue) AsQueryNameValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *TsEntryStateAnomalyModelSensitiveness_FieldTerminalPathValue) AsAnomalyThresholdValue() (float64, bool) {
	res, ok := fpv.value.(float64)
	return res, ok
}

// SetTo stores value for selected field for object AnomalyModelSensitiveness
func (fpv *TsEntryStateAnomalyModelSensitiveness_FieldTerminalPathValue) SetTo(target **TsEntry_State_AnomalyModelSensitiveness) {
	if *target == nil {
		*target = new(TsEntry_State_AnomalyModelSensitiveness)
	}
	switch fpv.selector {
	case TsEntryStateAnomalyModelSensitiveness_FieldPathSelectorQueryName:
		(*target).QueryName = fpv.value.(string)
	case TsEntryStateAnomalyModelSensitiveness_FieldPathSelectorAnomalyThreshold:
		(*target).AnomalyThreshold = fpv.value.(float64)
	default:
		panic(fmt.Sprintf("Invalid selector for TsEntry_State_AnomalyModelSensitiveness: %d", fpv.selector))
	}
}

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

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

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

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

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

func MustParseTsEntryStateAnomalyModelSensitiveness_FieldPathArrayItemValue(pathStr, valueStr string) TsEntryStateAnomalyModelSensitiveness_FieldPathArrayItemValue {
	fpaiv, err := ParseTsEntryStateAnomalyModelSensitiveness_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type TsEntryStateAnomalyModelSensitiveness_FieldTerminalPathArrayItemValue struct {
	TsEntryStateAnomalyModelSensitiveness_FieldTerminalPath
	value interface{}
}

var _ TsEntryStateAnomalyModelSensitiveness_FieldPathArrayItemValue = (*TsEntryStateAnomalyModelSensitiveness_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *TsEntryStateAnomalyModelSensitiveness_FieldTerminalPathArrayItemValue) GetSingle(source *TsEntry_State_AnomalyModelSensitiveness) (interface{}, bool) {
	return nil, false
}

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

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

// TsEntryStateAnomalyModelSensitiveness_FieldPathArrayOfValues allows storing slice of values for AnomalyModelSensitiveness fields according to their type
type TsEntryStateAnomalyModelSensitiveness_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	TsEntryStateAnomalyModelSensitiveness_FieldPath
}

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

func MustParseTsEntryStateAnomalyModelSensitiveness_FieldPathArrayOfValues(pathStr, valuesStr string) TsEntryStateAnomalyModelSensitiveness_FieldPathArrayOfValues {
	fpaov, err := ParseTsEntryStateAnomalyModelSensitiveness_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type TsEntryStateAnomalyModelSensitiveness_FieldTerminalPathArrayOfValues struct {
	TsEntryStateAnomalyModelSensitiveness_FieldTerminalPath
	values interface{}
}

var _ TsEntryStateAnomalyModelSensitiveness_FieldPathArrayOfValues = (*TsEntryStateAnomalyModelSensitiveness_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *TsEntryStateAnomalyModelSensitiveness_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case TsEntryStateAnomalyModelSensitiveness_FieldPathSelectorQueryName:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case TsEntryStateAnomalyModelSensitiveness_FieldPathSelectorAnomalyThreshold:
		for _, v := range fpaov.values.([]float64) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *TsEntryStateAnomalyModelSensitiveness_FieldTerminalPathArrayOfValues) AsQueryNameArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *TsEntryStateAnomalyModelSensitiveness_FieldTerminalPathArrayOfValues) AsAnomalyThresholdArrayOfValues() ([]float64, bool) {
	res, ok := fpaov.values.([]float64)
	return res, ok
}

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

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

type TsEntryStateAdaptiveThresholdInfo_FieldPathSelector int32

const (
	TsEntryStateAdaptiveThresholdInfo_FieldPathSelectorQueryName TsEntryStateAdaptiveThresholdInfo_FieldPathSelector = 0
	TsEntryStateAdaptiveThresholdInfo_FieldPathSelectorLower     TsEntryStateAdaptiveThresholdInfo_FieldPathSelector = 1
	TsEntryStateAdaptiveThresholdInfo_FieldPathSelectorUpper     TsEntryStateAdaptiveThresholdInfo_FieldPathSelector = 2
	TsEntryStateAdaptiveThresholdInfo_FieldPathSelectorNextCheck TsEntryStateAdaptiveThresholdInfo_FieldPathSelector = 3
)

func (s TsEntryStateAdaptiveThresholdInfo_FieldPathSelector) String() string {
	switch s {
	case TsEntryStateAdaptiveThresholdInfo_FieldPathSelectorQueryName:
		return "query_name"
	case TsEntryStateAdaptiveThresholdInfo_FieldPathSelectorLower:
		return "lower"
	case TsEntryStateAdaptiveThresholdInfo_FieldPathSelectorUpper:
		return "upper"
	case TsEntryStateAdaptiveThresholdInfo_FieldPathSelectorNextCheck:
		return "next_check"
	default:
		panic(fmt.Sprintf("Invalid selector for TsEntry_State_AdaptiveThresholdInfo: %d", s))
	}
}

func BuildTsEntryStateAdaptiveThresholdInfo_FieldPath(fp gotenobject.RawFieldPath) (TsEntryStateAdaptiveThresholdInfo_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object TsEntry_State_AdaptiveThresholdInfo")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "query_name", "queryName", "query-name":
			return &TsEntryStateAdaptiveThresholdInfo_FieldTerminalPath{selector: TsEntryStateAdaptiveThresholdInfo_FieldPathSelectorQueryName}, nil
		case "lower":
			return &TsEntryStateAdaptiveThresholdInfo_FieldTerminalPath{selector: TsEntryStateAdaptiveThresholdInfo_FieldPathSelectorLower}, nil
		case "upper":
			return &TsEntryStateAdaptiveThresholdInfo_FieldTerminalPath{selector: TsEntryStateAdaptiveThresholdInfo_FieldPathSelectorUpper}, nil
		case "next_check", "nextCheck", "next-check":
			return &TsEntryStateAdaptiveThresholdInfo_FieldTerminalPath{selector: TsEntryStateAdaptiveThresholdInfo_FieldPathSelectorNextCheck}, nil
		}
	} else {
		switch fp[0] {
		case "lower":
			if subpath, err := rcommon.BuildAlertingThreshold_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &TsEntryStateAdaptiveThresholdInfo_FieldSubPath{selector: TsEntryStateAdaptiveThresholdInfo_FieldPathSelectorLower, subPath: subpath}, nil
			}
		case "upper":
			if subpath, err := rcommon.BuildAlertingThreshold_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &TsEntryStateAdaptiveThresholdInfo_FieldSubPath{selector: TsEntryStateAdaptiveThresholdInfo_FieldPathSelectorUpper, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object TsEntry_State_AdaptiveThresholdInfo", fp)
}

func ParseTsEntryStateAdaptiveThresholdInfo_FieldPath(rawField string) (TsEntryStateAdaptiveThresholdInfo_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildTsEntryStateAdaptiveThresholdInfo_FieldPath(fp)
}

func MustParseTsEntryStateAdaptiveThresholdInfo_FieldPath(rawField string) TsEntryStateAdaptiveThresholdInfo_FieldPath {
	fp, err := ParseTsEntryStateAdaptiveThresholdInfo_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type TsEntryStateAdaptiveThresholdInfo_FieldTerminalPath struct {
	selector TsEntryStateAdaptiveThresholdInfo_FieldPathSelector
}

var _ TsEntryStateAdaptiveThresholdInfo_FieldPath = (*TsEntryStateAdaptiveThresholdInfo_FieldTerminalPath)(nil)

func (fp *TsEntryStateAdaptiveThresholdInfo_FieldTerminalPath) Selector() TsEntryStateAdaptiveThresholdInfo_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source TsEntry_State_AdaptiveThresholdInfo
func (fp *TsEntryStateAdaptiveThresholdInfo_FieldTerminalPath) Get(source *TsEntry_State_AdaptiveThresholdInfo) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case TsEntryStateAdaptiveThresholdInfo_FieldPathSelectorQueryName:
			values = append(values, source.QueryName)
		case TsEntryStateAdaptiveThresholdInfo_FieldPathSelectorLower:
			if source.Lower != nil {
				values = append(values, source.Lower)
			}
		case TsEntryStateAdaptiveThresholdInfo_FieldPathSelectorUpper:
			if source.Upper != nil {
				values = append(values, source.Upper)
			}
		case TsEntryStateAdaptiveThresholdInfo_FieldPathSelectorNextCheck:
			if source.NextCheck != nil {
				values = append(values, source.NextCheck)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for TsEntry_State_AdaptiveThresholdInfo: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source TsEntry_State_AdaptiveThresholdInfo
func (fp *TsEntryStateAdaptiveThresholdInfo_FieldTerminalPath) GetSingle(source *TsEntry_State_AdaptiveThresholdInfo) (interface{}, bool) {
	switch fp.selector {
	case TsEntryStateAdaptiveThresholdInfo_FieldPathSelectorQueryName:
		return source.GetQueryName(), source != nil
	case TsEntryStateAdaptiveThresholdInfo_FieldPathSelectorLower:
		res := source.GetLower()
		return res, res != nil
	case TsEntryStateAdaptiveThresholdInfo_FieldPathSelectorUpper:
		res := source.GetUpper()
		return res, res != nil
	case TsEntryStateAdaptiveThresholdInfo_FieldPathSelectorNextCheck:
		res := source.GetNextCheck()
		return res, res != nil
	default:
		panic(fmt.Sprintf("Invalid selector for TsEntry_State_AdaptiveThresholdInfo: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *TsEntryStateAdaptiveThresholdInfo_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case TsEntryStateAdaptiveThresholdInfo_FieldPathSelectorQueryName:
		return ""
	case TsEntryStateAdaptiveThresholdInfo_FieldPathSelectorLower:
		return (*rcommon.AlertingThreshold)(nil)
	case TsEntryStateAdaptiveThresholdInfo_FieldPathSelectorUpper:
		return (*rcommon.AlertingThreshold)(nil)
	case TsEntryStateAdaptiveThresholdInfo_FieldPathSelectorNextCheck:
		return (*timestamppb.Timestamp)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for TsEntry_State_AdaptiveThresholdInfo: %d", fp.selector))
	}
}

func (fp *TsEntryStateAdaptiveThresholdInfo_FieldTerminalPath) ClearValue(item *TsEntry_State_AdaptiveThresholdInfo) {
	if item != nil {
		switch fp.selector {
		case TsEntryStateAdaptiveThresholdInfo_FieldPathSelectorQueryName:
			item.QueryName = ""
		case TsEntryStateAdaptiveThresholdInfo_FieldPathSelectorLower:
			item.Lower = nil
		case TsEntryStateAdaptiveThresholdInfo_FieldPathSelectorUpper:
			item.Upper = nil
		case TsEntryStateAdaptiveThresholdInfo_FieldPathSelectorNextCheck:
			item.NextCheck = nil
		default:
			panic(fmt.Sprintf("Invalid selector for TsEntry_State_AdaptiveThresholdInfo: %d", fp.selector))
		}
	}
}

func (fp *TsEntryStateAdaptiveThresholdInfo_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*TsEntry_State_AdaptiveThresholdInfo))
}

// IsLeaf - whether field path is holds simple value
func (fp *TsEntryStateAdaptiveThresholdInfo_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == TsEntryStateAdaptiveThresholdInfo_FieldPathSelectorQueryName ||
		fp.selector == TsEntryStateAdaptiveThresholdInfo_FieldPathSelectorNextCheck
}

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

func (fp *TsEntryStateAdaptiveThresholdInfo_FieldTerminalPath) WithIValue(value interface{}) TsEntryStateAdaptiveThresholdInfo_FieldPathValue {
	switch fp.selector {
	case TsEntryStateAdaptiveThresholdInfo_FieldPathSelectorQueryName:
		return &TsEntryStateAdaptiveThresholdInfo_FieldTerminalPathValue{TsEntryStateAdaptiveThresholdInfo_FieldTerminalPath: *fp, value: value.(string)}
	case TsEntryStateAdaptiveThresholdInfo_FieldPathSelectorLower:
		return &TsEntryStateAdaptiveThresholdInfo_FieldTerminalPathValue{TsEntryStateAdaptiveThresholdInfo_FieldTerminalPath: *fp, value: value.(*rcommon.AlertingThreshold)}
	case TsEntryStateAdaptiveThresholdInfo_FieldPathSelectorUpper:
		return &TsEntryStateAdaptiveThresholdInfo_FieldTerminalPathValue{TsEntryStateAdaptiveThresholdInfo_FieldTerminalPath: *fp, value: value.(*rcommon.AlertingThreshold)}
	case TsEntryStateAdaptiveThresholdInfo_FieldPathSelectorNextCheck:
		return &TsEntryStateAdaptiveThresholdInfo_FieldTerminalPathValue{TsEntryStateAdaptiveThresholdInfo_FieldTerminalPath: *fp, value: value.(*timestamppb.Timestamp)}
	default:
		panic(fmt.Sprintf("Invalid selector for TsEntry_State_AdaptiveThresholdInfo: %d", fp.selector))
	}
}

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

func (fp *TsEntryStateAdaptiveThresholdInfo_FieldTerminalPath) WithIArrayOfValues(values interface{}) TsEntryStateAdaptiveThresholdInfo_FieldPathArrayOfValues {
	fpaov := &TsEntryStateAdaptiveThresholdInfo_FieldTerminalPathArrayOfValues{TsEntryStateAdaptiveThresholdInfo_FieldTerminalPath: *fp}
	switch fp.selector {
	case TsEntryStateAdaptiveThresholdInfo_FieldPathSelectorQueryName:
		return &TsEntryStateAdaptiveThresholdInfo_FieldTerminalPathArrayOfValues{TsEntryStateAdaptiveThresholdInfo_FieldTerminalPath: *fp, values: values.([]string)}
	case TsEntryStateAdaptiveThresholdInfo_FieldPathSelectorLower:
		return &TsEntryStateAdaptiveThresholdInfo_FieldTerminalPathArrayOfValues{TsEntryStateAdaptiveThresholdInfo_FieldTerminalPath: *fp, values: values.([]*rcommon.AlertingThreshold)}
	case TsEntryStateAdaptiveThresholdInfo_FieldPathSelectorUpper:
		return &TsEntryStateAdaptiveThresholdInfo_FieldTerminalPathArrayOfValues{TsEntryStateAdaptiveThresholdInfo_FieldTerminalPath: *fp, values: values.([]*rcommon.AlertingThreshold)}
	case TsEntryStateAdaptiveThresholdInfo_FieldPathSelectorNextCheck:
		return &TsEntryStateAdaptiveThresholdInfo_FieldTerminalPathArrayOfValues{TsEntryStateAdaptiveThresholdInfo_FieldTerminalPath: *fp, values: values.([]*timestamppb.Timestamp)}
	default:
		panic(fmt.Sprintf("Invalid selector for TsEntry_State_AdaptiveThresholdInfo: %d", fp.selector))
	}
	return fpaov
}

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

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

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

type TsEntryStateAdaptiveThresholdInfo_FieldSubPath struct {
	selector TsEntryStateAdaptiveThresholdInfo_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ TsEntryStateAdaptiveThresholdInfo_FieldPath = (*TsEntryStateAdaptiveThresholdInfo_FieldSubPath)(nil)

func (fps *TsEntryStateAdaptiveThresholdInfo_FieldSubPath) Selector() TsEntryStateAdaptiveThresholdInfo_FieldPathSelector {
	return fps.selector
}
func (fps *TsEntryStateAdaptiveThresholdInfo_FieldSubPath) AsLowerSubPath() (rcommon.AlertingThreshold_FieldPath, bool) {
	res, ok := fps.subPath.(rcommon.AlertingThreshold_FieldPath)
	return res, ok
}
func (fps *TsEntryStateAdaptiveThresholdInfo_FieldSubPath) AsUpperSubPath() (rcommon.AlertingThreshold_FieldPath, bool) {
	res, ok := fps.subPath.(rcommon.AlertingThreshold_FieldPath)
	return res, ok
}

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

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

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

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

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

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

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

func (fps *TsEntryStateAdaptiveThresholdInfo_FieldSubPath) ClearValue(item *TsEntry_State_AdaptiveThresholdInfo) {
	if item != nil {
		switch fps.selector {
		case TsEntryStateAdaptiveThresholdInfo_FieldPathSelectorLower:
			fps.subPath.ClearValueRaw(item.Lower)
		case TsEntryStateAdaptiveThresholdInfo_FieldPathSelectorUpper:
			fps.subPath.ClearValueRaw(item.Upper)
		default:
			panic(fmt.Sprintf("Invalid selector for TsEntry_State_AdaptiveThresholdInfo: %d", fps.selector))
		}
	}
}

func (fps *TsEntryStateAdaptiveThresholdInfo_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*TsEntry_State_AdaptiveThresholdInfo))
}

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

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

func (fps *TsEntryStateAdaptiveThresholdInfo_FieldSubPath) WithIValue(value interface{}) TsEntryStateAdaptiveThresholdInfo_FieldPathValue {
	return &TsEntryStateAdaptiveThresholdInfo_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *TsEntryStateAdaptiveThresholdInfo_FieldSubPath) WithIArrayOfValues(values interface{}) TsEntryStateAdaptiveThresholdInfo_FieldPathArrayOfValues {
	return &TsEntryStateAdaptiveThresholdInfo_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *TsEntryStateAdaptiveThresholdInfo_FieldSubPath) WithIArrayItemValue(value interface{}) TsEntryStateAdaptiveThresholdInfo_FieldPathArrayItemValue {
	return &TsEntryStateAdaptiveThresholdInfo_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

// TsEntryStateAdaptiveThresholdInfo_FieldPathValue allows storing values for AdaptiveThresholdInfo fields according to their type
type TsEntryStateAdaptiveThresholdInfo_FieldPathValue interface {
	TsEntryStateAdaptiveThresholdInfo_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **TsEntry_State_AdaptiveThresholdInfo)
	CompareWith(*TsEntry_State_AdaptiveThresholdInfo) (cmp int, comparable bool)
}

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

func MustParseTsEntryStateAdaptiveThresholdInfo_FieldPathValue(pathStr, valueStr string) TsEntryStateAdaptiveThresholdInfo_FieldPathValue {
	fpv, err := ParseTsEntryStateAdaptiveThresholdInfo_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type TsEntryStateAdaptiveThresholdInfo_FieldTerminalPathValue struct {
	TsEntryStateAdaptiveThresholdInfo_FieldTerminalPath
	value interface{}
}

var _ TsEntryStateAdaptiveThresholdInfo_FieldPathValue = (*TsEntryStateAdaptiveThresholdInfo_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'AdaptiveThresholdInfo' as interface{}
func (fpv *TsEntryStateAdaptiveThresholdInfo_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *TsEntryStateAdaptiveThresholdInfo_FieldTerminalPathValue) AsQueryNameValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *TsEntryStateAdaptiveThresholdInfo_FieldTerminalPathValue) AsLowerValue() (*rcommon.AlertingThreshold, bool) {
	res, ok := fpv.value.(*rcommon.AlertingThreshold)
	return res, ok
}
func (fpv *TsEntryStateAdaptiveThresholdInfo_FieldTerminalPathValue) AsUpperValue() (*rcommon.AlertingThreshold, bool) {
	res, ok := fpv.value.(*rcommon.AlertingThreshold)
	return res, ok
}
func (fpv *TsEntryStateAdaptiveThresholdInfo_FieldTerminalPathValue) AsNextCheckValue() (*timestamppb.Timestamp, bool) {
	res, ok := fpv.value.(*timestamppb.Timestamp)
	return res, ok
}

// SetTo stores value for selected field for object AdaptiveThresholdInfo
func (fpv *TsEntryStateAdaptiveThresholdInfo_FieldTerminalPathValue) SetTo(target **TsEntry_State_AdaptiveThresholdInfo) {
	if *target == nil {
		*target = new(TsEntry_State_AdaptiveThresholdInfo)
	}
	switch fpv.selector {
	case TsEntryStateAdaptiveThresholdInfo_FieldPathSelectorQueryName:
		(*target).QueryName = fpv.value.(string)
	case TsEntryStateAdaptiveThresholdInfo_FieldPathSelectorLower:
		(*target).Lower = fpv.value.(*rcommon.AlertingThreshold)
	case TsEntryStateAdaptiveThresholdInfo_FieldPathSelectorUpper:
		(*target).Upper = fpv.value.(*rcommon.AlertingThreshold)
	case TsEntryStateAdaptiveThresholdInfo_FieldPathSelectorNextCheck:
		(*target).NextCheck = fpv.value.(*timestamppb.Timestamp)
	default:
		panic(fmt.Sprintf("Invalid selector for TsEntry_State_AdaptiveThresholdInfo: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'TsEntryStateAdaptiveThresholdInfo_FieldTerminalPathValue' with the value under path in 'TsEntry_State_AdaptiveThresholdInfo'.
func (fpv *TsEntryStateAdaptiveThresholdInfo_FieldTerminalPathValue) CompareWith(source *TsEntry_State_AdaptiveThresholdInfo) (int, bool) {
	switch fpv.selector {
	case TsEntryStateAdaptiveThresholdInfo_FieldPathSelectorQueryName:
		leftValue := fpv.value.(string)
		rightValue := source.GetQueryName()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case TsEntryStateAdaptiveThresholdInfo_FieldPathSelectorLower:
		return 0, false
	case TsEntryStateAdaptiveThresholdInfo_FieldPathSelectorUpper:
		return 0, false
	case TsEntryStateAdaptiveThresholdInfo_FieldPathSelectorNextCheck:
		leftValue := fpv.value.(*timestamppb.Timestamp)
		rightValue := source.GetNextCheck()
		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 TsEntry_State_AdaptiveThresholdInfo: %d", fpv.selector))
	}
}

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

type TsEntryStateAdaptiveThresholdInfo_FieldSubPathValue struct {
	TsEntryStateAdaptiveThresholdInfo_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ TsEntryStateAdaptiveThresholdInfo_FieldPathValue = (*TsEntryStateAdaptiveThresholdInfo_FieldSubPathValue)(nil)

func (fpvs *TsEntryStateAdaptiveThresholdInfo_FieldSubPathValue) AsLowerPathValue() (rcommon.AlertingThreshold_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(rcommon.AlertingThreshold_FieldPathValue)
	return res, ok
}
func (fpvs *TsEntryStateAdaptiveThresholdInfo_FieldSubPathValue) AsUpperPathValue() (rcommon.AlertingThreshold_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(rcommon.AlertingThreshold_FieldPathValue)
	return res, ok
}

func (fpvs *TsEntryStateAdaptiveThresholdInfo_FieldSubPathValue) SetTo(target **TsEntry_State_AdaptiveThresholdInfo) {
	if *target == nil {
		*target = new(TsEntry_State_AdaptiveThresholdInfo)
	}
	switch fpvs.Selector() {
	case TsEntryStateAdaptiveThresholdInfo_FieldPathSelectorLower:
		fpvs.subPathValue.(rcommon.AlertingThreshold_FieldPathValue).SetTo(&(*target).Lower)
	case TsEntryStateAdaptiveThresholdInfo_FieldPathSelectorUpper:
		fpvs.subPathValue.(rcommon.AlertingThreshold_FieldPathValue).SetTo(&(*target).Upper)
	default:
		panic(fmt.Sprintf("Invalid selector for TsEntry_State_AdaptiveThresholdInfo: %d", fpvs.Selector()))
	}
}

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

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

func (fpvs *TsEntryStateAdaptiveThresholdInfo_FieldSubPathValue) CompareWith(source *TsEntry_State_AdaptiveThresholdInfo) (int, bool) {
	switch fpvs.Selector() {
	case TsEntryStateAdaptiveThresholdInfo_FieldPathSelectorLower:
		return fpvs.subPathValue.(rcommon.AlertingThreshold_FieldPathValue).CompareWith(source.GetLower())
	case TsEntryStateAdaptiveThresholdInfo_FieldPathSelectorUpper:
		return fpvs.subPathValue.(rcommon.AlertingThreshold_FieldPathValue).CompareWith(source.GetUpper())
	default:
		panic(fmt.Sprintf("Invalid selector for TsEntry_State_AdaptiveThresholdInfo: %d", fpvs.Selector()))
	}
}

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

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

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

func MustParseTsEntryStateAdaptiveThresholdInfo_FieldPathArrayItemValue(pathStr, valueStr string) TsEntryStateAdaptiveThresholdInfo_FieldPathArrayItemValue {
	fpaiv, err := ParseTsEntryStateAdaptiveThresholdInfo_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type TsEntryStateAdaptiveThresholdInfo_FieldTerminalPathArrayItemValue struct {
	TsEntryStateAdaptiveThresholdInfo_FieldTerminalPath
	value interface{}
}

var _ TsEntryStateAdaptiveThresholdInfo_FieldPathArrayItemValue = (*TsEntryStateAdaptiveThresholdInfo_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *TsEntryStateAdaptiveThresholdInfo_FieldTerminalPathArrayItemValue) GetSingle(source *TsEntry_State_AdaptiveThresholdInfo) (interface{}, bool) {
	return nil, false
}

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

// Contains returns a boolean indicating if value that is being held is present in given 'AdaptiveThresholdInfo'
func (fpaiv *TsEntryStateAdaptiveThresholdInfo_FieldTerminalPathArrayItemValue) ContainsValue(source *TsEntry_State_AdaptiveThresholdInfo) bool {
	slice := fpaiv.TsEntryStateAdaptiveThresholdInfo_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 TsEntryStateAdaptiveThresholdInfo_FieldSubPathArrayItemValue struct {
	TsEntryStateAdaptiveThresholdInfo_FieldPath
	subPathItemValue gotenobject.FieldPathArrayItemValue
}

// GetRawValue returns stored array item value
func (fpaivs *TsEntryStateAdaptiveThresholdInfo_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *TsEntryStateAdaptiveThresholdInfo_FieldSubPathArrayItemValue) AsLowerPathItemValue() (rcommon.AlertingThreshold_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(rcommon.AlertingThreshold_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *TsEntryStateAdaptiveThresholdInfo_FieldSubPathArrayItemValue) AsUpperPathItemValue() (rcommon.AlertingThreshold_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(rcommon.AlertingThreshold_FieldPathArrayItemValue)
	return res, ok
}

// Contains returns a boolean indicating if value that is being held is present in given 'AdaptiveThresholdInfo'
func (fpaivs *TsEntryStateAdaptiveThresholdInfo_FieldSubPathArrayItemValue) ContainsValue(source *TsEntry_State_AdaptiveThresholdInfo) bool {
	switch fpaivs.Selector() {
	case TsEntryStateAdaptiveThresholdInfo_FieldPathSelectorLower:
		return fpaivs.subPathItemValue.(rcommon.AlertingThreshold_FieldPathArrayItemValue).ContainsValue(source.GetLower())
	case TsEntryStateAdaptiveThresholdInfo_FieldPathSelectorUpper:
		return fpaivs.subPathItemValue.(rcommon.AlertingThreshold_FieldPathArrayItemValue).ContainsValue(source.GetUpper())
	default:
		panic(fmt.Sprintf("Invalid selector for TsEntry_State_AdaptiveThresholdInfo: %d", fpaivs.Selector()))
	}
}

// TsEntryStateAdaptiveThresholdInfo_FieldPathArrayOfValues allows storing slice of values for AdaptiveThresholdInfo fields according to their type
type TsEntryStateAdaptiveThresholdInfo_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	TsEntryStateAdaptiveThresholdInfo_FieldPath
}

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

func MustParseTsEntryStateAdaptiveThresholdInfo_FieldPathArrayOfValues(pathStr, valuesStr string) TsEntryStateAdaptiveThresholdInfo_FieldPathArrayOfValues {
	fpaov, err := ParseTsEntryStateAdaptiveThresholdInfo_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type TsEntryStateAdaptiveThresholdInfo_FieldTerminalPathArrayOfValues struct {
	TsEntryStateAdaptiveThresholdInfo_FieldTerminalPath
	values interface{}
}

var _ TsEntryStateAdaptiveThresholdInfo_FieldPathArrayOfValues = (*TsEntryStateAdaptiveThresholdInfo_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *TsEntryStateAdaptiveThresholdInfo_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case TsEntryStateAdaptiveThresholdInfo_FieldPathSelectorQueryName:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case TsEntryStateAdaptiveThresholdInfo_FieldPathSelectorLower:
		for _, v := range fpaov.values.([]*rcommon.AlertingThreshold) {
			values = append(values, v)
		}
	case TsEntryStateAdaptiveThresholdInfo_FieldPathSelectorUpper:
		for _, v := range fpaov.values.([]*rcommon.AlertingThreshold) {
			values = append(values, v)
		}
	case TsEntryStateAdaptiveThresholdInfo_FieldPathSelectorNextCheck:
		for _, v := range fpaov.values.([]*timestamppb.Timestamp) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *TsEntryStateAdaptiveThresholdInfo_FieldTerminalPathArrayOfValues) AsQueryNameArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *TsEntryStateAdaptiveThresholdInfo_FieldTerminalPathArrayOfValues) AsLowerArrayOfValues() ([]*rcommon.AlertingThreshold, bool) {
	res, ok := fpaov.values.([]*rcommon.AlertingThreshold)
	return res, ok
}
func (fpaov *TsEntryStateAdaptiveThresholdInfo_FieldTerminalPathArrayOfValues) AsUpperArrayOfValues() ([]*rcommon.AlertingThreshold, bool) {
	res, ok := fpaov.values.([]*rcommon.AlertingThreshold)
	return res, ok
}
func (fpaov *TsEntryStateAdaptiveThresholdInfo_FieldTerminalPathArrayOfValues) AsNextCheckArrayOfValues() ([]*timestamppb.Timestamp, bool) {
	res, ok := fpaov.values.([]*timestamppb.Timestamp)
	return res, ok
}

type TsEntryStateAdaptiveThresholdInfo_FieldSubPathArrayOfValues struct {
	TsEntryStateAdaptiveThresholdInfo_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ TsEntryStateAdaptiveThresholdInfo_FieldPathArrayOfValues = (*TsEntryStateAdaptiveThresholdInfo_FieldSubPathArrayOfValues)(nil)

func (fpsaov *TsEntryStateAdaptiveThresholdInfo_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *TsEntryStateAdaptiveThresholdInfo_FieldSubPathArrayOfValues) AsLowerPathArrayOfValues() (rcommon.AlertingThreshold_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(rcommon.AlertingThreshold_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *TsEntryStateAdaptiveThresholdInfo_FieldSubPathArrayOfValues) AsUpperPathArrayOfValues() (rcommon.AlertingThreshold_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(rcommon.AlertingThreshold_FieldPathArrayOfValues)
	return res, ok
}