github.com/cloudwan/edgelq-sdk@v1.15.4/monitoring/resources/v3/alert/alert.pb.fieldpath.go

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

package alert

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 (
	alerting_condition "github.com/cloudwan/edgelq-sdk/monitoring/resources/v3/alerting_condition"
	common "github.com/cloudwan/edgelq-sdk/monitoring/resources/v3/common"
	meta "github.com/cloudwan/goten-sdk/types/meta"
)

// 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 (
	_ = &alerting_condition.AlertingCondition{}
	_ = &common.LabelDescriptor{}
	_ = &meta.Meta{}
)

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

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

type Alert_FieldPathSelector int32

const (
	Alert_FieldPathSelectorName        Alert_FieldPathSelector = 0
	Alert_FieldPathSelectorMetadata    Alert_FieldPathSelector = 1
	Alert_FieldPathSelectorDisplayName Alert_FieldPathSelector = 2
	Alert_FieldPathSelectorInfo        Alert_FieldPathSelector = 3
	Alert_FieldPathSelectorState       Alert_FieldPathSelector = 4
)

func (s Alert_FieldPathSelector) String() string {
	switch s {
	case Alert_FieldPathSelectorName:
		return "name"
	case Alert_FieldPathSelectorMetadata:
		return "metadata"
	case Alert_FieldPathSelectorDisplayName:
		return "display_name"
	case Alert_FieldPathSelectorInfo:
		return "info"
	case Alert_FieldPathSelectorState:
		return "state"
	default:
		panic(fmt.Sprintf("Invalid selector for Alert: %d", s))
	}
}

func BuildAlert_FieldPath(fp gotenobject.RawFieldPath) (Alert_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object Alert")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "name":
			return &Alert_FieldTerminalPath{selector: Alert_FieldPathSelectorName}, nil
		case "metadata":
			return &Alert_FieldTerminalPath{selector: Alert_FieldPathSelectorMetadata}, nil
		case "display_name", "displayName", "display-name":
			return &Alert_FieldTerminalPath{selector: Alert_FieldPathSelectorDisplayName}, nil
		case "info":
			return &Alert_FieldTerminalPath{selector: Alert_FieldPathSelectorInfo}, nil
		case "state":
			return &Alert_FieldTerminalPath{selector: Alert_FieldPathSelectorState}, nil
		}
	} else {
		switch fp[0] {
		case "metadata":
			if subpath, err := meta.BuildMeta_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &Alert_FieldSubPath{selector: Alert_FieldPathSelectorMetadata, subPath: subpath}, nil
			}
		case "info":
			if subpath, err := BuildAlertInfo_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &Alert_FieldSubPath{selector: Alert_FieldPathSelectorInfo, subPath: subpath}, nil
			}
		case "state":
			if subpath, err := BuildAlertState_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &Alert_FieldSubPath{selector: Alert_FieldPathSelectorState, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object Alert", fp)
}

func ParseAlert_FieldPath(rawField string) (Alert_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildAlert_FieldPath(fp)
}

func MustParseAlert_FieldPath(rawField string) Alert_FieldPath {
	fp, err := ParseAlert_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type Alert_FieldTerminalPath struct {
	selector Alert_FieldPathSelector
}

var _ Alert_FieldPath = (*Alert_FieldTerminalPath)(nil)

func (fp *Alert_FieldTerminalPath) Selector() Alert_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source Alert
func (fp *Alert_FieldTerminalPath) Get(source *Alert) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case Alert_FieldPathSelectorName:
			if source.Name != nil {
				values = append(values, source.Name)
			}
		case Alert_FieldPathSelectorMetadata:
			if source.Metadata != nil {
				values = append(values, source.Metadata)
			}
		case Alert_FieldPathSelectorDisplayName:
			values = append(values, source.DisplayName)
		case Alert_FieldPathSelectorInfo:
			if source.Info != nil {
				values = append(values, source.Info)
			}
		case Alert_FieldPathSelectorState:
			if source.State != nil {
				values = append(values, source.State)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for Alert: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source Alert
func (fp *Alert_FieldTerminalPath) GetSingle(source *Alert) (interface{}, bool) {
	switch fp.selector {
	case Alert_FieldPathSelectorName:
		res := source.GetName()
		return res, res != nil
	case Alert_FieldPathSelectorMetadata:
		res := source.GetMetadata()
		return res, res != nil
	case Alert_FieldPathSelectorDisplayName:
		return source.GetDisplayName(), source != nil
	case Alert_FieldPathSelectorInfo:
		res := source.GetInfo()
		return res, res != nil
	case Alert_FieldPathSelectorState:
		res := source.GetState()
		return res, res != nil
	default:
		panic(fmt.Sprintf("Invalid selector for Alert: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *Alert_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case Alert_FieldPathSelectorName:
		return (*Name)(nil)
	case Alert_FieldPathSelectorMetadata:
		return (*meta.Meta)(nil)
	case Alert_FieldPathSelectorDisplayName:
		return ""
	case Alert_FieldPathSelectorInfo:
		return (*Alert_Info)(nil)
	case Alert_FieldPathSelectorState:
		return (*Alert_State)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for Alert: %d", fp.selector))
	}
}

func (fp *Alert_FieldTerminalPath) ClearValue(item *Alert) {
	if item != nil {
		switch fp.selector {
		case Alert_FieldPathSelectorName:
			item.Name = nil
		case Alert_FieldPathSelectorMetadata:
			item.Metadata = nil
		case Alert_FieldPathSelectorDisplayName:
			item.DisplayName = ""
		case Alert_FieldPathSelectorInfo:
			item.Info = nil
		case Alert_FieldPathSelectorState:
			item.State = nil
		default:
			panic(fmt.Sprintf("Invalid selector for Alert: %d", fp.selector))
		}
	}
}

func (fp *Alert_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*Alert))
}

// IsLeaf - whether field path is holds simple value
func (fp *Alert_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == Alert_FieldPathSelectorName ||
		fp.selector == Alert_FieldPathSelectorDisplayName
}

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

func (fp *Alert_FieldTerminalPath) WithIValue(value interface{}) Alert_FieldPathValue {
	switch fp.selector {
	case Alert_FieldPathSelectorName:
		return &Alert_FieldTerminalPathValue{Alert_FieldTerminalPath: *fp, value: value.(*Name)}
	case Alert_FieldPathSelectorMetadata:
		return &Alert_FieldTerminalPathValue{Alert_FieldTerminalPath: *fp, value: value.(*meta.Meta)}
	case Alert_FieldPathSelectorDisplayName:
		return &Alert_FieldTerminalPathValue{Alert_FieldTerminalPath: *fp, value: value.(string)}
	case Alert_FieldPathSelectorInfo:
		return &Alert_FieldTerminalPathValue{Alert_FieldTerminalPath: *fp, value: value.(*Alert_Info)}
	case Alert_FieldPathSelectorState:
		return &Alert_FieldTerminalPathValue{Alert_FieldTerminalPath: *fp, value: value.(*Alert_State)}
	default:
		panic(fmt.Sprintf("Invalid selector for Alert: %d", fp.selector))
	}
}

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

func (fp *Alert_FieldTerminalPath) WithIArrayOfValues(values interface{}) Alert_FieldPathArrayOfValues {
	fpaov := &Alert_FieldTerminalPathArrayOfValues{Alert_FieldTerminalPath: *fp}
	switch fp.selector {
	case Alert_FieldPathSelectorName:
		return &Alert_FieldTerminalPathArrayOfValues{Alert_FieldTerminalPath: *fp, values: values.([]*Name)}
	case Alert_FieldPathSelectorMetadata:
		return &Alert_FieldTerminalPathArrayOfValues{Alert_FieldTerminalPath: *fp, values: values.([]*meta.Meta)}
	case Alert_FieldPathSelectorDisplayName:
		return &Alert_FieldTerminalPathArrayOfValues{Alert_FieldTerminalPath: *fp, values: values.([]string)}
	case Alert_FieldPathSelectorInfo:
		return &Alert_FieldTerminalPathArrayOfValues{Alert_FieldTerminalPath: *fp, values: values.([]*Alert_Info)}
	case Alert_FieldPathSelectorState:
		return &Alert_FieldTerminalPathArrayOfValues{Alert_FieldTerminalPath: *fp, values: values.([]*Alert_State)}
	default:
		panic(fmt.Sprintf("Invalid selector for Alert: %d", fp.selector))
	}
	return fpaov
}

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

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

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

type Alert_FieldSubPath struct {
	selector Alert_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ Alert_FieldPath = (*Alert_FieldSubPath)(nil)

func (fps *Alert_FieldSubPath) Selector() Alert_FieldPathSelector {
	return fps.selector
}
func (fps *Alert_FieldSubPath) AsMetadataSubPath() (meta.Meta_FieldPath, bool) {
	res, ok := fps.subPath.(meta.Meta_FieldPath)
	return res, ok
}
func (fps *Alert_FieldSubPath) AsInfoSubPath() (AlertInfo_FieldPath, bool) {
	res, ok := fps.subPath.(AlertInfo_FieldPath)
	return res, ok
}
func (fps *Alert_FieldSubPath) AsStateSubPath() (AlertState_FieldPath, bool) {
	res, ok := fps.subPath.(AlertState_FieldPath)
	return res, ok
}

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

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

// Get returns all values pointed by selected field from source Alert
func (fps *Alert_FieldSubPath) Get(source *Alert) (values []interface{}) {
	switch fps.selector {
	case Alert_FieldPathSelectorMetadata:
		values = append(values, fps.subPath.GetRaw(source.GetMetadata())...)
	case Alert_FieldPathSelectorInfo:
		values = append(values, fps.subPath.GetRaw(source.GetInfo())...)
	case Alert_FieldPathSelectorState:
		values = append(values, fps.subPath.GetRaw(source.GetState())...)
	default:
		panic(fmt.Sprintf("Invalid selector for Alert: %d", fps.selector))
	}
	return
}

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

// GetSingle returns value of selected field from source Alert
func (fps *Alert_FieldSubPath) GetSingle(source *Alert) (interface{}, bool) {
	switch fps.selector {
	case Alert_FieldPathSelectorMetadata:
		if source.GetMetadata() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetMetadata())
	case Alert_FieldPathSelectorInfo:
		if source.GetInfo() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetInfo())
	case Alert_FieldPathSelectorState:
		if source.GetState() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetState())
	default:
		panic(fmt.Sprintf("Invalid selector for Alert: %d", fps.selector))
	}
}

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

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

func (fps *Alert_FieldSubPath) ClearValue(item *Alert) {
	if item != nil {
		switch fps.selector {
		case Alert_FieldPathSelectorMetadata:
			fps.subPath.ClearValueRaw(item.Metadata)
		case Alert_FieldPathSelectorInfo:
			fps.subPath.ClearValueRaw(item.Info)
		case Alert_FieldPathSelectorState:
			fps.subPath.ClearValueRaw(item.State)
		default:
			panic(fmt.Sprintf("Invalid selector for Alert: %d", fps.selector))
		}
	}
}

func (fps *Alert_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*Alert))
}

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

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

func (fps *Alert_FieldSubPath) WithIValue(value interface{}) Alert_FieldPathValue {
	return &Alert_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *Alert_FieldSubPath) WithIArrayOfValues(values interface{}) Alert_FieldPathArrayOfValues {
	return &Alert_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *Alert_FieldSubPath) WithIArrayItemValue(value interface{}) Alert_FieldPathArrayItemValue {
	return &Alert_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

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

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

func MustParseAlert_FieldPathValue(pathStr, valueStr string) Alert_FieldPathValue {
	fpv, err := ParseAlert_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type Alert_FieldTerminalPathValue struct {
	Alert_FieldTerminalPath
	value interface{}
}

var _ Alert_FieldPathValue = (*Alert_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'Alert' as interface{}
func (fpv *Alert_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *Alert_FieldTerminalPathValue) AsNameValue() (*Name, bool) {
	res, ok := fpv.value.(*Name)
	return res, ok
}
func (fpv *Alert_FieldTerminalPathValue) AsMetadataValue() (*meta.Meta, bool) {
	res, ok := fpv.value.(*meta.Meta)
	return res, ok
}
func (fpv *Alert_FieldTerminalPathValue) AsDisplayNameValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *Alert_FieldTerminalPathValue) AsInfoValue() (*Alert_Info, bool) {
	res, ok := fpv.value.(*Alert_Info)
	return res, ok
}
func (fpv *Alert_FieldTerminalPathValue) AsStateValue() (*Alert_State, bool) {
	res, ok := fpv.value.(*Alert_State)
	return res, ok
}

// SetTo stores value for selected field for object Alert
func (fpv *Alert_FieldTerminalPathValue) SetTo(target **Alert) {
	if *target == nil {
		*target = new(Alert)
	}
	switch fpv.selector {
	case Alert_FieldPathSelectorName:
		(*target).Name = fpv.value.(*Name)
	case Alert_FieldPathSelectorMetadata:
		(*target).Metadata = fpv.value.(*meta.Meta)
	case Alert_FieldPathSelectorDisplayName:
		(*target).DisplayName = fpv.value.(string)
	case Alert_FieldPathSelectorInfo:
		(*target).Info = fpv.value.(*Alert_Info)
	case Alert_FieldPathSelectorState:
		(*target).State = fpv.value.(*Alert_State)
	default:
		panic(fmt.Sprintf("Invalid selector for Alert: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'Alert_FieldTerminalPathValue' with the value under path in 'Alert'.
func (fpv *Alert_FieldTerminalPathValue) CompareWith(source *Alert) (int, bool) {
	switch fpv.selector {
	case Alert_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 Alert_FieldPathSelectorMetadata:
		return 0, false
	case Alert_FieldPathSelectorDisplayName:
		leftValue := fpv.value.(string)
		rightValue := source.GetDisplayName()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case Alert_FieldPathSelectorInfo:
		return 0, false
	case Alert_FieldPathSelectorState:
		return 0, false
	default:
		panic(fmt.Sprintf("Invalid selector for Alert: %d", fpv.selector))
	}
}

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

type Alert_FieldSubPathValue struct {
	Alert_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ Alert_FieldPathValue = (*Alert_FieldSubPathValue)(nil)

func (fpvs *Alert_FieldSubPathValue) AsMetadataPathValue() (meta.Meta_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(meta.Meta_FieldPathValue)
	return res, ok
}
func (fpvs *Alert_FieldSubPathValue) AsInfoPathValue() (AlertInfo_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(AlertInfo_FieldPathValue)
	return res, ok
}
func (fpvs *Alert_FieldSubPathValue) AsStatePathValue() (AlertState_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(AlertState_FieldPathValue)
	return res, ok
}

func (fpvs *Alert_FieldSubPathValue) SetTo(target **Alert) {
	if *target == nil {
		*target = new(Alert)
	}
	switch fpvs.Selector() {
	case Alert_FieldPathSelectorMetadata:
		fpvs.subPathValue.(meta.Meta_FieldPathValue).SetTo(&(*target).Metadata)
	case Alert_FieldPathSelectorInfo:
		fpvs.subPathValue.(AlertInfo_FieldPathValue).SetTo(&(*target).Info)
	case Alert_FieldPathSelectorState:
		fpvs.subPathValue.(AlertState_FieldPathValue).SetTo(&(*target).State)
	default:
		panic(fmt.Sprintf("Invalid selector for Alert: %d", fpvs.Selector()))
	}
}

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

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

func (fpvs *Alert_FieldSubPathValue) CompareWith(source *Alert) (int, bool) {
	switch fpvs.Selector() {
	case Alert_FieldPathSelectorMetadata:
		return fpvs.subPathValue.(meta.Meta_FieldPathValue).CompareWith(source.GetMetadata())
	case Alert_FieldPathSelectorInfo:
		return fpvs.subPathValue.(AlertInfo_FieldPathValue).CompareWith(source.GetInfo())
	case Alert_FieldPathSelectorState:
		return fpvs.subPathValue.(AlertState_FieldPathValue).CompareWith(source.GetState())
	default:
		panic(fmt.Sprintf("Invalid selector for Alert: %d", fpvs.Selector()))
	}
}

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

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

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

func MustParseAlert_FieldPathArrayItemValue(pathStr, valueStr string) Alert_FieldPathArrayItemValue {
	fpaiv, err := ParseAlert_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type Alert_FieldTerminalPathArrayItemValue struct {
	Alert_FieldTerminalPath
	value interface{}
}

var _ Alert_FieldPathArrayItemValue = (*Alert_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *Alert_FieldTerminalPathArrayItemValue) GetSingle(source *Alert) (interface{}, bool) {
	return nil, false
}

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

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

// GetRawValue returns stored array item value
func (fpaivs *Alert_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *Alert_FieldSubPathArrayItemValue) AsMetadataPathItemValue() (meta.Meta_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(meta.Meta_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *Alert_FieldSubPathArrayItemValue) AsInfoPathItemValue() (AlertInfo_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(AlertInfo_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *Alert_FieldSubPathArrayItemValue) AsStatePathItemValue() (AlertState_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(AlertState_FieldPathArrayItemValue)
	return res, ok
}

// Contains returns a boolean indicating if value that is being held is present in given 'Alert'
func (fpaivs *Alert_FieldSubPathArrayItemValue) ContainsValue(source *Alert) bool {
	switch fpaivs.Selector() {
	case Alert_FieldPathSelectorMetadata:
		return fpaivs.subPathItemValue.(meta.Meta_FieldPathArrayItemValue).ContainsValue(source.GetMetadata())
	case Alert_FieldPathSelectorInfo:
		return fpaivs.subPathItemValue.(AlertInfo_FieldPathArrayItemValue).ContainsValue(source.GetInfo())
	case Alert_FieldPathSelectorState:
		return fpaivs.subPathItemValue.(AlertState_FieldPathArrayItemValue).ContainsValue(source.GetState())
	default:
		panic(fmt.Sprintf("Invalid selector for Alert: %d", fpaivs.Selector()))
	}
}

// Alert_FieldPathArrayOfValues allows storing slice of values for Alert fields according to their type
type Alert_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	Alert_FieldPath
}

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

func MustParseAlert_FieldPathArrayOfValues(pathStr, valuesStr string) Alert_FieldPathArrayOfValues {
	fpaov, err := ParseAlert_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type Alert_FieldTerminalPathArrayOfValues struct {
	Alert_FieldTerminalPath
	values interface{}
}

var _ Alert_FieldPathArrayOfValues = (*Alert_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *Alert_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case Alert_FieldPathSelectorName:
		for _, v := range fpaov.values.([]*Name) {
			values = append(values, v)
		}
	case Alert_FieldPathSelectorMetadata:
		for _, v := range fpaov.values.([]*meta.Meta) {
			values = append(values, v)
		}
	case Alert_FieldPathSelectorDisplayName:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case Alert_FieldPathSelectorInfo:
		for _, v := range fpaov.values.([]*Alert_Info) {
			values = append(values, v)
		}
	case Alert_FieldPathSelectorState:
		for _, v := range fpaov.values.([]*Alert_State) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *Alert_FieldTerminalPathArrayOfValues) AsNameArrayOfValues() ([]*Name, bool) {
	res, ok := fpaov.values.([]*Name)
	return res, ok
}
func (fpaov *Alert_FieldTerminalPathArrayOfValues) AsMetadataArrayOfValues() ([]*meta.Meta, bool) {
	res, ok := fpaov.values.([]*meta.Meta)
	return res, ok
}
func (fpaov *Alert_FieldTerminalPathArrayOfValues) AsDisplayNameArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *Alert_FieldTerminalPathArrayOfValues) AsInfoArrayOfValues() ([]*Alert_Info, bool) {
	res, ok := fpaov.values.([]*Alert_Info)
	return res, ok
}
func (fpaov *Alert_FieldTerminalPathArrayOfValues) AsStateArrayOfValues() ([]*Alert_State, bool) {
	res, ok := fpaov.values.([]*Alert_State)
	return res, ok
}

type Alert_FieldSubPathArrayOfValues struct {
	Alert_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ Alert_FieldPathArrayOfValues = (*Alert_FieldSubPathArrayOfValues)(nil)

func (fpsaov *Alert_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *Alert_FieldSubPathArrayOfValues) AsMetadataPathArrayOfValues() (meta.Meta_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(meta.Meta_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *Alert_FieldSubPathArrayOfValues) AsInfoPathArrayOfValues() (AlertInfo_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(AlertInfo_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *Alert_FieldSubPathArrayOfValues) AsStatePathArrayOfValues() (AlertState_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(AlertState_FieldPathArrayOfValues)
	return res, ok
}

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

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

type AlertInfo_FieldPathSelector int32

const (
	AlertInfo_FieldPathSelectorTimeSerie      AlertInfo_FieldPathSelector = 0
	AlertInfo_FieldPathSelectorObservedValues AlertInfo_FieldPathSelector = 1
)

func (s AlertInfo_FieldPathSelector) String() string {
	switch s {
	case AlertInfo_FieldPathSelectorTimeSerie:
		return "time_serie"
	case AlertInfo_FieldPathSelectorObservedValues:
		return "observed_values"
	default:
		panic(fmt.Sprintf("Invalid selector for Alert_Info: %d", s))
	}
}

func BuildAlertInfo_FieldPath(fp gotenobject.RawFieldPath) (AlertInfo_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object Alert_Info")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "time_serie", "timeSerie", "time-serie":
			return &AlertInfo_FieldTerminalPath{selector: AlertInfo_FieldPathSelectorTimeSerie}, nil
		case "observed_values", "observedValues", "observed-values":
			return &AlertInfo_FieldTerminalPath{selector: AlertInfo_FieldPathSelectorObservedValues}, nil
		}
	} else {
		switch fp[0] {
		case "time_serie", "timeSerie", "time-serie":
			if subpath, err := BuildAlertInfoTimeSerie_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &AlertInfo_FieldSubPath{selector: AlertInfo_FieldPathSelectorTimeSerie, subPath: subpath}, nil
			}
		case "observed_values", "observedValues", "observed-values":
			if subpath, err := BuildAlertInfoObservedValues_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &AlertInfo_FieldSubPath{selector: AlertInfo_FieldPathSelectorObservedValues, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object Alert_Info", fp)
}

func ParseAlertInfo_FieldPath(rawField string) (AlertInfo_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildAlertInfo_FieldPath(fp)
}

func MustParseAlertInfo_FieldPath(rawField string) AlertInfo_FieldPath {
	fp, err := ParseAlertInfo_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type AlertInfo_FieldTerminalPath struct {
	selector AlertInfo_FieldPathSelector
}

var _ AlertInfo_FieldPath = (*AlertInfo_FieldTerminalPath)(nil)

func (fp *AlertInfo_FieldTerminalPath) Selector() AlertInfo_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

// GetDefault returns a default value of the field type
func (fp *AlertInfo_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case AlertInfo_FieldPathSelectorTimeSerie:
		return (*Alert_Info_TimeSerie)(nil)
	case AlertInfo_FieldPathSelectorObservedValues:
		return (*Alert_Info_ObservedValues)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for Alert_Info: %d", fp.selector))
	}
}

func (fp *AlertInfo_FieldTerminalPath) ClearValue(item *Alert_Info) {
	if item != nil {
		switch fp.selector {
		case AlertInfo_FieldPathSelectorTimeSerie:
			item.TimeSerie = nil
		case AlertInfo_FieldPathSelectorObservedValues:
			item.ObservedValues = nil
		default:
			panic(fmt.Sprintf("Invalid selector for Alert_Info: %d", fp.selector))
		}
	}
}

func (fp *AlertInfo_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*Alert_Info))
}

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

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

func (fp *AlertInfo_FieldTerminalPath) WithIValue(value interface{}) AlertInfo_FieldPathValue {
	switch fp.selector {
	case AlertInfo_FieldPathSelectorTimeSerie:
		return &AlertInfo_FieldTerminalPathValue{AlertInfo_FieldTerminalPath: *fp, value: value.(*Alert_Info_TimeSerie)}
	case AlertInfo_FieldPathSelectorObservedValues:
		return &AlertInfo_FieldTerminalPathValue{AlertInfo_FieldTerminalPath: *fp, value: value.(*Alert_Info_ObservedValues)}
	default:
		panic(fmt.Sprintf("Invalid selector for Alert_Info: %d", fp.selector))
	}
}

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

func (fp *AlertInfo_FieldTerminalPath) WithIArrayOfValues(values interface{}) AlertInfo_FieldPathArrayOfValues {
	fpaov := &AlertInfo_FieldTerminalPathArrayOfValues{AlertInfo_FieldTerminalPath: *fp}
	switch fp.selector {
	case AlertInfo_FieldPathSelectorTimeSerie:
		return &AlertInfo_FieldTerminalPathArrayOfValues{AlertInfo_FieldTerminalPath: *fp, values: values.([]*Alert_Info_TimeSerie)}
	case AlertInfo_FieldPathSelectorObservedValues:
		return &AlertInfo_FieldTerminalPathArrayOfValues{AlertInfo_FieldTerminalPath: *fp, values: values.([]*Alert_Info_ObservedValues)}
	default:
		panic(fmt.Sprintf("Invalid selector for Alert_Info: %d", fp.selector))
	}
	return fpaov
}

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

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

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

type AlertInfo_FieldSubPath struct {
	selector AlertInfo_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ AlertInfo_FieldPath = (*AlertInfo_FieldSubPath)(nil)

func (fps *AlertInfo_FieldSubPath) Selector() AlertInfo_FieldPathSelector {
	return fps.selector
}
func (fps *AlertInfo_FieldSubPath) AsTimeSerieSubPath() (AlertInfoTimeSerie_FieldPath, bool) {
	res, ok := fps.subPath.(AlertInfoTimeSerie_FieldPath)
	return res, ok
}
func (fps *AlertInfo_FieldSubPath) AsObservedValuesSubPath() (AlertInfoObservedValues_FieldPath, bool) {
	res, ok := fps.subPath.(AlertInfoObservedValues_FieldPath)
	return res, ok
}

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

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

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

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

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

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

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

func (fps *AlertInfo_FieldSubPath) ClearValue(item *Alert_Info) {
	if item != nil {
		switch fps.selector {
		case AlertInfo_FieldPathSelectorTimeSerie:
			fps.subPath.ClearValueRaw(item.TimeSerie)
		case AlertInfo_FieldPathSelectorObservedValues:
			fps.subPath.ClearValueRaw(item.ObservedValues)
		default:
			panic(fmt.Sprintf("Invalid selector for Alert_Info: %d", fps.selector))
		}
	}
}

func (fps *AlertInfo_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*Alert_Info))
}

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

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

func (fps *AlertInfo_FieldSubPath) WithIValue(value interface{}) AlertInfo_FieldPathValue {
	return &AlertInfo_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *AlertInfo_FieldSubPath) WithIArrayOfValues(values interface{}) AlertInfo_FieldPathArrayOfValues {
	return &AlertInfo_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *AlertInfo_FieldSubPath) WithIArrayItemValue(value interface{}) AlertInfo_FieldPathArrayItemValue {
	return &AlertInfo_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

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

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

func MustParseAlertInfo_FieldPathValue(pathStr, valueStr string) AlertInfo_FieldPathValue {
	fpv, err := ParseAlertInfo_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type AlertInfo_FieldTerminalPathValue struct {
	AlertInfo_FieldTerminalPath
	value interface{}
}

var _ AlertInfo_FieldPathValue = (*AlertInfo_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'Info' as interface{}
func (fpv *AlertInfo_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *AlertInfo_FieldTerminalPathValue) AsTimeSerieValue() (*Alert_Info_TimeSerie, bool) {
	res, ok := fpv.value.(*Alert_Info_TimeSerie)
	return res, ok
}
func (fpv *AlertInfo_FieldTerminalPathValue) AsObservedValuesValue() (*Alert_Info_ObservedValues, bool) {
	res, ok := fpv.value.(*Alert_Info_ObservedValues)
	return res, ok
}

// SetTo stores value for selected field for object Info
func (fpv *AlertInfo_FieldTerminalPathValue) SetTo(target **Alert_Info) {
	if *target == nil {
		*target = new(Alert_Info)
	}
	switch fpv.selector {
	case AlertInfo_FieldPathSelectorTimeSerie:
		(*target).TimeSerie = fpv.value.(*Alert_Info_TimeSerie)
	case AlertInfo_FieldPathSelectorObservedValues:
		(*target).ObservedValues = fpv.value.(*Alert_Info_ObservedValues)
	default:
		panic(fmt.Sprintf("Invalid selector for Alert_Info: %d", fpv.selector))
	}
}

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

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

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

type AlertInfo_FieldSubPathValue struct {
	AlertInfo_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ AlertInfo_FieldPathValue = (*AlertInfo_FieldSubPathValue)(nil)

func (fpvs *AlertInfo_FieldSubPathValue) AsTimeSeriePathValue() (AlertInfoTimeSerie_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(AlertInfoTimeSerie_FieldPathValue)
	return res, ok
}
func (fpvs *AlertInfo_FieldSubPathValue) AsObservedValuesPathValue() (AlertInfoObservedValues_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(AlertInfoObservedValues_FieldPathValue)
	return res, ok
}

func (fpvs *AlertInfo_FieldSubPathValue) SetTo(target **Alert_Info) {
	if *target == nil {
		*target = new(Alert_Info)
	}
	switch fpvs.Selector() {
	case AlertInfo_FieldPathSelectorTimeSerie:
		fpvs.subPathValue.(AlertInfoTimeSerie_FieldPathValue).SetTo(&(*target).TimeSerie)
	case AlertInfo_FieldPathSelectorObservedValues:
		fpvs.subPathValue.(AlertInfoObservedValues_FieldPathValue).SetTo(&(*target).ObservedValues)
	default:
		panic(fmt.Sprintf("Invalid selector for Alert_Info: %d", fpvs.Selector()))
	}
}

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

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

func (fpvs *AlertInfo_FieldSubPathValue) CompareWith(source *Alert_Info) (int, bool) {
	switch fpvs.Selector() {
	case AlertInfo_FieldPathSelectorTimeSerie:
		return fpvs.subPathValue.(AlertInfoTimeSerie_FieldPathValue).CompareWith(source.GetTimeSerie())
	case AlertInfo_FieldPathSelectorObservedValues:
		return fpvs.subPathValue.(AlertInfoObservedValues_FieldPathValue).CompareWith(source.GetObservedValues())
	default:
		panic(fmt.Sprintf("Invalid selector for Alert_Info: %d", fpvs.Selector()))
	}
}

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

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

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

func MustParseAlertInfo_FieldPathArrayItemValue(pathStr, valueStr string) AlertInfo_FieldPathArrayItemValue {
	fpaiv, err := ParseAlertInfo_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type AlertInfo_FieldTerminalPathArrayItemValue struct {
	AlertInfo_FieldTerminalPath
	value interface{}
}

var _ AlertInfo_FieldPathArrayItemValue = (*AlertInfo_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *AlertInfo_FieldTerminalPathArrayItemValue) GetSingle(source *Alert_Info) (interface{}, bool) {
	return nil, false
}

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

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

// GetRawValue returns stored array item value
func (fpaivs *AlertInfo_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *AlertInfo_FieldSubPathArrayItemValue) AsTimeSeriePathItemValue() (AlertInfoTimeSerie_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(AlertInfoTimeSerie_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *AlertInfo_FieldSubPathArrayItemValue) AsObservedValuesPathItemValue() (AlertInfoObservedValues_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(AlertInfoObservedValues_FieldPathArrayItemValue)
	return res, ok
}

// Contains returns a boolean indicating if value that is being held is present in given 'Info'
func (fpaivs *AlertInfo_FieldSubPathArrayItemValue) ContainsValue(source *Alert_Info) bool {
	switch fpaivs.Selector() {
	case AlertInfo_FieldPathSelectorTimeSerie:
		return fpaivs.subPathItemValue.(AlertInfoTimeSerie_FieldPathArrayItemValue).ContainsValue(source.GetTimeSerie())
	case AlertInfo_FieldPathSelectorObservedValues:
		return fpaivs.subPathItemValue.(AlertInfoObservedValues_FieldPathArrayItemValue).ContainsValue(source.GetObservedValues())
	default:
		panic(fmt.Sprintf("Invalid selector for Alert_Info: %d", fpaivs.Selector()))
	}
}

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

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

func MustParseAlertInfo_FieldPathArrayOfValues(pathStr, valuesStr string) AlertInfo_FieldPathArrayOfValues {
	fpaov, err := ParseAlertInfo_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type AlertInfo_FieldTerminalPathArrayOfValues struct {
	AlertInfo_FieldTerminalPath
	values interface{}
}

var _ AlertInfo_FieldPathArrayOfValues = (*AlertInfo_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *AlertInfo_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case AlertInfo_FieldPathSelectorTimeSerie:
		for _, v := range fpaov.values.([]*Alert_Info_TimeSerie) {
			values = append(values, v)
		}
	case AlertInfo_FieldPathSelectorObservedValues:
		for _, v := range fpaov.values.([]*Alert_Info_ObservedValues) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *AlertInfo_FieldTerminalPathArrayOfValues) AsTimeSerieArrayOfValues() ([]*Alert_Info_TimeSerie, bool) {
	res, ok := fpaov.values.([]*Alert_Info_TimeSerie)
	return res, ok
}
func (fpaov *AlertInfo_FieldTerminalPathArrayOfValues) AsObservedValuesArrayOfValues() ([]*Alert_Info_ObservedValues, bool) {
	res, ok := fpaov.values.([]*Alert_Info_ObservedValues)
	return res, ok
}

type AlertInfo_FieldSubPathArrayOfValues struct {
	AlertInfo_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ AlertInfo_FieldPathArrayOfValues = (*AlertInfo_FieldSubPathArrayOfValues)(nil)

func (fpsaov *AlertInfo_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *AlertInfo_FieldSubPathArrayOfValues) AsTimeSeriePathArrayOfValues() (AlertInfoTimeSerie_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(AlertInfoTimeSerie_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *AlertInfo_FieldSubPathArrayOfValues) AsObservedValuesPathArrayOfValues() (AlertInfoObservedValues_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(AlertInfoObservedValues_FieldPathArrayOfValues)
	return res, ok
}

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

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

type AlertState_FieldPathSelector int32

const (
	AlertState_FieldPathSelectorIsFiring            AlertState_FieldPathSelector = 0
	AlertState_FieldPathSelectorIsAcknowledged      AlertState_FieldPathSelector = 1
	AlertState_FieldPathSelectorIsSilenced          AlertState_FieldPathSelector = 2
	AlertState_FieldPathSelectorLifetime            AlertState_FieldPathSelector = 3
	AlertState_FieldPathSelectorNeedsNotification   AlertState_FieldPathSelector = 4
	AlertState_FieldPathSelectorNotificationCreated AlertState_FieldPathSelector = 5
	AlertState_FieldPathSelectorLifecycleCompleted  AlertState_FieldPathSelector = 6
)

func (s AlertState_FieldPathSelector) String() string {
	switch s {
	case AlertState_FieldPathSelectorIsFiring:
		return "is_firing"
	case AlertState_FieldPathSelectorIsAcknowledged:
		return "is_acknowledged"
	case AlertState_FieldPathSelectorIsSilenced:
		return "is_silenced"
	case AlertState_FieldPathSelectorLifetime:
		return "lifetime"
	case AlertState_FieldPathSelectorNeedsNotification:
		return "needs_notification"
	case AlertState_FieldPathSelectorNotificationCreated:
		return "notification_created"
	case AlertState_FieldPathSelectorLifecycleCompleted:
		return "lifecycle_completed"
	default:
		panic(fmt.Sprintf("Invalid selector for Alert_State: %d", s))
	}
}

func BuildAlertState_FieldPath(fp gotenobject.RawFieldPath) (AlertState_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object Alert_State")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "is_firing", "isFiring", "is-firing":
			return &AlertState_FieldTerminalPath{selector: AlertState_FieldPathSelectorIsFiring}, nil
		case "is_acknowledged", "isAcknowledged", "is-acknowledged":
			return &AlertState_FieldTerminalPath{selector: AlertState_FieldPathSelectorIsAcknowledged}, nil
		case "is_silenced", "isSilenced", "is-silenced":
			return &AlertState_FieldTerminalPath{selector: AlertState_FieldPathSelectorIsSilenced}, nil
		case "lifetime":
			return &AlertState_FieldTerminalPath{selector: AlertState_FieldPathSelectorLifetime}, nil
		case "needs_notification", "needsNotification", "needs-notification":
			return &AlertState_FieldTerminalPath{selector: AlertState_FieldPathSelectorNeedsNotification}, nil
		case "notification_created", "notificationCreated", "notification-created":
			return &AlertState_FieldTerminalPath{selector: AlertState_FieldPathSelectorNotificationCreated}, nil
		case "lifecycle_completed", "lifecycleCompleted", "lifecycle-completed":
			return &AlertState_FieldTerminalPath{selector: AlertState_FieldPathSelectorLifecycleCompleted}, nil
		}
	} else {
		switch fp[0] {
		case "lifetime":
			if subpath, err := common.BuildTimeRange_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &AlertState_FieldSubPath{selector: AlertState_FieldPathSelectorLifetime, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object Alert_State", fp)
}

func ParseAlertState_FieldPath(rawField string) (AlertState_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildAlertState_FieldPath(fp)
}

func MustParseAlertState_FieldPath(rawField string) AlertState_FieldPath {
	fp, err := ParseAlertState_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type AlertState_FieldTerminalPath struct {
	selector AlertState_FieldPathSelector
}

var _ AlertState_FieldPath = (*AlertState_FieldTerminalPath)(nil)

func (fp *AlertState_FieldTerminalPath) Selector() AlertState_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source Alert_State
func (fp *AlertState_FieldTerminalPath) Get(source *Alert_State) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case AlertState_FieldPathSelectorIsFiring:
			values = append(values, source.IsFiring)
		case AlertState_FieldPathSelectorIsAcknowledged:
			values = append(values, source.IsAcknowledged)
		case AlertState_FieldPathSelectorIsSilenced:
			values = append(values, source.IsSilenced)
		case AlertState_FieldPathSelectorLifetime:
			if source.Lifetime != nil {
				values = append(values, source.Lifetime)
			}
		case AlertState_FieldPathSelectorNeedsNotification:
			values = append(values, source.NeedsNotification)
		case AlertState_FieldPathSelectorNotificationCreated:
			values = append(values, source.NotificationCreated)
		case AlertState_FieldPathSelectorLifecycleCompleted:
			values = append(values, source.LifecycleCompleted)
		default:
			panic(fmt.Sprintf("Invalid selector for Alert_State: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source Alert_State
func (fp *AlertState_FieldTerminalPath) GetSingle(source *Alert_State) (interface{}, bool) {
	switch fp.selector {
	case AlertState_FieldPathSelectorIsFiring:
		return source.GetIsFiring(), source != nil
	case AlertState_FieldPathSelectorIsAcknowledged:
		return source.GetIsAcknowledged(), source != nil
	case AlertState_FieldPathSelectorIsSilenced:
		return source.GetIsSilenced(), source != nil
	case AlertState_FieldPathSelectorLifetime:
		res := source.GetLifetime()
		return res, res != nil
	case AlertState_FieldPathSelectorNeedsNotification:
		return source.GetNeedsNotification(), source != nil
	case AlertState_FieldPathSelectorNotificationCreated:
		return source.GetNotificationCreated(), source != nil
	case AlertState_FieldPathSelectorLifecycleCompleted:
		return source.GetLifecycleCompleted(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for Alert_State: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *AlertState_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case AlertState_FieldPathSelectorIsFiring:
		return false
	case AlertState_FieldPathSelectorIsAcknowledged:
		return false
	case AlertState_FieldPathSelectorIsSilenced:
		return false
	case AlertState_FieldPathSelectorLifetime:
		return (*common.TimeRange)(nil)
	case AlertState_FieldPathSelectorNeedsNotification:
		return false
	case AlertState_FieldPathSelectorNotificationCreated:
		return false
	case AlertState_FieldPathSelectorLifecycleCompleted:
		return false
	default:
		panic(fmt.Sprintf("Invalid selector for Alert_State: %d", fp.selector))
	}
}

func (fp *AlertState_FieldTerminalPath) ClearValue(item *Alert_State) {
	if item != nil {
		switch fp.selector {
		case AlertState_FieldPathSelectorIsFiring:
			item.IsFiring = false
		case AlertState_FieldPathSelectorIsAcknowledged:
			item.IsAcknowledged = false
		case AlertState_FieldPathSelectorIsSilenced:
			item.IsSilenced = false
		case AlertState_FieldPathSelectorLifetime:
			item.Lifetime = nil
		case AlertState_FieldPathSelectorNeedsNotification:
			item.NeedsNotification = false
		case AlertState_FieldPathSelectorNotificationCreated:
			item.NotificationCreated = false
		case AlertState_FieldPathSelectorLifecycleCompleted:
			item.LifecycleCompleted = false
		default:
			panic(fmt.Sprintf("Invalid selector for Alert_State: %d", fp.selector))
		}
	}
}

func (fp *AlertState_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*Alert_State))
}

// IsLeaf - whether field path is holds simple value
func (fp *AlertState_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == AlertState_FieldPathSelectorIsFiring ||
		fp.selector == AlertState_FieldPathSelectorIsAcknowledged ||
		fp.selector == AlertState_FieldPathSelectorIsSilenced ||
		fp.selector == AlertState_FieldPathSelectorNeedsNotification ||
		fp.selector == AlertState_FieldPathSelectorNotificationCreated ||
		fp.selector == AlertState_FieldPathSelectorLifecycleCompleted
}

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

func (fp *AlertState_FieldTerminalPath) WithIValue(value interface{}) AlertState_FieldPathValue {
	switch fp.selector {
	case AlertState_FieldPathSelectorIsFiring:
		return &AlertState_FieldTerminalPathValue{AlertState_FieldTerminalPath: *fp, value: value.(bool)}
	case AlertState_FieldPathSelectorIsAcknowledged:
		return &AlertState_FieldTerminalPathValue{AlertState_FieldTerminalPath: *fp, value: value.(bool)}
	case AlertState_FieldPathSelectorIsSilenced:
		return &AlertState_FieldTerminalPathValue{AlertState_FieldTerminalPath: *fp, value: value.(bool)}
	case AlertState_FieldPathSelectorLifetime:
		return &AlertState_FieldTerminalPathValue{AlertState_FieldTerminalPath: *fp, value: value.(*common.TimeRange)}
	case AlertState_FieldPathSelectorNeedsNotification:
		return &AlertState_FieldTerminalPathValue{AlertState_FieldTerminalPath: *fp, value: value.(bool)}
	case AlertState_FieldPathSelectorNotificationCreated:
		return &AlertState_FieldTerminalPathValue{AlertState_FieldTerminalPath: *fp, value: value.(bool)}
	case AlertState_FieldPathSelectorLifecycleCompleted:
		return &AlertState_FieldTerminalPathValue{AlertState_FieldTerminalPath: *fp, value: value.(bool)}
	default:
		panic(fmt.Sprintf("Invalid selector for Alert_State: %d", fp.selector))
	}
}

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

func (fp *AlertState_FieldTerminalPath) WithIArrayOfValues(values interface{}) AlertState_FieldPathArrayOfValues {
	fpaov := &AlertState_FieldTerminalPathArrayOfValues{AlertState_FieldTerminalPath: *fp}
	switch fp.selector {
	case AlertState_FieldPathSelectorIsFiring:
		return &AlertState_FieldTerminalPathArrayOfValues{AlertState_FieldTerminalPath: *fp, values: values.([]bool)}
	case AlertState_FieldPathSelectorIsAcknowledged:
		return &AlertState_FieldTerminalPathArrayOfValues{AlertState_FieldTerminalPath: *fp, values: values.([]bool)}
	case AlertState_FieldPathSelectorIsSilenced:
		return &AlertState_FieldTerminalPathArrayOfValues{AlertState_FieldTerminalPath: *fp, values: values.([]bool)}
	case AlertState_FieldPathSelectorLifetime:
		return &AlertState_FieldTerminalPathArrayOfValues{AlertState_FieldTerminalPath: *fp, values: values.([]*common.TimeRange)}
	case AlertState_FieldPathSelectorNeedsNotification:
		return &AlertState_FieldTerminalPathArrayOfValues{AlertState_FieldTerminalPath: *fp, values: values.([]bool)}
	case AlertState_FieldPathSelectorNotificationCreated:
		return &AlertState_FieldTerminalPathArrayOfValues{AlertState_FieldTerminalPath: *fp, values: values.([]bool)}
	case AlertState_FieldPathSelectorLifecycleCompleted:
		return &AlertState_FieldTerminalPathArrayOfValues{AlertState_FieldTerminalPath: *fp, values: values.([]bool)}
	default:
		panic(fmt.Sprintf("Invalid selector for Alert_State: %d", fp.selector))
	}
	return fpaov
}

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

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

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

type AlertState_FieldSubPath struct {
	selector AlertState_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ AlertState_FieldPath = (*AlertState_FieldSubPath)(nil)

func (fps *AlertState_FieldSubPath) Selector() AlertState_FieldPathSelector {
	return fps.selector
}
func (fps *AlertState_FieldSubPath) AsLifetimeSubPath() (common.TimeRange_FieldPath, bool) {
	res, ok := fps.subPath.(common.TimeRange_FieldPath)
	return res, ok
}

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

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

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

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

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

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

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

func (fps *AlertState_FieldSubPath) ClearValue(item *Alert_State) {
	if item != nil {
		switch fps.selector {
		case AlertState_FieldPathSelectorLifetime:
			fps.subPath.ClearValueRaw(item.Lifetime)
		default:
			panic(fmt.Sprintf("Invalid selector for Alert_State: %d", fps.selector))
		}
	}
}

func (fps *AlertState_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*Alert_State))
}

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

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

func (fps *AlertState_FieldSubPath) WithIValue(value interface{}) AlertState_FieldPathValue {
	return &AlertState_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *AlertState_FieldSubPath) WithIArrayOfValues(values interface{}) AlertState_FieldPathArrayOfValues {
	return &AlertState_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *AlertState_FieldSubPath) WithIArrayItemValue(value interface{}) AlertState_FieldPathArrayItemValue {
	return &AlertState_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

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

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

func MustParseAlertState_FieldPathValue(pathStr, valueStr string) AlertState_FieldPathValue {
	fpv, err := ParseAlertState_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type AlertState_FieldTerminalPathValue struct {
	AlertState_FieldTerminalPath
	value interface{}
}

var _ AlertState_FieldPathValue = (*AlertState_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'State' as interface{}
func (fpv *AlertState_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *AlertState_FieldTerminalPathValue) AsIsFiringValue() (bool, bool) {
	res, ok := fpv.value.(bool)
	return res, ok
}
func (fpv *AlertState_FieldTerminalPathValue) AsIsAcknowledgedValue() (bool, bool) {
	res, ok := fpv.value.(bool)
	return res, ok
}
func (fpv *AlertState_FieldTerminalPathValue) AsIsSilencedValue() (bool, bool) {
	res, ok := fpv.value.(bool)
	return res, ok
}
func (fpv *AlertState_FieldTerminalPathValue) AsLifetimeValue() (*common.TimeRange, bool) {
	res, ok := fpv.value.(*common.TimeRange)
	return res, ok
}
func (fpv *AlertState_FieldTerminalPathValue) AsNeedsNotificationValue() (bool, bool) {
	res, ok := fpv.value.(bool)
	return res, ok
}
func (fpv *AlertState_FieldTerminalPathValue) AsNotificationCreatedValue() (bool, bool) {
	res, ok := fpv.value.(bool)
	return res, ok
}
func (fpv *AlertState_FieldTerminalPathValue) AsLifecycleCompletedValue() (bool, bool) {
	res, ok := fpv.value.(bool)
	return res, ok
}

// SetTo stores value for selected field for object State
func (fpv *AlertState_FieldTerminalPathValue) SetTo(target **Alert_State) {
	if *target == nil {
		*target = new(Alert_State)
	}
	switch fpv.selector {
	case AlertState_FieldPathSelectorIsFiring:
		(*target).IsFiring = fpv.value.(bool)
	case AlertState_FieldPathSelectorIsAcknowledged:
		(*target).IsAcknowledged = fpv.value.(bool)
	case AlertState_FieldPathSelectorIsSilenced:
		(*target).IsSilenced = fpv.value.(bool)
	case AlertState_FieldPathSelectorLifetime:
		(*target).Lifetime = fpv.value.(*common.TimeRange)
	case AlertState_FieldPathSelectorNeedsNotification:
		(*target).NeedsNotification = fpv.value.(bool)
	case AlertState_FieldPathSelectorNotificationCreated:
		(*target).NotificationCreated = fpv.value.(bool)
	case AlertState_FieldPathSelectorLifecycleCompleted:
		(*target).LifecycleCompleted = fpv.value.(bool)
	default:
		panic(fmt.Sprintf("Invalid selector for Alert_State: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'AlertState_FieldTerminalPathValue' with the value under path in 'Alert_State'.
func (fpv *AlertState_FieldTerminalPathValue) CompareWith(source *Alert_State) (int, bool) {
	switch fpv.selector {
	case AlertState_FieldPathSelectorIsFiring:
		leftValue := fpv.value.(bool)
		rightValue := source.GetIsFiring()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if !(leftValue) && (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case AlertState_FieldPathSelectorIsAcknowledged:
		leftValue := fpv.value.(bool)
		rightValue := source.GetIsAcknowledged()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if !(leftValue) && (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case AlertState_FieldPathSelectorIsSilenced:
		leftValue := fpv.value.(bool)
		rightValue := source.GetIsSilenced()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if !(leftValue) && (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case AlertState_FieldPathSelectorLifetime:
		return 0, false
	case AlertState_FieldPathSelectorNeedsNotification:
		leftValue := fpv.value.(bool)
		rightValue := source.GetNeedsNotification()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if !(leftValue) && (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case AlertState_FieldPathSelectorNotificationCreated:
		leftValue := fpv.value.(bool)
		rightValue := source.GetNotificationCreated()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if !(leftValue) && (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case AlertState_FieldPathSelectorLifecycleCompleted:
		leftValue := fpv.value.(bool)
		rightValue := source.GetLifecycleCompleted()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if !(leftValue) && (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for Alert_State: %d", fpv.selector))
	}
}

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

type AlertState_FieldSubPathValue struct {
	AlertState_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ AlertState_FieldPathValue = (*AlertState_FieldSubPathValue)(nil)

func (fpvs *AlertState_FieldSubPathValue) AsLifetimePathValue() (common.TimeRange_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(common.TimeRange_FieldPathValue)
	return res, ok
}

func (fpvs *AlertState_FieldSubPathValue) SetTo(target **Alert_State) {
	if *target == nil {
		*target = new(Alert_State)
	}
	switch fpvs.Selector() {
	case AlertState_FieldPathSelectorLifetime:
		fpvs.subPathValue.(common.TimeRange_FieldPathValue).SetTo(&(*target).Lifetime)
	default:
		panic(fmt.Sprintf("Invalid selector for Alert_State: %d", fpvs.Selector()))
	}
}

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

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

func (fpvs *AlertState_FieldSubPathValue) CompareWith(source *Alert_State) (int, bool) {
	switch fpvs.Selector() {
	case AlertState_FieldPathSelectorLifetime:
		return fpvs.subPathValue.(common.TimeRange_FieldPathValue).CompareWith(source.GetLifetime())
	default:
		panic(fmt.Sprintf("Invalid selector for Alert_State: %d", fpvs.Selector()))
	}
}

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

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

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

func MustParseAlertState_FieldPathArrayItemValue(pathStr, valueStr string) AlertState_FieldPathArrayItemValue {
	fpaiv, err := ParseAlertState_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type AlertState_FieldTerminalPathArrayItemValue struct {
	AlertState_FieldTerminalPath
	value interface{}
}

var _ AlertState_FieldPathArrayItemValue = (*AlertState_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *AlertState_FieldTerminalPathArrayItemValue) GetSingle(source *Alert_State) (interface{}, bool) {
	return nil, false
}

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

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

// GetRawValue returns stored array item value
func (fpaivs *AlertState_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *AlertState_FieldSubPathArrayItemValue) AsLifetimePathItemValue() (common.TimeRange_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(common.TimeRange_FieldPathArrayItemValue)
	return res, ok
}

// Contains returns a boolean indicating if value that is being held is present in given 'State'
func (fpaivs *AlertState_FieldSubPathArrayItemValue) ContainsValue(source *Alert_State) bool {
	switch fpaivs.Selector() {
	case AlertState_FieldPathSelectorLifetime:
		return fpaivs.subPathItemValue.(common.TimeRange_FieldPathArrayItemValue).ContainsValue(source.GetLifetime())
	default:
		panic(fmt.Sprintf("Invalid selector for Alert_State: %d", fpaivs.Selector()))
	}
}

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

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

func MustParseAlertState_FieldPathArrayOfValues(pathStr, valuesStr string) AlertState_FieldPathArrayOfValues {
	fpaov, err := ParseAlertState_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type AlertState_FieldTerminalPathArrayOfValues struct {
	AlertState_FieldTerminalPath
	values interface{}
}

var _ AlertState_FieldPathArrayOfValues = (*AlertState_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *AlertState_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case AlertState_FieldPathSelectorIsFiring:
		for _, v := range fpaov.values.([]bool) {
			values = append(values, v)
		}
	case AlertState_FieldPathSelectorIsAcknowledged:
		for _, v := range fpaov.values.([]bool) {
			values = append(values, v)
		}
	case AlertState_FieldPathSelectorIsSilenced:
		for _, v := range fpaov.values.([]bool) {
			values = append(values, v)
		}
	case AlertState_FieldPathSelectorLifetime:
		for _, v := range fpaov.values.([]*common.TimeRange) {
			values = append(values, v)
		}
	case AlertState_FieldPathSelectorNeedsNotification:
		for _, v := range fpaov.values.([]bool) {
			values = append(values, v)
		}
	case AlertState_FieldPathSelectorNotificationCreated:
		for _, v := range fpaov.values.([]bool) {
			values = append(values, v)
		}
	case AlertState_FieldPathSelectorLifecycleCompleted:
		for _, v := range fpaov.values.([]bool) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *AlertState_FieldTerminalPathArrayOfValues) AsIsFiringArrayOfValues() ([]bool, bool) {
	res, ok := fpaov.values.([]bool)
	return res, ok
}
func (fpaov *AlertState_FieldTerminalPathArrayOfValues) AsIsAcknowledgedArrayOfValues() ([]bool, bool) {
	res, ok := fpaov.values.([]bool)
	return res, ok
}
func (fpaov *AlertState_FieldTerminalPathArrayOfValues) AsIsSilencedArrayOfValues() ([]bool, bool) {
	res, ok := fpaov.values.([]bool)
	return res, ok
}
func (fpaov *AlertState_FieldTerminalPathArrayOfValues) AsLifetimeArrayOfValues() ([]*common.TimeRange, bool) {
	res, ok := fpaov.values.([]*common.TimeRange)
	return res, ok
}
func (fpaov *AlertState_FieldTerminalPathArrayOfValues) AsNeedsNotificationArrayOfValues() ([]bool, bool) {
	res, ok := fpaov.values.([]bool)
	return res, ok
}
func (fpaov *AlertState_FieldTerminalPathArrayOfValues) AsNotificationCreatedArrayOfValues() ([]bool, bool) {
	res, ok := fpaov.values.([]bool)
	return res, ok
}
func (fpaov *AlertState_FieldTerminalPathArrayOfValues) AsLifecycleCompletedArrayOfValues() ([]bool, bool) {
	res, ok := fpaov.values.([]bool)
	return res, ok
}

type AlertState_FieldSubPathArrayOfValues struct {
	AlertState_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ AlertState_FieldPathArrayOfValues = (*AlertState_FieldSubPathArrayOfValues)(nil)

func (fpsaov *AlertState_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *AlertState_FieldSubPathArrayOfValues) AsLifetimePathArrayOfValues() (common.TimeRange_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(common.TimeRange_FieldPathArrayOfValues)
	return res, ok
}

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

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

type AlertInfoTimeSerie_FieldPathSelector int32

const (
	AlertInfoTimeSerie_FieldPathSelectorKey               AlertInfoTimeSerie_FieldPathSelector = 0
	AlertInfoTimeSerie_FieldPathSelectorMetric            AlertInfoTimeSerie_FieldPathSelector = 1
	AlertInfoTimeSerie_FieldPathSelectorMonitoredResource AlertInfoTimeSerie_FieldPathSelector = 2
)

func (s AlertInfoTimeSerie_FieldPathSelector) String() string {
	switch s {
	case AlertInfoTimeSerie_FieldPathSelectorKey:
		return "key"
	case AlertInfoTimeSerie_FieldPathSelectorMetric:
		return "metric"
	case AlertInfoTimeSerie_FieldPathSelectorMonitoredResource:
		return "monitored_resource"
	default:
		panic(fmt.Sprintf("Invalid selector for Alert_Info_TimeSerie: %d", s))
	}
}

func BuildAlertInfoTimeSerie_FieldPath(fp gotenobject.RawFieldPath) (AlertInfoTimeSerie_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object Alert_Info_TimeSerie")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "key":
			return &AlertInfoTimeSerie_FieldTerminalPath{selector: AlertInfoTimeSerie_FieldPathSelectorKey}, nil
		case "metric":
			return &AlertInfoTimeSerie_FieldTerminalPath{selector: AlertInfoTimeSerie_FieldPathSelectorMetric}, nil
		case "monitored_resource", "monitoredResource", "monitored-resource":
			return &AlertInfoTimeSerie_FieldTerminalPath{selector: AlertInfoTimeSerie_FieldPathSelectorMonitoredResource}, nil
		}
	} else {
		switch fp[0] {
		case "metric":
			if subpath, err := common.BuildMetric_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &AlertInfoTimeSerie_FieldSubPath{selector: AlertInfoTimeSerie_FieldPathSelectorMetric, subPath: subpath}, nil
			}
		case "monitored_resource", "monitoredResource", "monitored-resource":
			if subpath, err := common.BuildMonitoredResource_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &AlertInfoTimeSerie_FieldSubPath{selector: AlertInfoTimeSerie_FieldPathSelectorMonitoredResource, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object Alert_Info_TimeSerie", fp)
}

func ParseAlertInfoTimeSerie_FieldPath(rawField string) (AlertInfoTimeSerie_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildAlertInfoTimeSerie_FieldPath(fp)
}

func MustParseAlertInfoTimeSerie_FieldPath(rawField string) AlertInfoTimeSerie_FieldPath {
	fp, err := ParseAlertInfoTimeSerie_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type AlertInfoTimeSerie_FieldTerminalPath struct {
	selector AlertInfoTimeSerie_FieldPathSelector
}

var _ AlertInfoTimeSerie_FieldPath = (*AlertInfoTimeSerie_FieldTerminalPath)(nil)

func (fp *AlertInfoTimeSerie_FieldTerminalPath) Selector() AlertInfoTimeSerie_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source Alert_Info_TimeSerie
func (fp *AlertInfoTimeSerie_FieldTerminalPath) Get(source *Alert_Info_TimeSerie) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case AlertInfoTimeSerie_FieldPathSelectorKey:
			values = append(values, source.Key)
		case AlertInfoTimeSerie_FieldPathSelectorMetric:
			if source.Metric != nil {
				values = append(values, source.Metric)
			}
		case AlertInfoTimeSerie_FieldPathSelectorMonitoredResource:
			if source.MonitoredResource != nil {
				values = append(values, source.MonitoredResource)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for Alert_Info_TimeSerie: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source Alert_Info_TimeSerie
func (fp *AlertInfoTimeSerie_FieldTerminalPath) GetSingle(source *Alert_Info_TimeSerie) (interface{}, bool) {
	switch fp.selector {
	case AlertInfoTimeSerie_FieldPathSelectorKey:
		res := source.GetKey()
		return res, res != nil
	case AlertInfoTimeSerie_FieldPathSelectorMetric:
		res := source.GetMetric()
		return res, res != nil
	case AlertInfoTimeSerie_FieldPathSelectorMonitoredResource:
		res := source.GetMonitoredResource()
		return res, res != nil
	default:
		panic(fmt.Sprintf("Invalid selector for Alert_Info_TimeSerie: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *AlertInfoTimeSerie_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case AlertInfoTimeSerie_FieldPathSelectorKey:
		return ([]byte)(nil)
	case AlertInfoTimeSerie_FieldPathSelectorMetric:
		return (*common.Metric)(nil)
	case AlertInfoTimeSerie_FieldPathSelectorMonitoredResource:
		return (*common.MonitoredResource)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for Alert_Info_TimeSerie: %d", fp.selector))
	}
}

func (fp *AlertInfoTimeSerie_FieldTerminalPath) ClearValue(item *Alert_Info_TimeSerie) {
	if item != nil {
		switch fp.selector {
		case AlertInfoTimeSerie_FieldPathSelectorKey:
			item.Key = nil
		case AlertInfoTimeSerie_FieldPathSelectorMetric:
			item.Metric = nil
		case AlertInfoTimeSerie_FieldPathSelectorMonitoredResource:
			item.MonitoredResource = nil
		default:
			panic(fmt.Sprintf("Invalid selector for Alert_Info_TimeSerie: %d", fp.selector))
		}
	}
}

func (fp *AlertInfoTimeSerie_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*Alert_Info_TimeSerie))
}

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

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

func (fp *AlertInfoTimeSerie_FieldTerminalPath) WithIValue(value interface{}) AlertInfoTimeSerie_FieldPathValue {
	switch fp.selector {
	case AlertInfoTimeSerie_FieldPathSelectorKey:
		return &AlertInfoTimeSerie_FieldTerminalPathValue{AlertInfoTimeSerie_FieldTerminalPath: *fp, value: value.([]byte)}
	case AlertInfoTimeSerie_FieldPathSelectorMetric:
		return &AlertInfoTimeSerie_FieldTerminalPathValue{AlertInfoTimeSerie_FieldTerminalPath: *fp, value: value.(*common.Metric)}
	case AlertInfoTimeSerie_FieldPathSelectorMonitoredResource:
		return &AlertInfoTimeSerie_FieldTerminalPathValue{AlertInfoTimeSerie_FieldTerminalPath: *fp, value: value.(*common.MonitoredResource)}
	default:
		panic(fmt.Sprintf("Invalid selector for Alert_Info_TimeSerie: %d", fp.selector))
	}
}

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

func (fp *AlertInfoTimeSerie_FieldTerminalPath) WithIArrayOfValues(values interface{}) AlertInfoTimeSerie_FieldPathArrayOfValues {
	fpaov := &AlertInfoTimeSerie_FieldTerminalPathArrayOfValues{AlertInfoTimeSerie_FieldTerminalPath: *fp}
	switch fp.selector {
	case AlertInfoTimeSerie_FieldPathSelectorKey:
		return &AlertInfoTimeSerie_FieldTerminalPathArrayOfValues{AlertInfoTimeSerie_FieldTerminalPath: *fp, values: values.([][]byte)}
	case AlertInfoTimeSerie_FieldPathSelectorMetric:
		return &AlertInfoTimeSerie_FieldTerminalPathArrayOfValues{AlertInfoTimeSerie_FieldTerminalPath: *fp, values: values.([]*common.Metric)}
	case AlertInfoTimeSerie_FieldPathSelectorMonitoredResource:
		return &AlertInfoTimeSerie_FieldTerminalPathArrayOfValues{AlertInfoTimeSerie_FieldTerminalPath: *fp, values: values.([]*common.MonitoredResource)}
	default:
		panic(fmt.Sprintf("Invalid selector for Alert_Info_TimeSerie: %d", fp.selector))
	}
	return fpaov
}

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

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

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

type AlertInfoTimeSerie_FieldSubPath struct {
	selector AlertInfoTimeSerie_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ AlertInfoTimeSerie_FieldPath = (*AlertInfoTimeSerie_FieldSubPath)(nil)

func (fps *AlertInfoTimeSerie_FieldSubPath) Selector() AlertInfoTimeSerie_FieldPathSelector {
	return fps.selector
}
func (fps *AlertInfoTimeSerie_FieldSubPath) AsMetricSubPath() (common.Metric_FieldPath, bool) {
	res, ok := fps.subPath.(common.Metric_FieldPath)
	return res, ok
}
func (fps *AlertInfoTimeSerie_FieldSubPath) AsMonitoredResourceSubPath() (common.MonitoredResource_FieldPath, bool) {
	res, ok := fps.subPath.(common.MonitoredResource_FieldPath)
	return res, ok
}

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

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

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

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

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

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

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

func (fps *AlertInfoTimeSerie_FieldSubPath) ClearValue(item *Alert_Info_TimeSerie) {
	if item != nil {
		switch fps.selector {
		case AlertInfoTimeSerie_FieldPathSelectorMetric:
			fps.subPath.ClearValueRaw(item.Metric)
		case AlertInfoTimeSerie_FieldPathSelectorMonitoredResource:
			fps.subPath.ClearValueRaw(item.MonitoredResource)
		default:
			panic(fmt.Sprintf("Invalid selector for Alert_Info_TimeSerie: %d", fps.selector))
		}
	}
}

func (fps *AlertInfoTimeSerie_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*Alert_Info_TimeSerie))
}

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

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

func (fps *AlertInfoTimeSerie_FieldSubPath) WithIValue(value interface{}) AlertInfoTimeSerie_FieldPathValue {
	return &AlertInfoTimeSerie_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *AlertInfoTimeSerie_FieldSubPath) WithIArrayOfValues(values interface{}) AlertInfoTimeSerie_FieldPathArrayOfValues {
	return &AlertInfoTimeSerie_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *AlertInfoTimeSerie_FieldSubPath) WithIArrayItemValue(value interface{}) AlertInfoTimeSerie_FieldPathArrayItemValue {
	return &AlertInfoTimeSerie_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

// AlertInfoTimeSerie_FieldPathValue allows storing values for TimeSerie fields according to their type
type AlertInfoTimeSerie_FieldPathValue interface {
	AlertInfoTimeSerie_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **Alert_Info_TimeSerie)
	CompareWith(*Alert_Info_TimeSerie) (cmp int, comparable bool)
}

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

func MustParseAlertInfoTimeSerie_FieldPathValue(pathStr, valueStr string) AlertInfoTimeSerie_FieldPathValue {
	fpv, err := ParseAlertInfoTimeSerie_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type AlertInfoTimeSerie_FieldTerminalPathValue struct {
	AlertInfoTimeSerie_FieldTerminalPath
	value interface{}
}

var _ AlertInfoTimeSerie_FieldPathValue = (*AlertInfoTimeSerie_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'TimeSerie' as interface{}
func (fpv *AlertInfoTimeSerie_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *AlertInfoTimeSerie_FieldTerminalPathValue) AsKeyValue() ([]byte, bool) {
	res, ok := fpv.value.([]byte)
	return res, ok
}
func (fpv *AlertInfoTimeSerie_FieldTerminalPathValue) AsMetricValue() (*common.Metric, bool) {
	res, ok := fpv.value.(*common.Metric)
	return res, ok
}
func (fpv *AlertInfoTimeSerie_FieldTerminalPathValue) AsMonitoredResourceValue() (*common.MonitoredResource, bool) {
	res, ok := fpv.value.(*common.MonitoredResource)
	return res, ok
}

// SetTo stores value for selected field for object TimeSerie
func (fpv *AlertInfoTimeSerie_FieldTerminalPathValue) SetTo(target **Alert_Info_TimeSerie) {
	if *target == nil {
		*target = new(Alert_Info_TimeSerie)
	}
	switch fpv.selector {
	case AlertInfoTimeSerie_FieldPathSelectorKey:
		(*target).Key = fpv.value.([]byte)
	case AlertInfoTimeSerie_FieldPathSelectorMetric:
		(*target).Metric = fpv.value.(*common.Metric)
	case AlertInfoTimeSerie_FieldPathSelectorMonitoredResource:
		(*target).MonitoredResource = fpv.value.(*common.MonitoredResource)
	default:
		panic(fmt.Sprintf("Invalid selector for Alert_Info_TimeSerie: %d", fpv.selector))
	}
}

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

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

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

type AlertInfoTimeSerie_FieldSubPathValue struct {
	AlertInfoTimeSerie_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ AlertInfoTimeSerie_FieldPathValue = (*AlertInfoTimeSerie_FieldSubPathValue)(nil)

func (fpvs *AlertInfoTimeSerie_FieldSubPathValue) AsMetricPathValue() (common.Metric_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(common.Metric_FieldPathValue)
	return res, ok
}
func (fpvs *AlertInfoTimeSerie_FieldSubPathValue) AsMonitoredResourcePathValue() (common.MonitoredResource_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(common.MonitoredResource_FieldPathValue)
	return res, ok
}

func (fpvs *AlertInfoTimeSerie_FieldSubPathValue) SetTo(target **Alert_Info_TimeSerie) {
	if *target == nil {
		*target = new(Alert_Info_TimeSerie)
	}
	switch fpvs.Selector() {
	case AlertInfoTimeSerie_FieldPathSelectorMetric:
		fpvs.subPathValue.(common.Metric_FieldPathValue).SetTo(&(*target).Metric)
	case AlertInfoTimeSerie_FieldPathSelectorMonitoredResource:
		fpvs.subPathValue.(common.MonitoredResource_FieldPathValue).SetTo(&(*target).MonitoredResource)
	default:
		panic(fmt.Sprintf("Invalid selector for Alert_Info_TimeSerie: %d", fpvs.Selector()))
	}
}

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

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

func (fpvs *AlertInfoTimeSerie_FieldSubPathValue) CompareWith(source *Alert_Info_TimeSerie) (int, bool) {
	switch fpvs.Selector() {
	case AlertInfoTimeSerie_FieldPathSelectorMetric:
		return fpvs.subPathValue.(common.Metric_FieldPathValue).CompareWith(source.GetMetric())
	case AlertInfoTimeSerie_FieldPathSelectorMonitoredResource:
		return fpvs.subPathValue.(common.MonitoredResource_FieldPathValue).CompareWith(source.GetMonitoredResource())
	default:
		panic(fmt.Sprintf("Invalid selector for Alert_Info_TimeSerie: %d", fpvs.Selector()))
	}
}

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

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

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

func MustParseAlertInfoTimeSerie_FieldPathArrayItemValue(pathStr, valueStr string) AlertInfoTimeSerie_FieldPathArrayItemValue {
	fpaiv, err := ParseAlertInfoTimeSerie_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type AlertInfoTimeSerie_FieldTerminalPathArrayItemValue struct {
	AlertInfoTimeSerie_FieldTerminalPath
	value interface{}
}

var _ AlertInfoTimeSerie_FieldPathArrayItemValue = (*AlertInfoTimeSerie_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *AlertInfoTimeSerie_FieldTerminalPathArrayItemValue) GetSingle(source *Alert_Info_TimeSerie) (interface{}, bool) {
	return nil, false
}

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

// Contains returns a boolean indicating if value that is being held is present in given 'TimeSerie'
func (fpaiv *AlertInfoTimeSerie_FieldTerminalPathArrayItemValue) ContainsValue(source *Alert_Info_TimeSerie) bool {
	slice := fpaiv.AlertInfoTimeSerie_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 AlertInfoTimeSerie_FieldSubPathArrayItemValue struct {
	AlertInfoTimeSerie_FieldPath
	subPathItemValue gotenobject.FieldPathArrayItemValue
}

// GetRawValue returns stored array item value
func (fpaivs *AlertInfoTimeSerie_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *AlertInfoTimeSerie_FieldSubPathArrayItemValue) AsMetricPathItemValue() (common.Metric_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(common.Metric_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *AlertInfoTimeSerie_FieldSubPathArrayItemValue) AsMonitoredResourcePathItemValue() (common.MonitoredResource_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(common.MonitoredResource_FieldPathArrayItemValue)
	return res, ok
}

// Contains returns a boolean indicating if value that is being held is present in given 'TimeSerie'
func (fpaivs *AlertInfoTimeSerie_FieldSubPathArrayItemValue) ContainsValue(source *Alert_Info_TimeSerie) bool {
	switch fpaivs.Selector() {
	case AlertInfoTimeSerie_FieldPathSelectorMetric:
		return fpaivs.subPathItemValue.(common.Metric_FieldPathArrayItemValue).ContainsValue(source.GetMetric())
	case AlertInfoTimeSerie_FieldPathSelectorMonitoredResource:
		return fpaivs.subPathItemValue.(common.MonitoredResource_FieldPathArrayItemValue).ContainsValue(source.GetMonitoredResource())
	default:
		panic(fmt.Sprintf("Invalid selector for Alert_Info_TimeSerie: %d", fpaivs.Selector()))
	}
}

// AlertInfoTimeSerie_FieldPathArrayOfValues allows storing slice of values for TimeSerie fields according to their type
type AlertInfoTimeSerie_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	AlertInfoTimeSerie_FieldPath
}

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

func MustParseAlertInfoTimeSerie_FieldPathArrayOfValues(pathStr, valuesStr string) AlertInfoTimeSerie_FieldPathArrayOfValues {
	fpaov, err := ParseAlertInfoTimeSerie_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type AlertInfoTimeSerie_FieldTerminalPathArrayOfValues struct {
	AlertInfoTimeSerie_FieldTerminalPath
	values interface{}
}

var _ AlertInfoTimeSerie_FieldPathArrayOfValues = (*AlertInfoTimeSerie_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *AlertInfoTimeSerie_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case AlertInfoTimeSerie_FieldPathSelectorKey:
		for _, v := range fpaov.values.([][]byte) {
			values = append(values, v)
		}
	case AlertInfoTimeSerie_FieldPathSelectorMetric:
		for _, v := range fpaov.values.([]*common.Metric) {
			values = append(values, v)
		}
	case AlertInfoTimeSerie_FieldPathSelectorMonitoredResource:
		for _, v := range fpaov.values.([]*common.MonitoredResource) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *AlertInfoTimeSerie_FieldTerminalPathArrayOfValues) AsKeyArrayOfValues() ([][]byte, bool) {
	res, ok := fpaov.values.([][]byte)
	return res, ok
}
func (fpaov *AlertInfoTimeSerie_FieldTerminalPathArrayOfValues) AsMetricArrayOfValues() ([]*common.Metric, bool) {
	res, ok := fpaov.values.([]*common.Metric)
	return res, ok
}
func (fpaov *AlertInfoTimeSerie_FieldTerminalPathArrayOfValues) AsMonitoredResourceArrayOfValues() ([]*common.MonitoredResource, bool) {
	res, ok := fpaov.values.([]*common.MonitoredResource)
	return res, ok
}

type AlertInfoTimeSerie_FieldSubPathArrayOfValues struct {
	AlertInfoTimeSerie_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ AlertInfoTimeSerie_FieldPathArrayOfValues = (*AlertInfoTimeSerie_FieldSubPathArrayOfValues)(nil)

func (fpsaov *AlertInfoTimeSerie_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *AlertInfoTimeSerie_FieldSubPathArrayOfValues) AsMetricPathArrayOfValues() (common.Metric_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(common.Metric_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *AlertInfoTimeSerie_FieldSubPathArrayOfValues) AsMonitoredResourcePathArrayOfValues() (common.MonitoredResource_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(common.MonitoredResource_FieldPathArrayOfValues)
	return res, ok
}

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

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

type AlertInfoObservedValues_FieldPathSelector int32

const (
	AlertInfoObservedValues_FieldPathSelectorExampleValue AlertInfoObservedValues_FieldPathSelector = 0
	AlertInfoObservedValues_FieldPathSelectorPerMetric    AlertInfoObservedValues_FieldPathSelector = 1
)

func (s AlertInfoObservedValues_FieldPathSelector) String() string {
	switch s {
	case AlertInfoObservedValues_FieldPathSelectorExampleValue:
		return "example_value"
	case AlertInfoObservedValues_FieldPathSelectorPerMetric:
		return "per_metric"
	default:
		panic(fmt.Sprintf("Invalid selector for Alert_Info_ObservedValues: %d", s))
	}
}

func BuildAlertInfoObservedValues_FieldPath(fp gotenobject.RawFieldPath) (AlertInfoObservedValues_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object Alert_Info_ObservedValues")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "example_value", "exampleValue", "example-value":
			return &AlertInfoObservedValues_FieldTerminalPath{selector: AlertInfoObservedValues_FieldPathSelectorExampleValue}, nil
		case "per_metric", "perMetric", "per-metric":
			return &AlertInfoObservedValues_FieldTerminalPath{selector: AlertInfoObservedValues_FieldPathSelectorPerMetric}, nil
		}
	} else {
		switch fp[0] {
		case "per_metric", "perMetric", "per-metric":
			if len(fp) > 2 {
				return nil, status.Errorf(codes.InvalidArgument, "sub path for maps ('%s') are not supported (object Alert_Info_ObservedValues)", fp)
			}
			return &AlertInfoObservedValues_FieldPathMap{selector: AlertInfoObservedValues_FieldPathSelectorPerMetric, key: fp[1]}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object Alert_Info_ObservedValues", fp)
}

func ParseAlertInfoObservedValues_FieldPath(rawField string) (AlertInfoObservedValues_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildAlertInfoObservedValues_FieldPath(fp)
}

func MustParseAlertInfoObservedValues_FieldPath(rawField string) AlertInfoObservedValues_FieldPath {
	fp, err := ParseAlertInfoObservedValues_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type AlertInfoObservedValues_FieldTerminalPath struct {
	selector AlertInfoObservedValues_FieldPathSelector
}

var _ AlertInfoObservedValues_FieldPath = (*AlertInfoObservedValues_FieldTerminalPath)(nil)

func (fp *AlertInfoObservedValues_FieldTerminalPath) Selector() AlertInfoObservedValues_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

// GetDefault returns a default value of the field type
func (fp *AlertInfoObservedValues_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case AlertInfoObservedValues_FieldPathSelectorExampleValue:
		return float64(0)
	case AlertInfoObservedValues_FieldPathSelectorPerMetric:
		return (map[string]float64)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for Alert_Info_ObservedValues: %d", fp.selector))
	}
}

func (fp *AlertInfoObservedValues_FieldTerminalPath) ClearValue(item *Alert_Info_ObservedValues) {
	if item != nil {
		switch fp.selector {
		case AlertInfoObservedValues_FieldPathSelectorExampleValue:
			item.ExampleValue = float64(0)
		case AlertInfoObservedValues_FieldPathSelectorPerMetric:
			item.PerMetric = nil
		default:
			panic(fmt.Sprintf("Invalid selector for Alert_Info_ObservedValues: %d", fp.selector))
		}
	}
}

func (fp *AlertInfoObservedValues_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*Alert_Info_ObservedValues))
}

// IsLeaf - whether field path is holds simple value
func (fp *AlertInfoObservedValues_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == AlertInfoObservedValues_FieldPathSelectorExampleValue ||
		fp.selector == AlertInfoObservedValues_FieldPathSelectorPerMetric
}

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

func (fp *AlertInfoObservedValues_FieldTerminalPath) WithIValue(value interface{}) AlertInfoObservedValues_FieldPathValue {
	switch fp.selector {
	case AlertInfoObservedValues_FieldPathSelectorExampleValue:
		return &AlertInfoObservedValues_FieldTerminalPathValue{AlertInfoObservedValues_FieldTerminalPath: *fp, value: value.(float64)}
	case AlertInfoObservedValues_FieldPathSelectorPerMetric:
		return &AlertInfoObservedValues_FieldTerminalPathValue{AlertInfoObservedValues_FieldTerminalPath: *fp, value: value.(map[string]float64)}
	default:
		panic(fmt.Sprintf("Invalid selector for Alert_Info_ObservedValues: %d", fp.selector))
	}
}

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

func (fp *AlertInfoObservedValues_FieldTerminalPath) WithIArrayOfValues(values interface{}) AlertInfoObservedValues_FieldPathArrayOfValues {
	fpaov := &AlertInfoObservedValues_FieldTerminalPathArrayOfValues{AlertInfoObservedValues_FieldTerminalPath: *fp}
	switch fp.selector {
	case AlertInfoObservedValues_FieldPathSelectorExampleValue:
		return &AlertInfoObservedValues_FieldTerminalPathArrayOfValues{AlertInfoObservedValues_FieldTerminalPath: *fp, values: values.([]float64)}
	case AlertInfoObservedValues_FieldPathSelectorPerMetric:
		return &AlertInfoObservedValues_FieldTerminalPathArrayOfValues{AlertInfoObservedValues_FieldTerminalPath: *fp, values: values.([]map[string]float64)}
	default:
		panic(fmt.Sprintf("Invalid selector for Alert_Info_ObservedValues: %d", fp.selector))
	}
	return fpaov
}

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

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

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

// FieldPath for map type with additional Key information
type AlertInfoObservedValues_FieldPathMap struct {
	key      string
	selector AlertInfoObservedValues_FieldPathSelector
}

var _ AlertInfoObservedValues_FieldPath = (*AlertInfoObservedValues_FieldPathMap)(nil)

func (fpm *AlertInfoObservedValues_FieldPathMap) Selector() AlertInfoObservedValues_FieldPathSelector {
	return fpm.selector
}

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

// String returns path representation in proto convention
func (fpm *AlertInfoObservedValues_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 *AlertInfoObservedValues_FieldPathMap) JSONString() string {
	return strcase.ToLowerCamel(fpm.selector.String()) + "." + fpm.key
}

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

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

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

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

// GetDefault returns a default value of the field type
func (fpm *AlertInfoObservedValues_FieldPathMap) GetDefault() interface{} {
	switch fpm.selector {
	case AlertInfoObservedValues_FieldPathSelectorPerMetric:
		var v float64
		return v
	default:
		panic(fmt.Sprintf("Invalid selector for Alert_Info_ObservedValues: %d", fpm.selector))
	}
}

func (fpm *AlertInfoObservedValues_FieldPathMap) ClearValue(item *Alert_Info_ObservedValues) {
	if item != nil {
		switch fpm.selector {
		case AlertInfoObservedValues_FieldPathSelectorPerMetric:
			delete(item.PerMetric, fpm.key)
		default:
			panic(fmt.Sprintf("Invalid selector for Alert_Info_ObservedValues: %d", fpm.selector))
		}
	}
}

func (fpm *AlertInfoObservedValues_FieldPathMap) ClearValueRaw(item proto.Message) {
	fpm.ClearValue(item.(*Alert_Info_ObservedValues))
}

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

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

func (fpm *AlertInfoObservedValues_FieldPathMap) WithIValue(value interface{}) AlertInfoObservedValues_FieldPathValue {
	switch fpm.selector {
	case AlertInfoObservedValues_FieldPathSelectorPerMetric:
		return &AlertInfoObservedValues_FieldPathMapValue{AlertInfoObservedValues_FieldPathMap: *fpm, value: value.(float64)}
	default:
		panic(fmt.Sprintf("Invalid selector for Alert_Info_ObservedValues: %d", fpm.selector))
	}
}

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

func (fpm *AlertInfoObservedValues_FieldPathMap) WithIArrayOfValues(values interface{}) AlertInfoObservedValues_FieldPathArrayOfValues {
	switch fpm.selector {
	case AlertInfoObservedValues_FieldPathSelectorPerMetric:
		return &AlertInfoObservedValues_FieldPathMapArrayOfValues{AlertInfoObservedValues_FieldPathMap: *fpm, values: values.([]float64)}
	default:
		panic(fmt.Sprintf("Invalid selector for Alert_Info_ObservedValues: %d", fpm.selector))
	}
}

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

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

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

// AlertInfoObservedValues_FieldPathValue allows storing values for ObservedValues fields according to their type
type AlertInfoObservedValues_FieldPathValue interface {
	AlertInfoObservedValues_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **Alert_Info_ObservedValues)
	CompareWith(*Alert_Info_ObservedValues) (cmp int, comparable bool)
}

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

func MustParseAlertInfoObservedValues_FieldPathValue(pathStr, valueStr string) AlertInfoObservedValues_FieldPathValue {
	fpv, err := ParseAlertInfoObservedValues_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type AlertInfoObservedValues_FieldTerminalPathValue struct {
	AlertInfoObservedValues_FieldTerminalPath
	value interface{}
}

var _ AlertInfoObservedValues_FieldPathValue = (*AlertInfoObservedValues_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'ObservedValues' as interface{}
func (fpv *AlertInfoObservedValues_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *AlertInfoObservedValues_FieldTerminalPathValue) AsExampleValueValue() (float64, bool) {
	res, ok := fpv.value.(float64)
	return res, ok
}
func (fpv *AlertInfoObservedValues_FieldTerminalPathValue) AsPerMetricValue() (map[string]float64, bool) {
	res, ok := fpv.value.(map[string]float64)
	return res, ok
}

// SetTo stores value for selected field for object ObservedValues
func (fpv *AlertInfoObservedValues_FieldTerminalPathValue) SetTo(target **Alert_Info_ObservedValues) {
	if *target == nil {
		*target = new(Alert_Info_ObservedValues)
	}
	switch fpv.selector {
	case AlertInfoObservedValues_FieldPathSelectorExampleValue:
		(*target).ExampleValue = fpv.value.(float64)
	case AlertInfoObservedValues_FieldPathSelectorPerMetric:
		(*target).PerMetric = fpv.value.(map[string]float64)
	default:
		panic(fmt.Sprintf("Invalid selector for Alert_Info_ObservedValues: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'AlertInfoObservedValues_FieldTerminalPathValue' with the value under path in 'Alert_Info_ObservedValues'.
func (fpv *AlertInfoObservedValues_FieldTerminalPathValue) CompareWith(source *Alert_Info_ObservedValues) (int, bool) {
	switch fpv.selector {
	case AlertInfoObservedValues_FieldPathSelectorExampleValue:
		leftValue := fpv.value.(float64)
		rightValue := source.GetExampleValue()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case AlertInfoObservedValues_FieldPathSelectorPerMetric:
		return 0, false
	default:
		panic(fmt.Sprintf("Invalid selector for Alert_Info_ObservedValues: %d", fpv.selector))
	}
}

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

type AlertInfoObservedValues_FieldPathMapValue struct {
	AlertInfoObservedValues_FieldPathMap
	value interface{}
}

var _ AlertInfoObservedValues_FieldPathValue = (*AlertInfoObservedValues_FieldPathMapValue)(nil)

// GetValue returns value stored under selected field in ObservedValues as interface{}
func (fpmv *AlertInfoObservedValues_FieldPathMapValue) GetRawValue() interface{} {
	return fpmv.value
}
func (fpmv *AlertInfoObservedValues_FieldPathMapValue) AsPerMetricElementValue() (float64, bool) {
	res, ok := fpmv.value.(float64)
	return res, ok
}

// SetTo stores value for selected field in ObservedValues
func (fpmv *AlertInfoObservedValues_FieldPathMapValue) SetTo(target **Alert_Info_ObservedValues) {
	if *target == nil {
		*target = new(Alert_Info_ObservedValues)
	}
	switch fpmv.selector {
	case AlertInfoObservedValues_FieldPathSelectorPerMetric:
		if (*target).PerMetric == nil {
			(*target).PerMetric = make(map[string]float64)
		}
		(*target).PerMetric[fpmv.key] = fpmv.value.(float64)
	default:
		panic(fmt.Sprintf("Invalid selector for Alert_Info_ObservedValues: %d", fpmv.selector))
	}
}

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

// CompareWith compares value in the 'AlertInfoObservedValues_FieldPathMapValue' with the value under path in 'Alert_Info_ObservedValues'.
func (fpmv *AlertInfoObservedValues_FieldPathMapValue) CompareWith(source *Alert_Info_ObservedValues) (int, bool) {
	switch fpmv.selector {
	case AlertInfoObservedValues_FieldPathSelectorPerMetric:
		leftValue := fpmv.value.(float64)
		rightValue := source.GetPerMetric()[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 Alert_Info_ObservedValues: %d", fpmv.selector))
	}
}

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

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

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

func MustParseAlertInfoObservedValues_FieldPathArrayItemValue(pathStr, valueStr string) AlertInfoObservedValues_FieldPathArrayItemValue {
	fpaiv, err := ParseAlertInfoObservedValues_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type AlertInfoObservedValues_FieldTerminalPathArrayItemValue struct {
	AlertInfoObservedValues_FieldTerminalPath
	value interface{}
}

var _ AlertInfoObservedValues_FieldPathArrayItemValue = (*AlertInfoObservedValues_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *AlertInfoObservedValues_FieldTerminalPathArrayItemValue) GetSingle(source *Alert_Info_ObservedValues) (interface{}, bool) {
	return nil, false
}

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

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

// AlertInfoObservedValues_FieldPathArrayOfValues allows storing slice of values for ObservedValues fields according to their type
type AlertInfoObservedValues_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	AlertInfoObservedValues_FieldPath
}

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

func MustParseAlertInfoObservedValues_FieldPathArrayOfValues(pathStr, valuesStr string) AlertInfoObservedValues_FieldPathArrayOfValues {
	fpaov, err := ParseAlertInfoObservedValues_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type AlertInfoObservedValues_FieldTerminalPathArrayOfValues struct {
	AlertInfoObservedValues_FieldTerminalPath
	values interface{}
}

var _ AlertInfoObservedValues_FieldPathArrayOfValues = (*AlertInfoObservedValues_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *AlertInfoObservedValues_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case AlertInfoObservedValues_FieldPathSelectorExampleValue:
		for _, v := range fpaov.values.([]float64) {
			values = append(values, v)
		}
	case AlertInfoObservedValues_FieldPathSelectorPerMetric:
		for _, v := range fpaov.values.([]map[string]float64) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *AlertInfoObservedValues_FieldTerminalPathArrayOfValues) AsExampleValueArrayOfValues() ([]float64, bool) {
	res, ok := fpaov.values.([]float64)
	return res, ok
}
func (fpaov *AlertInfoObservedValues_FieldTerminalPathArrayOfValues) AsPerMetricArrayOfValues() ([]map[string]float64, bool) {
	res, ok := fpaov.values.([]map[string]float64)
	return res, ok
}

type AlertInfoObservedValues_FieldPathMapArrayOfValues struct {
	AlertInfoObservedValues_FieldPathMap
	values interface{}
}

var _ AlertInfoObservedValues_FieldPathArrayOfValues = (*AlertInfoObservedValues_FieldPathMapArrayOfValues)(nil)

func (fpmaov *AlertInfoObservedValues_FieldPathMapArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpmaov.selector {
	case AlertInfoObservedValues_FieldPathSelectorPerMetric:
		for _, v := range fpmaov.values.([]float64) {
			values = append(values, v)
		}
	}
	return
}
func (fpmaov *AlertInfoObservedValues_FieldPathMapArrayOfValues) AsPerMetricArrayOfElementValues() ([]float64, bool) {
	res, ok := fpmaov.values.([]float64)
	return res, ok
}

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

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

type AlertStateThreshold_FieldPathSelector int32

const (
	AlertStateThreshold_FieldPathSelectorObservedValue AlertStateThreshold_FieldPathSelector = 0
)

func (s AlertStateThreshold_FieldPathSelector) String() string {
	switch s {
	case AlertStateThreshold_FieldPathSelectorObservedValue:
		return "observed_value"
	default:
		panic(fmt.Sprintf("Invalid selector for Alert_State_Threshold: %d", s))
	}
}

func BuildAlertStateThreshold_FieldPath(fp gotenobject.RawFieldPath) (AlertStateThreshold_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object Alert_State_Threshold")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "observed_value", "observedValue", "observed-value":
			return &AlertStateThreshold_FieldTerminalPath{selector: AlertStateThreshold_FieldPathSelectorObservedValue}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object Alert_State_Threshold", fp)
}

func ParseAlertStateThreshold_FieldPath(rawField string) (AlertStateThreshold_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildAlertStateThreshold_FieldPath(fp)
}

func MustParseAlertStateThreshold_FieldPath(rawField string) AlertStateThreshold_FieldPath {
	fp, err := ParseAlertStateThreshold_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type AlertStateThreshold_FieldTerminalPath struct {
	selector AlertStateThreshold_FieldPathSelector
}

var _ AlertStateThreshold_FieldPath = (*AlertStateThreshold_FieldTerminalPath)(nil)

func (fp *AlertStateThreshold_FieldTerminalPath) Selector() AlertStateThreshold_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

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

func (fp *AlertStateThreshold_FieldTerminalPath) ClearValue(item *Alert_State_Threshold) {
	if item != nil {
		switch fp.selector {
		case AlertStateThreshold_FieldPathSelectorObservedValue:
			item.ObservedValue = float64(0)
		default:
			panic(fmt.Sprintf("Invalid selector for Alert_State_Threshold: %d", fp.selector))
		}
	}
}

func (fp *AlertStateThreshold_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*Alert_State_Threshold))
}

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

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

func (fp *AlertStateThreshold_FieldTerminalPath) WithIValue(value interface{}) AlertStateThreshold_FieldPathValue {
	switch fp.selector {
	case AlertStateThreshold_FieldPathSelectorObservedValue:
		return &AlertStateThreshold_FieldTerminalPathValue{AlertStateThreshold_FieldTerminalPath: *fp, value: value.(float64)}
	default:
		panic(fmt.Sprintf("Invalid selector for Alert_State_Threshold: %d", fp.selector))
	}
}

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

func (fp *AlertStateThreshold_FieldTerminalPath) WithIArrayOfValues(values interface{}) AlertStateThreshold_FieldPathArrayOfValues {
	fpaov := &AlertStateThreshold_FieldTerminalPathArrayOfValues{AlertStateThreshold_FieldTerminalPath: *fp}
	switch fp.selector {
	case AlertStateThreshold_FieldPathSelectorObservedValue:
		return &AlertStateThreshold_FieldTerminalPathArrayOfValues{AlertStateThreshold_FieldTerminalPath: *fp, values: values.([]float64)}
	default:
		panic(fmt.Sprintf("Invalid selector for Alert_State_Threshold: %d", fp.selector))
	}
	return fpaov
}

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

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

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

// AlertStateThreshold_FieldPathValue allows storing values for Threshold fields according to their type
type AlertStateThreshold_FieldPathValue interface {
	AlertStateThreshold_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **Alert_State_Threshold)
	CompareWith(*Alert_State_Threshold) (cmp int, comparable bool)
}

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

func MustParseAlertStateThreshold_FieldPathValue(pathStr, valueStr string) AlertStateThreshold_FieldPathValue {
	fpv, err := ParseAlertStateThreshold_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type AlertStateThreshold_FieldTerminalPathValue struct {
	AlertStateThreshold_FieldTerminalPath
	value interface{}
}

var _ AlertStateThreshold_FieldPathValue = (*AlertStateThreshold_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'Threshold' as interface{}
func (fpv *AlertStateThreshold_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *AlertStateThreshold_FieldTerminalPathValue) AsObservedValueValue() (float64, bool) {
	res, ok := fpv.value.(float64)
	return res, ok
}

// SetTo stores value for selected field for object Threshold
func (fpv *AlertStateThreshold_FieldTerminalPathValue) SetTo(target **Alert_State_Threshold) {
	if *target == nil {
		*target = new(Alert_State_Threshold)
	}
	switch fpv.selector {
	case AlertStateThreshold_FieldPathSelectorObservedValue:
		(*target).ObservedValue = fpv.value.(float64)
	default:
		panic(fmt.Sprintf("Invalid selector for Alert_State_Threshold: %d", fpv.selector))
	}
}

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

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

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

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

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

func MustParseAlertStateThreshold_FieldPathArrayItemValue(pathStr, valueStr string) AlertStateThreshold_FieldPathArrayItemValue {
	fpaiv, err := ParseAlertStateThreshold_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type AlertStateThreshold_FieldTerminalPathArrayItemValue struct {
	AlertStateThreshold_FieldTerminalPath
	value interface{}
}

var _ AlertStateThreshold_FieldPathArrayItemValue = (*AlertStateThreshold_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *AlertStateThreshold_FieldTerminalPathArrayItemValue) GetSingle(source *Alert_State_Threshold) (interface{}, bool) {
	return nil, false
}

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

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

// AlertStateThreshold_FieldPathArrayOfValues allows storing slice of values for Threshold fields according to their type
type AlertStateThreshold_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	AlertStateThreshold_FieldPath
}

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

func MustParseAlertStateThreshold_FieldPathArrayOfValues(pathStr, valuesStr string) AlertStateThreshold_FieldPathArrayOfValues {
	fpaov, err := ParseAlertStateThreshold_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type AlertStateThreshold_FieldTerminalPathArrayOfValues struct {
	AlertStateThreshold_FieldTerminalPath
	values interface{}
}

var _ AlertStateThreshold_FieldPathArrayOfValues = (*AlertStateThreshold_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *AlertStateThreshold_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case AlertStateThreshold_FieldPathSelectorObservedValue:
		for _, v := range fpaov.values.([]float64) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *AlertStateThreshold_FieldTerminalPathArrayOfValues) AsObservedValueArrayOfValues() ([]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 AlertStateCombineThreshold_FieldPath interface {
	gotenobject.FieldPath
	Selector() AlertStateCombineThreshold_FieldPathSelector
	Get(source *Alert_State_CombineThreshold) []interface{}
	GetSingle(source *Alert_State_CombineThreshold) (interface{}, bool)
	ClearValue(item *Alert_State_CombineThreshold)

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

type AlertStateCombineThreshold_FieldPathSelector int32

func (s AlertStateCombineThreshold_FieldPathSelector) String() string {
	switch s {
	default:
		panic(fmt.Sprintf("Invalid selector for Alert_State_CombineThreshold: %d", s))
	}
}

func BuildAlertStateCombineThreshold_FieldPath(fp gotenobject.RawFieldPath) (AlertStateCombineThreshold_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object Alert_State_CombineThreshold")
	}
	if len(fp) == 1 {
		switch fp[0] {
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object Alert_State_CombineThreshold", fp)
}

func ParseAlertStateCombineThreshold_FieldPath(rawField string) (AlertStateCombineThreshold_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildAlertStateCombineThreshold_FieldPath(fp)
}

func MustParseAlertStateCombineThreshold_FieldPath(rawField string) AlertStateCombineThreshold_FieldPath {
	fp, err := ParseAlertStateCombineThreshold_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type AlertStateCombineThreshold_FieldTerminalPath struct {
	selector AlertStateCombineThreshold_FieldPathSelector
}

var _ AlertStateCombineThreshold_FieldPath = (*AlertStateCombineThreshold_FieldTerminalPath)(nil)

func (fp *AlertStateCombineThreshold_FieldTerminalPath) Selector() AlertStateCombineThreshold_FieldPathSelector {
	return fp.selector
}

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

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

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

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

// GetSingle returns value pointed by specific field of from source Alert_State_CombineThreshold
func (fp *AlertStateCombineThreshold_FieldTerminalPath) GetSingle(source *Alert_State_CombineThreshold) (interface{}, bool) {
	switch fp.selector {
	default:
		panic(fmt.Sprintf("Invalid selector for Alert_State_CombineThreshold: %d", fp.selector))
	}
}

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

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

func (fp *AlertStateCombineThreshold_FieldTerminalPath) ClearValue(item *Alert_State_CombineThreshold) {
	if item != nil {
		switch fp.selector {
		default:
			panic(fmt.Sprintf("Invalid selector for Alert_State_CombineThreshold: %d", fp.selector))
		}
	}
}

func (fp *AlertStateCombineThreshold_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*Alert_State_CombineThreshold))
}

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

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

func (fp *AlertStateCombineThreshold_FieldTerminalPath) WithIValue(value interface{}) AlertStateCombineThreshold_FieldPathValue {
	switch fp.selector {
	default:
		panic(fmt.Sprintf("Invalid selector for Alert_State_CombineThreshold: %d", fp.selector))
	}
}

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

func (fp *AlertStateCombineThreshold_FieldTerminalPath) WithIArrayOfValues(values interface{}) AlertStateCombineThreshold_FieldPathArrayOfValues {
	fpaov := &AlertStateCombineThreshold_FieldTerminalPathArrayOfValues{AlertStateCombineThreshold_FieldTerminalPath: *fp}
	switch fp.selector {
	default:
		panic(fmt.Sprintf("Invalid selector for Alert_State_CombineThreshold: %d", fp.selector))
	}
	return fpaov
}

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

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

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

// AlertStateCombineThreshold_FieldPathValue allows storing values for CombineThreshold fields according to their type
type AlertStateCombineThreshold_FieldPathValue interface {
	AlertStateCombineThreshold_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **Alert_State_CombineThreshold)
	CompareWith(*Alert_State_CombineThreshold) (cmp int, comparable bool)
}

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

func MustParseAlertStateCombineThreshold_FieldPathValue(pathStr, valueStr string) AlertStateCombineThreshold_FieldPathValue {
	fpv, err := ParseAlertStateCombineThreshold_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type AlertStateCombineThreshold_FieldTerminalPathValue struct {
	AlertStateCombineThreshold_FieldTerminalPath
	value interface{}
}

var _ AlertStateCombineThreshold_FieldPathValue = (*AlertStateCombineThreshold_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'CombineThreshold' as interface{}
func (fpv *AlertStateCombineThreshold_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}

// SetTo stores value for selected field for object CombineThreshold
func (fpv *AlertStateCombineThreshold_FieldTerminalPathValue) SetTo(target **Alert_State_CombineThreshold) {
	if *target == nil {
		*target = new(Alert_State_CombineThreshold)
	}
	switch fpv.selector {
	default:
		panic(fmt.Sprintf("Invalid selector for Alert_State_CombineThreshold: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'AlertStateCombineThreshold_FieldTerminalPathValue' with the value under path in 'Alert_State_CombineThreshold'.
func (fpv *AlertStateCombineThreshold_FieldTerminalPathValue) CompareWith(source *Alert_State_CombineThreshold) (int, bool) {
	switch fpv.selector {
	default:
		panic(fmt.Sprintf("Invalid selector for Alert_State_CombineThreshold: %d", fpv.selector))
	}
}

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

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

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

func MustParseAlertStateCombineThreshold_FieldPathArrayItemValue(pathStr, valueStr string) AlertStateCombineThreshold_FieldPathArrayItemValue {
	fpaiv, err := ParseAlertStateCombineThreshold_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type AlertStateCombineThreshold_FieldTerminalPathArrayItemValue struct {
	AlertStateCombineThreshold_FieldTerminalPath
	value interface{}
}

var _ AlertStateCombineThreshold_FieldPathArrayItemValue = (*AlertStateCombineThreshold_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *AlertStateCombineThreshold_FieldTerminalPathArrayItemValue) GetSingle(source *Alert_State_CombineThreshold) (interface{}, bool) {
	return nil, false
}

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

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

// AlertStateCombineThreshold_FieldPathArrayOfValues allows storing slice of values for CombineThreshold fields according to their type
type AlertStateCombineThreshold_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	AlertStateCombineThreshold_FieldPath
}

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

func MustParseAlertStateCombineThreshold_FieldPathArrayOfValues(pathStr, valuesStr string) AlertStateCombineThreshold_FieldPathArrayOfValues {
	fpaov, err := ParseAlertStateCombineThreshold_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type AlertStateCombineThreshold_FieldTerminalPathArrayOfValues struct {
	AlertStateCombineThreshold_FieldTerminalPath
	values interface{}
}

var _ AlertStateCombineThreshold_FieldPathArrayOfValues = (*AlertStateCombineThreshold_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *AlertStateCombineThreshold_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	}
	return
}

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

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

type AlertStateCombineThresholdPerMetric_FieldPathSelector int32

const (
	AlertStateCombineThresholdPerMetric_FieldPathSelectorObservedValues AlertStateCombineThresholdPerMetric_FieldPathSelector = 0
)

func (s AlertStateCombineThresholdPerMetric_FieldPathSelector) String() string {
	switch s {
	case AlertStateCombineThresholdPerMetric_FieldPathSelectorObservedValues:
		return "observed_values"
	default:
		panic(fmt.Sprintf("Invalid selector for Alert_State_CombineThreshold_PerMetric: %d", s))
	}
}

func BuildAlertStateCombineThresholdPerMetric_FieldPath(fp gotenobject.RawFieldPath) (AlertStateCombineThresholdPerMetric_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object Alert_State_CombineThreshold_PerMetric")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "observed_values", "observedValues", "observed-values":
			return &AlertStateCombineThresholdPerMetric_FieldTerminalPath{selector: AlertStateCombineThresholdPerMetric_FieldPathSelectorObservedValues}, nil
		}
	} else {
		switch fp[0] {
		case "observed_values", "observedValues", "observed-values":
			if len(fp) > 2 {
				return nil, status.Errorf(codes.InvalidArgument, "sub path for maps ('%s') are not supported (object Alert_State_CombineThreshold_PerMetric)", fp)
			}
			return &AlertStateCombineThresholdPerMetric_FieldPathMap{selector: AlertStateCombineThresholdPerMetric_FieldPathSelectorObservedValues, key: fp[1]}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object Alert_State_CombineThreshold_PerMetric", fp)
}

func ParseAlertStateCombineThresholdPerMetric_FieldPath(rawField string) (AlertStateCombineThresholdPerMetric_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildAlertStateCombineThresholdPerMetric_FieldPath(fp)
}

func MustParseAlertStateCombineThresholdPerMetric_FieldPath(rawField string) AlertStateCombineThresholdPerMetric_FieldPath {
	fp, err := ParseAlertStateCombineThresholdPerMetric_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type AlertStateCombineThresholdPerMetric_FieldTerminalPath struct {
	selector AlertStateCombineThresholdPerMetric_FieldPathSelector
}

var _ AlertStateCombineThresholdPerMetric_FieldPath = (*AlertStateCombineThresholdPerMetric_FieldTerminalPath)(nil)

func (fp *AlertStateCombineThresholdPerMetric_FieldTerminalPath) Selector() AlertStateCombineThresholdPerMetric_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

// GetDefault returns a default value of the field type
func (fp *AlertStateCombineThresholdPerMetric_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case AlertStateCombineThresholdPerMetric_FieldPathSelectorObservedValues:
		return (map[string]float64)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for Alert_State_CombineThreshold_PerMetric: %d", fp.selector))
	}
}

func (fp *AlertStateCombineThresholdPerMetric_FieldTerminalPath) ClearValue(item *Alert_State_CombineThreshold_PerMetric) {
	if item != nil {
		switch fp.selector {
		case AlertStateCombineThresholdPerMetric_FieldPathSelectorObservedValues:
			item.ObservedValues = nil
		default:
			panic(fmt.Sprintf("Invalid selector for Alert_State_CombineThreshold_PerMetric: %d", fp.selector))
		}
	}
}

func (fp *AlertStateCombineThresholdPerMetric_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*Alert_State_CombineThreshold_PerMetric))
}

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

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

func (fp *AlertStateCombineThresholdPerMetric_FieldTerminalPath) WithIValue(value interface{}) AlertStateCombineThresholdPerMetric_FieldPathValue {
	switch fp.selector {
	case AlertStateCombineThresholdPerMetric_FieldPathSelectorObservedValues:
		return &AlertStateCombineThresholdPerMetric_FieldTerminalPathValue{AlertStateCombineThresholdPerMetric_FieldTerminalPath: *fp, value: value.(map[string]float64)}
	default:
		panic(fmt.Sprintf("Invalid selector for Alert_State_CombineThreshold_PerMetric: %d", fp.selector))
	}
}

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

func (fp *AlertStateCombineThresholdPerMetric_FieldTerminalPath) WithIArrayOfValues(values interface{}) AlertStateCombineThresholdPerMetric_FieldPathArrayOfValues {
	fpaov := &AlertStateCombineThresholdPerMetric_FieldTerminalPathArrayOfValues{AlertStateCombineThresholdPerMetric_FieldTerminalPath: *fp}
	switch fp.selector {
	case AlertStateCombineThresholdPerMetric_FieldPathSelectorObservedValues:
		return &AlertStateCombineThresholdPerMetric_FieldTerminalPathArrayOfValues{AlertStateCombineThresholdPerMetric_FieldTerminalPath: *fp, values: values.([]map[string]float64)}
	default:
		panic(fmt.Sprintf("Invalid selector for Alert_State_CombineThreshold_PerMetric: %d", fp.selector))
	}
	return fpaov
}

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

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

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

// FieldPath for map type with additional Key information
type AlertStateCombineThresholdPerMetric_FieldPathMap struct {
	key      string
	selector AlertStateCombineThresholdPerMetric_FieldPathSelector
}

var _ AlertStateCombineThresholdPerMetric_FieldPath = (*AlertStateCombineThresholdPerMetric_FieldPathMap)(nil)

func (fpm *AlertStateCombineThresholdPerMetric_FieldPathMap) Selector() AlertStateCombineThresholdPerMetric_FieldPathSelector {
	return fpm.selector
}

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

// String returns path representation in proto convention
func (fpm *AlertStateCombineThresholdPerMetric_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 *AlertStateCombineThresholdPerMetric_FieldPathMap) JSONString() string {
	return strcase.ToLowerCamel(fpm.selector.String()) + "." + fpm.key
}

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

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

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

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

// GetDefault returns a default value of the field type
func (fpm *AlertStateCombineThresholdPerMetric_FieldPathMap) GetDefault() interface{} {
	switch fpm.selector {
	case AlertStateCombineThresholdPerMetric_FieldPathSelectorObservedValues:
		var v float64
		return v
	default:
		panic(fmt.Sprintf("Invalid selector for Alert_State_CombineThreshold_PerMetric: %d", fpm.selector))
	}
}

func (fpm *AlertStateCombineThresholdPerMetric_FieldPathMap) ClearValue(item *Alert_State_CombineThreshold_PerMetric) {
	if item != nil {
		switch fpm.selector {
		case AlertStateCombineThresholdPerMetric_FieldPathSelectorObservedValues:
			delete(item.ObservedValues, fpm.key)
		default:
			panic(fmt.Sprintf("Invalid selector for Alert_State_CombineThreshold_PerMetric: %d", fpm.selector))
		}
	}
}

func (fpm *AlertStateCombineThresholdPerMetric_FieldPathMap) ClearValueRaw(item proto.Message) {
	fpm.ClearValue(item.(*Alert_State_CombineThreshold_PerMetric))
}

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

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

func (fpm *AlertStateCombineThresholdPerMetric_FieldPathMap) WithIValue(value interface{}) AlertStateCombineThresholdPerMetric_FieldPathValue {
	switch fpm.selector {
	case AlertStateCombineThresholdPerMetric_FieldPathSelectorObservedValues:
		return &AlertStateCombineThresholdPerMetric_FieldPathMapValue{AlertStateCombineThresholdPerMetric_FieldPathMap: *fpm, value: value.(float64)}
	default:
		panic(fmt.Sprintf("Invalid selector for Alert_State_CombineThreshold_PerMetric: %d", fpm.selector))
	}
}

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

func (fpm *AlertStateCombineThresholdPerMetric_FieldPathMap) WithIArrayOfValues(values interface{}) AlertStateCombineThresholdPerMetric_FieldPathArrayOfValues {
	switch fpm.selector {
	case AlertStateCombineThresholdPerMetric_FieldPathSelectorObservedValues:
		return &AlertStateCombineThresholdPerMetric_FieldPathMapArrayOfValues{AlertStateCombineThresholdPerMetric_FieldPathMap: *fpm, values: values.([]float64)}
	default:
		panic(fmt.Sprintf("Invalid selector for Alert_State_CombineThreshold_PerMetric: %d", fpm.selector))
	}
}

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

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

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

// AlertStateCombineThresholdPerMetric_FieldPathValue allows storing values for PerMetric fields according to their type
type AlertStateCombineThresholdPerMetric_FieldPathValue interface {
	AlertStateCombineThresholdPerMetric_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **Alert_State_CombineThreshold_PerMetric)
	CompareWith(*Alert_State_CombineThreshold_PerMetric) (cmp int, comparable bool)
}

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

func MustParseAlertStateCombineThresholdPerMetric_FieldPathValue(pathStr, valueStr string) AlertStateCombineThresholdPerMetric_FieldPathValue {
	fpv, err := ParseAlertStateCombineThresholdPerMetric_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type AlertStateCombineThresholdPerMetric_FieldTerminalPathValue struct {
	AlertStateCombineThresholdPerMetric_FieldTerminalPath
	value interface{}
}

var _ AlertStateCombineThresholdPerMetric_FieldPathValue = (*AlertStateCombineThresholdPerMetric_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'PerMetric' as interface{}
func (fpv *AlertStateCombineThresholdPerMetric_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *AlertStateCombineThresholdPerMetric_FieldTerminalPathValue) AsObservedValuesValue() (map[string]float64, bool) {
	res, ok := fpv.value.(map[string]float64)
	return res, ok
}

// SetTo stores value for selected field for object PerMetric
func (fpv *AlertStateCombineThresholdPerMetric_FieldTerminalPathValue) SetTo(target **Alert_State_CombineThreshold_PerMetric) {
	if *target == nil {
		*target = new(Alert_State_CombineThreshold_PerMetric)
	}
	switch fpv.selector {
	case AlertStateCombineThresholdPerMetric_FieldPathSelectorObservedValues:
		(*target).ObservedValues = fpv.value.(map[string]float64)
	default:
		panic(fmt.Sprintf("Invalid selector for Alert_State_CombineThreshold_PerMetric: %d", fpv.selector))
	}
}

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

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

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

type AlertStateCombineThresholdPerMetric_FieldPathMapValue struct {
	AlertStateCombineThresholdPerMetric_FieldPathMap
	value interface{}
}

var _ AlertStateCombineThresholdPerMetric_FieldPathValue = (*AlertStateCombineThresholdPerMetric_FieldPathMapValue)(nil)

// GetValue returns value stored under selected field in PerMetric as interface{}
func (fpmv *AlertStateCombineThresholdPerMetric_FieldPathMapValue) GetRawValue() interface{} {
	return fpmv.value
}
func (fpmv *AlertStateCombineThresholdPerMetric_FieldPathMapValue) AsObservedValuesElementValue() (float64, bool) {
	res, ok := fpmv.value.(float64)
	return res, ok
}

// SetTo stores value for selected field in PerMetric
func (fpmv *AlertStateCombineThresholdPerMetric_FieldPathMapValue) SetTo(target **Alert_State_CombineThreshold_PerMetric) {
	if *target == nil {
		*target = new(Alert_State_CombineThreshold_PerMetric)
	}
	switch fpmv.selector {
	case AlertStateCombineThresholdPerMetric_FieldPathSelectorObservedValues:
		if (*target).ObservedValues == nil {
			(*target).ObservedValues = make(map[string]float64)
		}
		(*target).ObservedValues[fpmv.key] = fpmv.value.(float64)
	default:
		panic(fmt.Sprintf("Invalid selector for Alert_State_CombineThreshold_PerMetric: %d", fpmv.selector))
	}
}

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

// CompareWith compares value in the 'AlertStateCombineThresholdPerMetric_FieldPathMapValue' with the value under path in 'Alert_State_CombineThreshold_PerMetric'.
func (fpmv *AlertStateCombineThresholdPerMetric_FieldPathMapValue) CompareWith(source *Alert_State_CombineThreshold_PerMetric) (int, bool) {
	switch fpmv.selector {
	case AlertStateCombineThresholdPerMetric_FieldPathSelectorObservedValues:
		leftValue := fpmv.value.(float64)
		rightValue := source.GetObservedValues()[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 Alert_State_CombineThreshold_PerMetric: %d", fpmv.selector))
	}
}

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

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

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

func MustParseAlertStateCombineThresholdPerMetric_FieldPathArrayItemValue(pathStr, valueStr string) AlertStateCombineThresholdPerMetric_FieldPathArrayItemValue {
	fpaiv, err := ParseAlertStateCombineThresholdPerMetric_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type AlertStateCombineThresholdPerMetric_FieldTerminalPathArrayItemValue struct {
	AlertStateCombineThresholdPerMetric_FieldTerminalPath
	value interface{}
}

var _ AlertStateCombineThresholdPerMetric_FieldPathArrayItemValue = (*AlertStateCombineThresholdPerMetric_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *AlertStateCombineThresholdPerMetric_FieldTerminalPathArrayItemValue) GetSingle(source *Alert_State_CombineThreshold_PerMetric) (interface{}, bool) {
	return nil, false
}

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

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

// AlertStateCombineThresholdPerMetric_FieldPathArrayOfValues allows storing slice of values for PerMetric fields according to their type
type AlertStateCombineThresholdPerMetric_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	AlertStateCombineThresholdPerMetric_FieldPath
}

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

func MustParseAlertStateCombineThresholdPerMetric_FieldPathArrayOfValues(pathStr, valuesStr string) AlertStateCombineThresholdPerMetric_FieldPathArrayOfValues {
	fpaov, err := ParseAlertStateCombineThresholdPerMetric_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type AlertStateCombineThresholdPerMetric_FieldTerminalPathArrayOfValues struct {
	AlertStateCombineThresholdPerMetric_FieldTerminalPath
	values interface{}
}

var _ AlertStateCombineThresholdPerMetric_FieldPathArrayOfValues = (*AlertStateCombineThresholdPerMetric_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *AlertStateCombineThresholdPerMetric_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case AlertStateCombineThresholdPerMetric_FieldPathSelectorObservedValues:
		for _, v := range fpaov.values.([]map[string]float64) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *AlertStateCombineThresholdPerMetric_FieldTerminalPathArrayOfValues) AsObservedValuesArrayOfValues() ([]map[string]float64, bool) {
	res, ok := fpaov.values.([]map[string]float64)
	return res, ok
}

type AlertStateCombineThresholdPerMetric_FieldPathMapArrayOfValues struct {
	AlertStateCombineThresholdPerMetric_FieldPathMap
	values interface{}
}

var _ AlertStateCombineThresholdPerMetric_FieldPathArrayOfValues = (*AlertStateCombineThresholdPerMetric_FieldPathMapArrayOfValues)(nil)

func (fpmaov *AlertStateCombineThresholdPerMetric_FieldPathMapArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpmaov.selector {
	case AlertStateCombineThresholdPerMetric_FieldPathSelectorObservedValues:
		for _, v := range fpmaov.values.([]float64) {
			values = append(values, v)
		}
	}
	return
}
func (fpmaov *AlertStateCombineThresholdPerMetric_FieldPathMapArrayOfValues) AsObservedValuesArrayOfElementValues() ([]float64, bool) {
	res, ok := fpmaov.values.([]float64)
	return res, ok
}