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

// Code generated by protoc-gen-goten-object
// File: edgelq/alerting/proto/v1/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 (
	rcommon "github.com/cloudwan/edgelq-sdk/alerting/resources/v1/common"
	log_condition "github.com/cloudwan/edgelq-sdk/alerting/resources/v1/log_condition"
	notification_channel "github.com/cloudwan/edgelq-sdk/alerting/resources/v1/notification_channel"
	ts_condition "github.com/cloudwan/edgelq-sdk/alerting/resources/v1/ts_condition"
	meta "github.com/cloudwan/goten-sdk/types/meta"
	durationpb "google.golang.org/protobuf/types/known/durationpb"
	timestamppb "google.golang.org/protobuf/types/known/timestamppb"
)

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

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

	_ = new(gotenobject.FieldPath)
)

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

// FieldPath provides implementation to handle
// https://github.com/protocolbuffers/protobuf/blob/master/src/google/protobuf/field_mask.proto
type 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_FieldPathSelectorAlertingResource Alert_FieldPathSelector = 3
	Alert_FieldPathSelectorTsInfo           Alert_FieldPathSelector = 4
	Alert_FieldPathSelectorLogInfo          Alert_FieldPathSelector = 5
	Alert_FieldPathSelectorState            Alert_FieldPathSelector = 6
	Alert_FieldPathSelectorInternal         Alert_FieldPathSelector = 7
)

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_FieldPathSelectorAlertingResource:
		return "alerting_resource"
	case Alert_FieldPathSelectorTsInfo:
		return "ts_info"
	case Alert_FieldPathSelectorLogInfo:
		return "log_info"
	case Alert_FieldPathSelectorState:
		return "state"
	case Alert_FieldPathSelectorInternal:
		return "internal"
	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 "alerting_resource", "alertingResource", "alerting-resource":
			return &Alert_FieldTerminalPath{selector: Alert_FieldPathSelectorAlertingResource}, nil
		case "ts_info", "tsInfo", "ts-info":
			return &Alert_FieldTerminalPath{selector: Alert_FieldPathSelectorTsInfo}, nil
		case "log_info", "logInfo", "log-info":
			return &Alert_FieldTerminalPath{selector: Alert_FieldPathSelectorLogInfo}, nil
		case "state":
			return &Alert_FieldTerminalPath{selector: Alert_FieldPathSelectorState}, nil
		case "internal":
			return &Alert_FieldTerminalPath{selector: Alert_FieldPathSelectorInternal}, 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 "alerting_resource", "alertingResource", "alerting-resource":
			if subpath, err := meta.BuildOwnerReference_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &Alert_FieldSubPath{selector: Alert_FieldPathSelectorAlertingResource, subPath: subpath}, nil
			}
		case "ts_info", "tsInfo", "ts-info":
			if subpath, err := BuildAlertTsInfo_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &Alert_FieldSubPath{selector: Alert_FieldPathSelectorTsInfo, subPath: subpath}, nil
			}
		case "log_info", "logInfo", "log-info":
			if subpath, err := BuildAlertLogInfo_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &Alert_FieldSubPath{selector: Alert_FieldPathSelectorLogInfo, 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
			}
		case "internal":
			if subpath, err := BuildAlertInternal_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &Alert_FieldSubPath{selector: Alert_FieldPathSelectorInternal, 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_FieldPathSelectorAlertingResource:
			if source.AlertingResource != nil {
				values = append(values, source.AlertingResource)
			}
		case Alert_FieldPathSelectorTsInfo:
			if source, ok := source.Info.(*Alert_TsInfo_); ok && source != nil {
				if source.TsInfo != nil {
					values = append(values, source.TsInfo)
				}
			}
		case Alert_FieldPathSelectorLogInfo:
			if source, ok := source.Info.(*Alert_LogInfo_); ok && source != nil {
				if source.LogInfo != nil {
					values = append(values, source.LogInfo)
				}
			}
		case Alert_FieldPathSelectorState:
			if source.State != nil {
				values = append(values, source.State)
			}
		case Alert_FieldPathSelectorInternal:
			if source.Internal != nil {
				values = append(values, source.Internal)
			}
		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_FieldPathSelectorAlertingResource:
		res := source.GetAlertingResource()
		return res, res != nil
	case Alert_FieldPathSelectorTsInfo:
		// if object nil or oneof not active, return "default" type with false flag.
		if source == nil {
			return source.GetTsInfo(), false
		}
		_, oneOfSelected := source.Info.(*Alert_TsInfo_)
		if !oneOfSelected {
			return source.GetTsInfo(), false // to return "type" information
		}
		res := source.GetTsInfo()
		return res, res != nil
	case Alert_FieldPathSelectorLogInfo:
		// if object nil or oneof not active, return "default" type with false flag.
		if source == nil {
			return source.GetLogInfo(), false
		}
		_, oneOfSelected := source.Info.(*Alert_LogInfo_)
		if !oneOfSelected {
			return source.GetLogInfo(), false // to return "type" information
		}
		res := source.GetLogInfo()
		return res, res != nil
	case Alert_FieldPathSelectorState:
		res := source.GetState()
		return res, res != nil
	case Alert_FieldPathSelectorInternal:
		res := source.GetInternal()
		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_FieldPathSelectorAlertingResource:
		return (*meta.OwnerReference)(nil)
	case Alert_FieldPathSelectorTsInfo:
		return (*Alert_TsInfo)(nil)
	case Alert_FieldPathSelectorLogInfo:
		return (*Alert_LogInfo)(nil)
	case Alert_FieldPathSelectorState:
		return (*Alert_State)(nil)
	case Alert_FieldPathSelectorInternal:
		return (*Alert_Internal)(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_FieldPathSelectorAlertingResource:
			item.AlertingResource = nil
		case Alert_FieldPathSelectorTsInfo:
			if item, ok := item.Info.(*Alert_TsInfo_); ok {
				item.TsInfo = nil
			}
		case Alert_FieldPathSelectorLogInfo:
			if item, ok := item.Info.(*Alert_LogInfo_); ok {
				item.LogInfo = nil
			}
		case Alert_FieldPathSelectorState:
			item.State = nil
		case Alert_FieldPathSelectorInternal:
			item.Internal = 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_FieldPathSelectorAlertingResource:
		return &Alert_FieldTerminalPathValue{Alert_FieldTerminalPath: *fp, value: value.(*meta.OwnerReference)}
	case Alert_FieldPathSelectorTsInfo:
		return &Alert_FieldTerminalPathValue{Alert_FieldTerminalPath: *fp, value: value.(*Alert_TsInfo)}
	case Alert_FieldPathSelectorLogInfo:
		return &Alert_FieldTerminalPathValue{Alert_FieldTerminalPath: *fp, value: value.(*Alert_LogInfo)}
	case Alert_FieldPathSelectorState:
		return &Alert_FieldTerminalPathValue{Alert_FieldTerminalPath: *fp, value: value.(*Alert_State)}
	case Alert_FieldPathSelectorInternal:
		return &Alert_FieldTerminalPathValue{Alert_FieldTerminalPath: *fp, value: value.(*Alert_Internal)}
	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_FieldPathSelectorAlertingResource:
		return &Alert_FieldTerminalPathArrayOfValues{Alert_FieldTerminalPath: *fp, values: values.([]*meta.OwnerReference)}
	case Alert_FieldPathSelectorTsInfo:
		return &Alert_FieldTerminalPathArrayOfValues{Alert_FieldTerminalPath: *fp, values: values.([]*Alert_TsInfo)}
	case Alert_FieldPathSelectorLogInfo:
		return &Alert_FieldTerminalPathArrayOfValues{Alert_FieldTerminalPath: *fp, values: values.([]*Alert_LogInfo)}
	case Alert_FieldPathSelectorState:
		return &Alert_FieldTerminalPathArrayOfValues{Alert_FieldTerminalPath: *fp, values: values.([]*Alert_State)}
	case Alert_FieldPathSelectorInternal:
		return &Alert_FieldTerminalPathArrayOfValues{Alert_FieldTerminalPath: *fp, values: values.([]*Alert_Internal)}
	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) AsAlertingResourceSubPath() (meta.OwnerReference_FieldPath, bool) {
	res, ok := fps.subPath.(meta.OwnerReference_FieldPath)
	return res, ok
}
func (fps *Alert_FieldSubPath) AsTsInfoSubPath() (AlertTsInfo_FieldPath, bool) {
	res, ok := fps.subPath.(AlertTsInfo_FieldPath)
	return res, ok
}
func (fps *Alert_FieldSubPath) AsLogInfoSubPath() (AlertLogInfo_FieldPath, bool) {
	res, ok := fps.subPath.(AlertLogInfo_FieldPath)
	return res, ok
}
func (fps *Alert_FieldSubPath) AsStateSubPath() (AlertState_FieldPath, bool) {
	res, ok := fps.subPath.(AlertState_FieldPath)
	return res, ok
}
func (fps *Alert_FieldSubPath) AsInternalSubPath() (AlertInternal_FieldPath, bool) {
	res, ok := fps.subPath.(AlertInternal_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_FieldPathSelectorAlertingResource:
		values = append(values, fps.subPath.GetRaw(source.GetAlertingResource())...)
	case Alert_FieldPathSelectorTsInfo:
		values = append(values, fps.subPath.GetRaw(source.GetTsInfo())...)
	case Alert_FieldPathSelectorLogInfo:
		values = append(values, fps.subPath.GetRaw(source.GetLogInfo())...)
	case Alert_FieldPathSelectorState:
		values = append(values, fps.subPath.GetRaw(source.GetState())...)
	case Alert_FieldPathSelectorInternal:
		values = append(values, fps.subPath.GetRaw(source.GetInternal())...)
	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_FieldPathSelectorAlertingResource:
		if source.GetAlertingResource() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetAlertingResource())
	case Alert_FieldPathSelectorTsInfo:
		if source.GetTsInfo() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetTsInfo())
	case Alert_FieldPathSelectorLogInfo:
		if source.GetLogInfo() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetLogInfo())
	case Alert_FieldPathSelectorState:
		if source.GetState() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetState())
	case Alert_FieldPathSelectorInternal:
		if source.GetInternal() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetInternal())
	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_FieldPathSelectorAlertingResource:
			fps.subPath.ClearValueRaw(item.AlertingResource)
		case Alert_FieldPathSelectorTsInfo:
			if item.Info != nil {
				if item, ok := item.Info.(*Alert_TsInfo_); ok {
					fps.subPath.ClearValueRaw(item.TsInfo)
				}
			}
		case Alert_FieldPathSelectorLogInfo:
			if item.Info != nil {
				if item, ok := item.Info.(*Alert_LogInfo_); ok {
					fps.subPath.ClearValueRaw(item.LogInfo)
				}
			}
		case Alert_FieldPathSelectorState:
			fps.subPath.ClearValueRaw(item.State)
		case Alert_FieldPathSelectorInternal:
			fps.subPath.ClearValueRaw(item.Internal)
		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) AsAlertingResourceValue() (*meta.OwnerReference, bool) {
	res, ok := fpv.value.(*meta.OwnerReference)
	return res, ok
}
func (fpv *Alert_FieldTerminalPathValue) AsTsInfoValue() (*Alert_TsInfo, bool) {
	res, ok := fpv.value.(*Alert_TsInfo)
	return res, ok
}
func (fpv *Alert_FieldTerminalPathValue) AsLogInfoValue() (*Alert_LogInfo, bool) {
	res, ok := fpv.value.(*Alert_LogInfo)
	return res, ok
}
func (fpv *Alert_FieldTerminalPathValue) AsStateValue() (*Alert_State, bool) {
	res, ok := fpv.value.(*Alert_State)
	return res, ok
}
func (fpv *Alert_FieldTerminalPathValue) AsInternalValue() (*Alert_Internal, bool) {
	res, ok := fpv.value.(*Alert_Internal)
	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_FieldPathSelectorAlertingResource:
		(*target).AlertingResource = fpv.value.(*meta.OwnerReference)
	case Alert_FieldPathSelectorTsInfo:
		if _, ok := (*target).Info.(*Alert_TsInfo_); !ok {
			(*target).Info = &Alert_TsInfo_{}
		}
		(*target).Info.(*Alert_TsInfo_).TsInfo = fpv.value.(*Alert_TsInfo)
	case Alert_FieldPathSelectorLogInfo:
		if _, ok := (*target).Info.(*Alert_LogInfo_); !ok {
			(*target).Info = &Alert_LogInfo_{}
		}
		(*target).Info.(*Alert_LogInfo_).LogInfo = fpv.value.(*Alert_LogInfo)
	case Alert_FieldPathSelectorState:
		(*target).State = fpv.value.(*Alert_State)
	case Alert_FieldPathSelectorInternal:
		(*target).Internal = fpv.value.(*Alert_Internal)
	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_FieldPathSelectorAlertingResource:
		return 0, false
	case Alert_FieldPathSelectorTsInfo:
		return 0, false
	case Alert_FieldPathSelectorLogInfo:
		return 0, false
	case Alert_FieldPathSelectorState:
		return 0, false
	case Alert_FieldPathSelectorInternal:
		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) AsAlertingResourcePathValue() (meta.OwnerReference_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(meta.OwnerReference_FieldPathValue)
	return res, ok
}
func (fpvs *Alert_FieldSubPathValue) AsTsInfoPathValue() (AlertTsInfo_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(AlertTsInfo_FieldPathValue)
	return res, ok
}
func (fpvs *Alert_FieldSubPathValue) AsLogInfoPathValue() (AlertLogInfo_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(AlertLogInfo_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) AsInternalPathValue() (AlertInternal_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(AlertInternal_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_FieldPathSelectorAlertingResource:
		fpvs.subPathValue.(meta.OwnerReference_FieldPathValue).SetTo(&(*target).AlertingResource)
	case Alert_FieldPathSelectorTsInfo:
		if _, ok := (*target).Info.(*Alert_TsInfo_); !ok {
			(*target).Info = &Alert_TsInfo_{}
		}
		fpvs.subPathValue.(AlertTsInfo_FieldPathValue).SetTo(&(*target).Info.(*Alert_TsInfo_).TsInfo)
	case Alert_FieldPathSelectorLogInfo:
		if _, ok := (*target).Info.(*Alert_LogInfo_); !ok {
			(*target).Info = &Alert_LogInfo_{}
		}
		fpvs.subPathValue.(AlertLogInfo_FieldPathValue).SetTo(&(*target).Info.(*Alert_LogInfo_).LogInfo)
	case Alert_FieldPathSelectorState:
		fpvs.subPathValue.(AlertState_FieldPathValue).SetTo(&(*target).State)
	case Alert_FieldPathSelectorInternal:
		fpvs.subPathValue.(AlertInternal_FieldPathValue).SetTo(&(*target).Internal)
	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_FieldPathSelectorAlertingResource:
		return fpvs.subPathValue.(meta.OwnerReference_FieldPathValue).CompareWith(source.GetAlertingResource())
	case Alert_FieldPathSelectorTsInfo:
		return fpvs.subPathValue.(AlertTsInfo_FieldPathValue).CompareWith(source.GetTsInfo())
	case Alert_FieldPathSelectorLogInfo:
		return fpvs.subPathValue.(AlertLogInfo_FieldPathValue).CompareWith(source.GetLogInfo())
	case Alert_FieldPathSelectorState:
		return fpvs.subPathValue.(AlertState_FieldPathValue).CompareWith(source.GetState())
	case Alert_FieldPathSelectorInternal:
		return fpvs.subPathValue.(AlertInternal_FieldPathValue).CompareWith(source.GetInternal())
	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) AsAlertingResourcePathItemValue() (meta.OwnerReference_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(meta.OwnerReference_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *Alert_FieldSubPathArrayItemValue) AsTsInfoPathItemValue() (AlertTsInfo_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(AlertTsInfo_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *Alert_FieldSubPathArrayItemValue) AsLogInfoPathItemValue() (AlertLogInfo_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(AlertLogInfo_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *Alert_FieldSubPathArrayItemValue) AsStatePathItemValue() (AlertState_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(AlertState_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *Alert_FieldSubPathArrayItemValue) AsInternalPathItemValue() (AlertInternal_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(AlertInternal_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_FieldPathSelectorAlertingResource:
		return fpaivs.subPathItemValue.(meta.OwnerReference_FieldPathArrayItemValue).ContainsValue(source.GetAlertingResource())
	case Alert_FieldPathSelectorTsInfo:
		return fpaivs.subPathItemValue.(AlertTsInfo_FieldPathArrayItemValue).ContainsValue(source.GetTsInfo())
	case Alert_FieldPathSelectorLogInfo:
		return fpaivs.subPathItemValue.(AlertLogInfo_FieldPathArrayItemValue).ContainsValue(source.GetLogInfo())
	case Alert_FieldPathSelectorState:
		return fpaivs.subPathItemValue.(AlertState_FieldPathArrayItemValue).ContainsValue(source.GetState())
	case Alert_FieldPathSelectorInternal:
		return fpaivs.subPathItemValue.(AlertInternal_FieldPathArrayItemValue).ContainsValue(source.GetInternal())
	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_FieldPathSelectorAlertingResource:
		for _, v := range fpaov.values.([]*meta.OwnerReference) {
			values = append(values, v)
		}
	case Alert_FieldPathSelectorTsInfo:
		for _, v := range fpaov.values.([]*Alert_TsInfo) {
			values = append(values, v)
		}
	case Alert_FieldPathSelectorLogInfo:
		for _, v := range fpaov.values.([]*Alert_LogInfo) {
			values = append(values, v)
		}
	case Alert_FieldPathSelectorState:
		for _, v := range fpaov.values.([]*Alert_State) {
			values = append(values, v)
		}
	case Alert_FieldPathSelectorInternal:
		for _, v := range fpaov.values.([]*Alert_Internal) {
			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) AsAlertingResourceArrayOfValues() ([]*meta.OwnerReference, bool) {
	res, ok := fpaov.values.([]*meta.OwnerReference)
	return res, ok
}
func (fpaov *Alert_FieldTerminalPathArrayOfValues) AsTsInfoArrayOfValues() ([]*Alert_TsInfo, bool) {
	res, ok := fpaov.values.([]*Alert_TsInfo)
	return res, ok
}
func (fpaov *Alert_FieldTerminalPathArrayOfValues) AsLogInfoArrayOfValues() ([]*Alert_LogInfo, bool) {
	res, ok := fpaov.values.([]*Alert_LogInfo)
	return res, ok
}
func (fpaov *Alert_FieldTerminalPathArrayOfValues) AsStateArrayOfValues() ([]*Alert_State, bool) {
	res, ok := fpaov.values.([]*Alert_State)
	return res, ok
}
func (fpaov *Alert_FieldTerminalPathArrayOfValues) AsInternalArrayOfValues() ([]*Alert_Internal, bool) {
	res, ok := fpaov.values.([]*Alert_Internal)
	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) AsAlertingResourcePathArrayOfValues() (meta.OwnerReference_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(meta.OwnerReference_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *Alert_FieldSubPathArrayOfValues) AsTsInfoPathArrayOfValues() (AlertTsInfo_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(AlertTsInfo_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *Alert_FieldSubPathArrayOfValues) AsLogInfoPathArrayOfValues() (AlertLogInfo_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(AlertLogInfo_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *Alert_FieldSubPathArrayOfValues) AsStatePathArrayOfValues() (AlertState_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(AlertState_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *Alert_FieldSubPathArrayOfValues) AsInternalPathArrayOfValues() (AlertInternal_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(AlertInternal_FieldPathArrayOfValues)
	return res, ok
}

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

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

type AlertTsInfo_FieldPathSelector int32

const (
	AlertTsInfo_FieldPathSelectorType                 AlertTsInfo_FieldPathSelector = 0
	AlertTsInfo_FieldPathSelectorAnomalyWindowSize    AlertTsInfo_FieldPathSelector = 1
	AlertTsInfo_FieldPathSelectorCommonKey            AlertTsInfo_FieldPathSelector = 2
	AlertTsInfo_FieldPathSelectorMetricTypes          AlertTsInfo_FieldPathSelector = 3
	AlertTsInfo_FieldPathSelectorResourceTypes        AlertTsInfo_FieldPathSelector = 4
	AlertTsInfo_FieldPathSelectorCommonMetricLabels   AlertTsInfo_FieldPathSelector = 5
	AlertTsInfo_FieldPathSelectorCommonResourceLabels AlertTsInfo_FieldPathSelector = 6
	AlertTsInfo_FieldPathSelectorTimeSeries           AlertTsInfo_FieldPathSelector = 7
)

func (s AlertTsInfo_FieldPathSelector) String() string {
	switch s {
	case AlertTsInfo_FieldPathSelectorType:
		return "type"
	case AlertTsInfo_FieldPathSelectorAnomalyWindowSize:
		return "anomaly_window_size"
	case AlertTsInfo_FieldPathSelectorCommonKey:
		return "common_key"
	case AlertTsInfo_FieldPathSelectorMetricTypes:
		return "metric_types"
	case AlertTsInfo_FieldPathSelectorResourceTypes:
		return "resource_types"
	case AlertTsInfo_FieldPathSelectorCommonMetricLabels:
		return "common_metric_labels"
	case AlertTsInfo_FieldPathSelectorCommonResourceLabels:
		return "common_resource_labels"
	case AlertTsInfo_FieldPathSelectorTimeSeries:
		return "time_series"
	default:
		panic(fmt.Sprintf("Invalid selector for Alert_TsInfo: %d", s))
	}
}

func BuildAlertTsInfo_FieldPath(fp gotenobject.RawFieldPath) (AlertTsInfo_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object Alert_TsInfo")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "type":
			return &AlertTsInfo_FieldTerminalPath{selector: AlertTsInfo_FieldPathSelectorType}, nil
		case "anomaly_window_size", "anomalyWindowSize", "anomaly-window-size":
			return &AlertTsInfo_FieldTerminalPath{selector: AlertTsInfo_FieldPathSelectorAnomalyWindowSize}, nil
		case "common_key", "commonKey", "common-key":
			return &AlertTsInfo_FieldTerminalPath{selector: AlertTsInfo_FieldPathSelectorCommonKey}, nil
		case "metric_types", "metricTypes", "metric-types":
			return &AlertTsInfo_FieldTerminalPath{selector: AlertTsInfo_FieldPathSelectorMetricTypes}, nil
		case "resource_types", "resourceTypes", "resource-types":
			return &AlertTsInfo_FieldTerminalPath{selector: AlertTsInfo_FieldPathSelectorResourceTypes}, nil
		case "common_metric_labels", "commonMetricLabels", "common-metric-labels":
			return &AlertTsInfo_FieldTerminalPath{selector: AlertTsInfo_FieldPathSelectorCommonMetricLabels}, nil
		case "common_resource_labels", "commonResourceLabels", "common-resource-labels":
			return &AlertTsInfo_FieldTerminalPath{selector: AlertTsInfo_FieldPathSelectorCommonResourceLabels}, nil
		case "time_series", "timeSeries", "time-series":
			return &AlertTsInfo_FieldTerminalPath{selector: AlertTsInfo_FieldPathSelectorTimeSeries}, nil
		}
	} else {
		switch fp[0] {
		case "time_series", "timeSeries", "time-series":
			if subpath, err := BuildAlertTsInfoTimeSeries_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &AlertTsInfo_FieldSubPath{selector: AlertTsInfo_FieldPathSelectorTimeSeries, subPath: subpath}, nil
			}
		case "common_metric_labels", "commonMetricLabels", "common-metric-labels":
			if len(fp) > 2 {
				return nil, status.Errorf(codes.InvalidArgument, "sub path for maps ('%s') are not supported (object Alert_TsInfo)", fp)
			}
			return &AlertTsInfo_FieldPathMap{selector: AlertTsInfo_FieldPathSelectorCommonMetricLabels, key: fp[1]}, nil
		case "common_resource_labels", "commonResourceLabels", "common-resource-labels":
			if len(fp) > 2 {
				return nil, status.Errorf(codes.InvalidArgument, "sub path for maps ('%s') are not supported (object Alert_TsInfo)", fp)
			}
			return &AlertTsInfo_FieldPathMap{selector: AlertTsInfo_FieldPathSelectorCommonResourceLabels, key: fp[1]}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object Alert_TsInfo", fp)
}

func ParseAlertTsInfo_FieldPath(rawField string) (AlertTsInfo_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildAlertTsInfo_FieldPath(fp)
}

func MustParseAlertTsInfo_FieldPath(rawField string) AlertTsInfo_FieldPath {
	fp, err := ParseAlertTsInfo_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type AlertTsInfo_FieldTerminalPath struct {
	selector AlertTsInfo_FieldPathSelector
}

var _ AlertTsInfo_FieldPath = (*AlertTsInfo_FieldTerminalPath)(nil)

func (fp *AlertTsInfo_FieldTerminalPath) Selector() AlertTsInfo_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source Alert_TsInfo
func (fp *AlertTsInfo_FieldTerminalPath) Get(source *Alert_TsInfo) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case AlertTsInfo_FieldPathSelectorType:
			values = append(values, source.Type)
		case AlertTsInfo_FieldPathSelectorAnomalyWindowSize:
			if source.AnomalyWindowSize != nil {
				values = append(values, source.AnomalyWindowSize)
			}
		case AlertTsInfo_FieldPathSelectorCommonKey:
			values = append(values, source.CommonKey)
		case AlertTsInfo_FieldPathSelectorMetricTypes:
			for _, value := range source.GetMetricTypes() {
				values = append(values, value)
			}
		case AlertTsInfo_FieldPathSelectorResourceTypes:
			for _, value := range source.GetResourceTypes() {
				values = append(values, value)
			}
		case AlertTsInfo_FieldPathSelectorCommonMetricLabels:
			values = append(values, source.CommonMetricLabels)
		case AlertTsInfo_FieldPathSelectorCommonResourceLabels:
			values = append(values, source.CommonResourceLabels)
		case AlertTsInfo_FieldPathSelectorTimeSeries:
			for _, value := range source.GetTimeSeries() {
				values = append(values, value)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for Alert_TsInfo: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source Alert_TsInfo
func (fp *AlertTsInfo_FieldTerminalPath) GetSingle(source *Alert_TsInfo) (interface{}, bool) {
	switch fp.selector {
	case AlertTsInfo_FieldPathSelectorType:
		return source.GetType(), source != nil
	case AlertTsInfo_FieldPathSelectorAnomalyWindowSize:
		res := source.GetAnomalyWindowSize()
		return res, res != nil
	case AlertTsInfo_FieldPathSelectorCommonKey:
		res := source.GetCommonKey()
		return res, res != nil
	case AlertTsInfo_FieldPathSelectorMetricTypes:
		res := source.GetMetricTypes()
		return res, res != nil
	case AlertTsInfo_FieldPathSelectorResourceTypes:
		res := source.GetResourceTypes()
		return res, res != nil
	case AlertTsInfo_FieldPathSelectorCommonMetricLabels:
		res := source.GetCommonMetricLabels()
		return res, res != nil
	case AlertTsInfo_FieldPathSelectorCommonResourceLabels:
		res := source.GetCommonResourceLabels()
		return res, res != nil
	case AlertTsInfo_FieldPathSelectorTimeSeries:
		res := source.GetTimeSeries()
		return res, res != nil
	default:
		panic(fmt.Sprintf("Invalid selector for Alert_TsInfo: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *AlertTsInfo_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case AlertTsInfo_FieldPathSelectorType:
		return Alert_TsInfo_UNDEFINED
	case AlertTsInfo_FieldPathSelectorAnomalyWindowSize:
		return (*durationpb.Duration)(nil)
	case AlertTsInfo_FieldPathSelectorCommonKey:
		return ([]byte)(nil)
	case AlertTsInfo_FieldPathSelectorMetricTypes:
		return ([]string)(nil)
	case AlertTsInfo_FieldPathSelectorResourceTypes:
		return ([]string)(nil)
	case AlertTsInfo_FieldPathSelectorCommonMetricLabels:
		return (map[string]string)(nil)
	case AlertTsInfo_FieldPathSelectorCommonResourceLabels:
		return (map[string]string)(nil)
	case AlertTsInfo_FieldPathSelectorTimeSeries:
		return ([]*Alert_TsInfo_TimeSeries)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for Alert_TsInfo: %d", fp.selector))
	}
}

func (fp *AlertTsInfo_FieldTerminalPath) ClearValue(item *Alert_TsInfo) {
	if item != nil {
		switch fp.selector {
		case AlertTsInfo_FieldPathSelectorType:
			item.Type = Alert_TsInfo_UNDEFINED
		case AlertTsInfo_FieldPathSelectorAnomalyWindowSize:
			item.AnomalyWindowSize = nil
		case AlertTsInfo_FieldPathSelectorCommonKey:
			item.CommonKey = nil
		case AlertTsInfo_FieldPathSelectorMetricTypes:
			item.MetricTypes = nil
		case AlertTsInfo_FieldPathSelectorResourceTypes:
			item.ResourceTypes = nil
		case AlertTsInfo_FieldPathSelectorCommonMetricLabels:
			item.CommonMetricLabels = nil
		case AlertTsInfo_FieldPathSelectorCommonResourceLabels:
			item.CommonResourceLabels = nil
		case AlertTsInfo_FieldPathSelectorTimeSeries:
			item.TimeSeries = nil
		default:
			panic(fmt.Sprintf("Invalid selector for Alert_TsInfo: %d", fp.selector))
		}
	}
}

func (fp *AlertTsInfo_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*Alert_TsInfo))
}

// IsLeaf - whether field path is holds simple value
func (fp *AlertTsInfo_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == AlertTsInfo_FieldPathSelectorType ||
		fp.selector == AlertTsInfo_FieldPathSelectorAnomalyWindowSize ||
		fp.selector == AlertTsInfo_FieldPathSelectorCommonKey ||
		fp.selector == AlertTsInfo_FieldPathSelectorMetricTypes ||
		fp.selector == AlertTsInfo_FieldPathSelectorResourceTypes ||
		fp.selector == AlertTsInfo_FieldPathSelectorCommonMetricLabels ||
		fp.selector == AlertTsInfo_FieldPathSelectorCommonResourceLabels
}

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

func (fp *AlertTsInfo_FieldTerminalPath) WithIValue(value interface{}) AlertTsInfo_FieldPathValue {
	switch fp.selector {
	case AlertTsInfo_FieldPathSelectorType:
		return &AlertTsInfo_FieldTerminalPathValue{AlertTsInfo_FieldTerminalPath: *fp, value: value.(Alert_TsInfo_Type)}
	case AlertTsInfo_FieldPathSelectorAnomalyWindowSize:
		return &AlertTsInfo_FieldTerminalPathValue{AlertTsInfo_FieldTerminalPath: *fp, value: value.(*durationpb.Duration)}
	case AlertTsInfo_FieldPathSelectorCommonKey:
		return &AlertTsInfo_FieldTerminalPathValue{AlertTsInfo_FieldTerminalPath: *fp, value: value.([]byte)}
	case AlertTsInfo_FieldPathSelectorMetricTypes:
		return &AlertTsInfo_FieldTerminalPathValue{AlertTsInfo_FieldTerminalPath: *fp, value: value.([]string)}
	case AlertTsInfo_FieldPathSelectorResourceTypes:
		return &AlertTsInfo_FieldTerminalPathValue{AlertTsInfo_FieldTerminalPath: *fp, value: value.([]string)}
	case AlertTsInfo_FieldPathSelectorCommonMetricLabels:
		return &AlertTsInfo_FieldTerminalPathValue{AlertTsInfo_FieldTerminalPath: *fp, value: value.(map[string]string)}
	case AlertTsInfo_FieldPathSelectorCommonResourceLabels:
		return &AlertTsInfo_FieldTerminalPathValue{AlertTsInfo_FieldTerminalPath: *fp, value: value.(map[string]string)}
	case AlertTsInfo_FieldPathSelectorTimeSeries:
		return &AlertTsInfo_FieldTerminalPathValue{AlertTsInfo_FieldTerminalPath: *fp, value: value.([]*Alert_TsInfo_TimeSeries)}
	default:
		panic(fmt.Sprintf("Invalid selector for Alert_TsInfo: %d", fp.selector))
	}
}

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

func (fp *AlertTsInfo_FieldTerminalPath) WithIArrayOfValues(values interface{}) AlertTsInfo_FieldPathArrayOfValues {
	fpaov := &AlertTsInfo_FieldTerminalPathArrayOfValues{AlertTsInfo_FieldTerminalPath: *fp}
	switch fp.selector {
	case AlertTsInfo_FieldPathSelectorType:
		return &AlertTsInfo_FieldTerminalPathArrayOfValues{AlertTsInfo_FieldTerminalPath: *fp, values: values.([]Alert_TsInfo_Type)}
	case AlertTsInfo_FieldPathSelectorAnomalyWindowSize:
		return &AlertTsInfo_FieldTerminalPathArrayOfValues{AlertTsInfo_FieldTerminalPath: *fp, values: values.([]*durationpb.Duration)}
	case AlertTsInfo_FieldPathSelectorCommonKey:
		return &AlertTsInfo_FieldTerminalPathArrayOfValues{AlertTsInfo_FieldTerminalPath: *fp, values: values.([][]byte)}
	case AlertTsInfo_FieldPathSelectorMetricTypes:
		return &AlertTsInfo_FieldTerminalPathArrayOfValues{AlertTsInfo_FieldTerminalPath: *fp, values: values.([][]string)}
	case AlertTsInfo_FieldPathSelectorResourceTypes:
		return &AlertTsInfo_FieldTerminalPathArrayOfValues{AlertTsInfo_FieldTerminalPath: *fp, values: values.([][]string)}
	case AlertTsInfo_FieldPathSelectorCommonMetricLabels:
		return &AlertTsInfo_FieldTerminalPathArrayOfValues{AlertTsInfo_FieldTerminalPath: *fp, values: values.([]map[string]string)}
	case AlertTsInfo_FieldPathSelectorCommonResourceLabels:
		return &AlertTsInfo_FieldTerminalPathArrayOfValues{AlertTsInfo_FieldTerminalPath: *fp, values: values.([]map[string]string)}
	case AlertTsInfo_FieldPathSelectorTimeSeries:
		return &AlertTsInfo_FieldTerminalPathArrayOfValues{AlertTsInfo_FieldTerminalPath: *fp, values: values.([][]*Alert_TsInfo_TimeSeries)}
	default:
		panic(fmt.Sprintf("Invalid selector for Alert_TsInfo: %d", fp.selector))
	}
	return fpaov
}

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

func (fp *AlertTsInfo_FieldTerminalPath) WithIArrayItemValue(value interface{}) AlertTsInfo_FieldPathArrayItemValue {
	switch fp.selector {
	case AlertTsInfo_FieldPathSelectorMetricTypes:
		return &AlertTsInfo_FieldTerminalPathArrayItemValue{AlertTsInfo_FieldTerminalPath: *fp, value: value.(string)}
	case AlertTsInfo_FieldPathSelectorResourceTypes:
		return &AlertTsInfo_FieldTerminalPathArrayItemValue{AlertTsInfo_FieldTerminalPath: *fp, value: value.(string)}
	case AlertTsInfo_FieldPathSelectorTimeSeries:
		return &AlertTsInfo_FieldTerminalPathArrayItemValue{AlertTsInfo_FieldTerminalPath: *fp, value: value.(*Alert_TsInfo_TimeSeries)}
	default:
		panic(fmt.Sprintf("Invalid selector for Alert_TsInfo: %d", fp.selector))
	}
}

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

// FieldPath for map type with additional Key information
type AlertTsInfo_FieldPathMap struct {
	key      string
	selector AlertTsInfo_FieldPathSelector
}

var _ AlertTsInfo_FieldPath = (*AlertTsInfo_FieldPathMap)(nil)

func (fpm *AlertTsInfo_FieldPathMap) Selector() AlertTsInfo_FieldPathSelector {
	return fpm.selector
}

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

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

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

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

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

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

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

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

func (fpm *AlertTsInfo_FieldPathMap) ClearValueRaw(item proto.Message) {
	fpm.ClearValue(item.(*Alert_TsInfo))
}

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

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

func (fpm *AlertTsInfo_FieldPathMap) WithIValue(value interface{}) AlertTsInfo_FieldPathValue {
	switch fpm.selector {
	case AlertTsInfo_FieldPathSelectorCommonMetricLabels:
		return &AlertTsInfo_FieldPathMapValue{AlertTsInfo_FieldPathMap: *fpm, value: value.(string)}
	case AlertTsInfo_FieldPathSelectorCommonResourceLabels:
		return &AlertTsInfo_FieldPathMapValue{AlertTsInfo_FieldPathMap: *fpm, value: value.(string)}
	default:
		panic(fmt.Sprintf("Invalid selector for Alert_TsInfo: %d", fpm.selector))
	}
}

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

func (fpm *AlertTsInfo_FieldPathMap) WithIArrayOfValues(values interface{}) AlertTsInfo_FieldPathArrayOfValues {
	switch fpm.selector {
	case AlertTsInfo_FieldPathSelectorCommonMetricLabels:
		return &AlertTsInfo_FieldPathMapArrayOfValues{AlertTsInfo_FieldPathMap: *fpm, values: values.([]string)}
	case AlertTsInfo_FieldPathSelectorCommonResourceLabels:
		return &AlertTsInfo_FieldPathMapArrayOfValues{AlertTsInfo_FieldPathMap: *fpm, values: values.([]string)}
	default:
		panic(fmt.Sprintf("Invalid selector for Alert_TsInfo: %d", fpm.selector))
	}
}

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

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

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

type AlertTsInfo_FieldSubPath struct {
	selector AlertTsInfo_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ AlertTsInfo_FieldPath = (*AlertTsInfo_FieldSubPath)(nil)

func (fps *AlertTsInfo_FieldSubPath) Selector() AlertTsInfo_FieldPathSelector {
	return fps.selector
}
func (fps *AlertTsInfo_FieldSubPath) AsTimeSeriesSubPath() (AlertTsInfoTimeSeries_FieldPath, bool) {
	res, ok := fps.subPath.(AlertTsInfoTimeSeries_FieldPath)
	return res, ok
}

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

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

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

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

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

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

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

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

func (fps *AlertTsInfo_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*Alert_TsInfo))
}

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

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

func (fps *AlertTsInfo_FieldSubPath) WithIValue(value interface{}) AlertTsInfo_FieldPathValue {
	return &AlertTsInfo_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *AlertTsInfo_FieldSubPath) WithIArrayOfValues(values interface{}) AlertTsInfo_FieldPathArrayOfValues {
	return &AlertTsInfo_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *AlertTsInfo_FieldSubPath) WithIArrayItemValue(value interface{}) AlertTsInfo_FieldPathArrayItemValue {
	return &AlertTsInfo_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

// AlertTsInfo_FieldPathValue allows storing values for TsInfo fields according to their type
type AlertTsInfo_FieldPathValue interface {
	AlertTsInfo_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **Alert_TsInfo)
	CompareWith(*Alert_TsInfo) (cmp int, comparable bool)
}

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

func MustParseAlertTsInfo_FieldPathValue(pathStr, valueStr string) AlertTsInfo_FieldPathValue {
	fpv, err := ParseAlertTsInfo_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type AlertTsInfo_FieldTerminalPathValue struct {
	AlertTsInfo_FieldTerminalPath
	value interface{}
}

var _ AlertTsInfo_FieldPathValue = (*AlertTsInfo_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'TsInfo' as interface{}
func (fpv *AlertTsInfo_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *AlertTsInfo_FieldTerminalPathValue) AsTypeValue() (Alert_TsInfo_Type, bool) {
	res, ok := fpv.value.(Alert_TsInfo_Type)
	return res, ok
}
func (fpv *AlertTsInfo_FieldTerminalPathValue) AsAnomalyWindowSizeValue() (*durationpb.Duration, bool) {
	res, ok := fpv.value.(*durationpb.Duration)
	return res, ok
}
func (fpv *AlertTsInfo_FieldTerminalPathValue) AsCommonKeyValue() ([]byte, bool) {
	res, ok := fpv.value.([]byte)
	return res, ok
}
func (fpv *AlertTsInfo_FieldTerminalPathValue) AsMetricTypesValue() ([]string, bool) {
	res, ok := fpv.value.([]string)
	return res, ok
}
func (fpv *AlertTsInfo_FieldTerminalPathValue) AsResourceTypesValue() ([]string, bool) {
	res, ok := fpv.value.([]string)
	return res, ok
}
func (fpv *AlertTsInfo_FieldTerminalPathValue) AsCommonMetricLabelsValue() (map[string]string, bool) {
	res, ok := fpv.value.(map[string]string)
	return res, ok
}
func (fpv *AlertTsInfo_FieldTerminalPathValue) AsCommonResourceLabelsValue() (map[string]string, bool) {
	res, ok := fpv.value.(map[string]string)
	return res, ok
}
func (fpv *AlertTsInfo_FieldTerminalPathValue) AsTimeSeriesValue() ([]*Alert_TsInfo_TimeSeries, bool) {
	res, ok := fpv.value.([]*Alert_TsInfo_TimeSeries)
	return res, ok
}

// SetTo stores value for selected field for object TsInfo
func (fpv *AlertTsInfo_FieldTerminalPathValue) SetTo(target **Alert_TsInfo) {
	if *target == nil {
		*target = new(Alert_TsInfo)
	}
	switch fpv.selector {
	case AlertTsInfo_FieldPathSelectorType:
		(*target).Type = fpv.value.(Alert_TsInfo_Type)
	case AlertTsInfo_FieldPathSelectorAnomalyWindowSize:
		(*target).AnomalyWindowSize = fpv.value.(*durationpb.Duration)
	case AlertTsInfo_FieldPathSelectorCommonKey:
		(*target).CommonKey = fpv.value.([]byte)
	case AlertTsInfo_FieldPathSelectorMetricTypes:
		(*target).MetricTypes = fpv.value.([]string)
	case AlertTsInfo_FieldPathSelectorResourceTypes:
		(*target).ResourceTypes = fpv.value.([]string)
	case AlertTsInfo_FieldPathSelectorCommonMetricLabels:
		(*target).CommonMetricLabels = fpv.value.(map[string]string)
	case AlertTsInfo_FieldPathSelectorCommonResourceLabels:
		(*target).CommonResourceLabels = fpv.value.(map[string]string)
	case AlertTsInfo_FieldPathSelectorTimeSeries:
		(*target).TimeSeries = fpv.value.([]*Alert_TsInfo_TimeSeries)
	default:
		panic(fmt.Sprintf("Invalid selector for Alert_TsInfo: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'AlertTsInfo_FieldTerminalPathValue' with the value under path in 'Alert_TsInfo'.
func (fpv *AlertTsInfo_FieldTerminalPathValue) CompareWith(source *Alert_TsInfo) (int, bool) {
	switch fpv.selector {
	case AlertTsInfo_FieldPathSelectorType:
		leftValue := fpv.value.(Alert_TsInfo_Type)
		rightValue := source.GetType()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case AlertTsInfo_FieldPathSelectorAnomalyWindowSize:
		leftValue := fpv.value.(*durationpb.Duration)
		rightValue := source.GetAnomalyWindowSize()
		if leftValue == nil {
			if rightValue != nil {
				return -1, true
			}
			return 0, true
		}
		if rightValue == nil {
			return 1, true
		}
		if leftValue.AsDuration() == rightValue.AsDuration() {
			return 0, true
		} else if leftValue.AsDuration() < rightValue.AsDuration() {
			return -1, true
		} else {
			return 1, true
		}
	case AlertTsInfo_FieldPathSelectorCommonKey:
		return 0, false
	case AlertTsInfo_FieldPathSelectorMetricTypes:
		return 0, false
	case AlertTsInfo_FieldPathSelectorResourceTypes:
		return 0, false
	case AlertTsInfo_FieldPathSelectorCommonMetricLabels:
		return 0, false
	case AlertTsInfo_FieldPathSelectorCommonResourceLabels:
		return 0, false
	case AlertTsInfo_FieldPathSelectorTimeSeries:
		return 0, false
	default:
		panic(fmt.Sprintf("Invalid selector for Alert_TsInfo: %d", fpv.selector))
	}
}

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

type AlertTsInfo_FieldPathMapValue struct {
	AlertTsInfo_FieldPathMap
	value interface{}
}

var _ AlertTsInfo_FieldPathValue = (*AlertTsInfo_FieldPathMapValue)(nil)

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

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

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

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

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

type AlertTsInfo_FieldSubPathValue struct {
	AlertTsInfo_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ AlertTsInfo_FieldPathValue = (*AlertTsInfo_FieldSubPathValue)(nil)

func (fpvs *AlertTsInfo_FieldSubPathValue) AsTimeSeriesPathValue() (AlertTsInfoTimeSeries_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(AlertTsInfoTimeSeries_FieldPathValue)
	return res, ok
}

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

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

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

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

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

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

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

func MustParseAlertTsInfo_FieldPathArrayItemValue(pathStr, valueStr string) AlertTsInfo_FieldPathArrayItemValue {
	fpaiv, err := ParseAlertTsInfo_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type AlertTsInfo_FieldTerminalPathArrayItemValue struct {
	AlertTsInfo_FieldTerminalPath
	value interface{}
}

var _ AlertTsInfo_FieldPathArrayItemValue = (*AlertTsInfo_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object Alert_TsInfo as interface{}
func (fpaiv *AlertTsInfo_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}
func (fpaiv *AlertTsInfo_FieldTerminalPathArrayItemValue) AsMetricTypesItemValue() (string, bool) {
	res, ok := fpaiv.value.(string)
	return res, ok
}
func (fpaiv *AlertTsInfo_FieldTerminalPathArrayItemValue) AsResourceTypesItemValue() (string, bool) {
	res, ok := fpaiv.value.(string)
	return res, ok
}
func (fpaiv *AlertTsInfo_FieldTerminalPathArrayItemValue) AsTimeSeriesItemValue() (*Alert_TsInfo_TimeSeries, bool) {
	res, ok := fpaiv.value.(*Alert_TsInfo_TimeSeries)
	return res, ok
}

func (fpaiv *AlertTsInfo_FieldTerminalPathArrayItemValue) GetSingle(source *Alert_TsInfo) (interface{}, bool) {
	return nil, false
}

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

// Contains returns a boolean indicating if value that is being held is present in given 'TsInfo'
func (fpaiv *AlertTsInfo_FieldTerminalPathArrayItemValue) ContainsValue(source *Alert_TsInfo) bool {
	slice := fpaiv.AlertTsInfo_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 AlertTsInfo_FieldSubPathArrayItemValue struct {
	AlertTsInfo_FieldPath
	subPathItemValue gotenobject.FieldPathArrayItemValue
}

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

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

// AlertTsInfo_FieldPathArrayOfValues allows storing slice of values for TsInfo fields according to their type
type AlertTsInfo_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	AlertTsInfo_FieldPath
}

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

func MustParseAlertTsInfo_FieldPathArrayOfValues(pathStr, valuesStr string) AlertTsInfo_FieldPathArrayOfValues {
	fpaov, err := ParseAlertTsInfo_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type AlertTsInfo_FieldTerminalPathArrayOfValues struct {
	AlertTsInfo_FieldTerminalPath
	values interface{}
}

var _ AlertTsInfo_FieldPathArrayOfValues = (*AlertTsInfo_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *AlertTsInfo_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case AlertTsInfo_FieldPathSelectorType:
		for _, v := range fpaov.values.([]Alert_TsInfo_Type) {
			values = append(values, v)
		}
	case AlertTsInfo_FieldPathSelectorAnomalyWindowSize:
		for _, v := range fpaov.values.([]*durationpb.Duration) {
			values = append(values, v)
		}
	case AlertTsInfo_FieldPathSelectorCommonKey:
		for _, v := range fpaov.values.([][]byte) {
			values = append(values, v)
		}
	case AlertTsInfo_FieldPathSelectorMetricTypes:
		for _, v := range fpaov.values.([][]string) {
			values = append(values, v)
		}
	case AlertTsInfo_FieldPathSelectorResourceTypes:
		for _, v := range fpaov.values.([][]string) {
			values = append(values, v)
		}
	case AlertTsInfo_FieldPathSelectorCommonMetricLabels:
		for _, v := range fpaov.values.([]map[string]string) {
			values = append(values, v)
		}
	case AlertTsInfo_FieldPathSelectorCommonResourceLabels:
		for _, v := range fpaov.values.([]map[string]string) {
			values = append(values, v)
		}
	case AlertTsInfo_FieldPathSelectorTimeSeries:
		for _, v := range fpaov.values.([][]*Alert_TsInfo_TimeSeries) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *AlertTsInfo_FieldTerminalPathArrayOfValues) AsTypeArrayOfValues() ([]Alert_TsInfo_Type, bool) {
	res, ok := fpaov.values.([]Alert_TsInfo_Type)
	return res, ok
}
func (fpaov *AlertTsInfo_FieldTerminalPathArrayOfValues) AsAnomalyWindowSizeArrayOfValues() ([]*durationpb.Duration, bool) {
	res, ok := fpaov.values.([]*durationpb.Duration)
	return res, ok
}
func (fpaov *AlertTsInfo_FieldTerminalPathArrayOfValues) AsCommonKeyArrayOfValues() ([][]byte, bool) {
	res, ok := fpaov.values.([][]byte)
	return res, ok
}
func (fpaov *AlertTsInfo_FieldTerminalPathArrayOfValues) AsMetricTypesArrayOfValues() ([][]string, bool) {
	res, ok := fpaov.values.([][]string)
	return res, ok
}
func (fpaov *AlertTsInfo_FieldTerminalPathArrayOfValues) AsResourceTypesArrayOfValues() ([][]string, bool) {
	res, ok := fpaov.values.([][]string)
	return res, ok
}
func (fpaov *AlertTsInfo_FieldTerminalPathArrayOfValues) AsCommonMetricLabelsArrayOfValues() ([]map[string]string, bool) {
	res, ok := fpaov.values.([]map[string]string)
	return res, ok
}
func (fpaov *AlertTsInfo_FieldTerminalPathArrayOfValues) AsCommonResourceLabelsArrayOfValues() ([]map[string]string, bool) {
	res, ok := fpaov.values.([]map[string]string)
	return res, ok
}
func (fpaov *AlertTsInfo_FieldTerminalPathArrayOfValues) AsTimeSeriesArrayOfValues() ([][]*Alert_TsInfo_TimeSeries, bool) {
	res, ok := fpaov.values.([][]*Alert_TsInfo_TimeSeries)
	return res, ok
}

type AlertTsInfo_FieldPathMapArrayOfValues struct {
	AlertTsInfo_FieldPathMap
	values interface{}
}

var _ AlertTsInfo_FieldPathArrayOfValues = (*AlertTsInfo_FieldPathMapArrayOfValues)(nil)

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

type AlertTsInfo_FieldSubPathArrayOfValues struct {
	AlertTsInfo_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ AlertTsInfo_FieldPathArrayOfValues = (*AlertTsInfo_FieldSubPathArrayOfValues)(nil)

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

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

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

type AlertLogInfo_FieldPathSelector int32

const (
	AlertLogInfo_FieldPathSelectorCommonKey       AlertLogInfo_FieldPathSelector = 0
	AlertLogInfo_FieldPathSelectorLogTypes        AlertLogInfo_FieldPathSelector = 1
	AlertLogInfo_FieldPathSelectorCommonLogLabels AlertLogInfo_FieldPathSelector = 2
	AlertLogInfo_FieldPathSelectorViolatingLog    AlertLogInfo_FieldPathSelector = 3
)

func (s AlertLogInfo_FieldPathSelector) String() string {
	switch s {
	case AlertLogInfo_FieldPathSelectorCommonKey:
		return "common_key"
	case AlertLogInfo_FieldPathSelectorLogTypes:
		return "log_types"
	case AlertLogInfo_FieldPathSelectorCommonLogLabels:
		return "common_log_labels"
	case AlertLogInfo_FieldPathSelectorViolatingLog:
		return "violating_log"
	default:
		panic(fmt.Sprintf("Invalid selector for Alert_LogInfo: %d", s))
	}
}

func BuildAlertLogInfo_FieldPath(fp gotenobject.RawFieldPath) (AlertLogInfo_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object Alert_LogInfo")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "common_key", "commonKey", "common-key":
			return &AlertLogInfo_FieldTerminalPath{selector: AlertLogInfo_FieldPathSelectorCommonKey}, nil
		case "log_types", "logTypes", "log-types":
			return &AlertLogInfo_FieldTerminalPath{selector: AlertLogInfo_FieldPathSelectorLogTypes}, nil
		case "common_log_labels", "commonLogLabels", "common-log-labels":
			return &AlertLogInfo_FieldTerminalPath{selector: AlertLogInfo_FieldPathSelectorCommonLogLabels}, nil
		case "violating_log", "violatingLog", "violating-log":
			return &AlertLogInfo_FieldTerminalPath{selector: AlertLogInfo_FieldPathSelectorViolatingLog}, nil
		}
	} else {
		switch fp[0] {
		case "common_log_labels", "commonLogLabels", "common-log-labels":
			if len(fp) > 2 {
				return nil, status.Errorf(codes.InvalidArgument, "sub path for maps ('%s') are not supported (object Alert_LogInfo)", fp)
			}
			return &AlertLogInfo_FieldPathMap{selector: AlertLogInfo_FieldPathSelectorCommonLogLabels, key: fp[1]}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object Alert_LogInfo", fp)
}

func ParseAlertLogInfo_FieldPath(rawField string) (AlertLogInfo_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildAlertLogInfo_FieldPath(fp)
}

func MustParseAlertLogInfo_FieldPath(rawField string) AlertLogInfo_FieldPath {
	fp, err := ParseAlertLogInfo_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type AlertLogInfo_FieldTerminalPath struct {
	selector AlertLogInfo_FieldPathSelector
}

var _ AlertLogInfo_FieldPath = (*AlertLogInfo_FieldTerminalPath)(nil)

func (fp *AlertLogInfo_FieldTerminalPath) Selector() AlertLogInfo_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source Alert_LogInfo
func (fp *AlertLogInfo_FieldTerminalPath) Get(source *Alert_LogInfo) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case AlertLogInfo_FieldPathSelectorCommonKey:
			values = append(values, source.CommonKey)
		case AlertLogInfo_FieldPathSelectorLogTypes:
			for _, value := range source.GetLogTypes() {
				values = append(values, value)
			}
		case AlertLogInfo_FieldPathSelectorCommonLogLabels:
			values = append(values, source.CommonLogLabels)
		case AlertLogInfo_FieldPathSelectorViolatingLog:
			values = append(values, source.ViolatingLog)
		default:
			panic(fmt.Sprintf("Invalid selector for Alert_LogInfo: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source Alert_LogInfo
func (fp *AlertLogInfo_FieldTerminalPath) GetSingle(source *Alert_LogInfo) (interface{}, bool) {
	switch fp.selector {
	case AlertLogInfo_FieldPathSelectorCommonKey:
		res := source.GetCommonKey()
		return res, res != nil
	case AlertLogInfo_FieldPathSelectorLogTypes:
		res := source.GetLogTypes()
		return res, res != nil
	case AlertLogInfo_FieldPathSelectorCommonLogLabels:
		res := source.GetCommonLogLabels()
		return res, res != nil
	case AlertLogInfo_FieldPathSelectorViolatingLog:
		return source.GetViolatingLog(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for Alert_LogInfo: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *AlertLogInfo_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case AlertLogInfo_FieldPathSelectorCommonKey:
		return ([]byte)(nil)
	case AlertLogInfo_FieldPathSelectorLogTypes:
		return ([]string)(nil)
	case AlertLogInfo_FieldPathSelectorCommonLogLabels:
		return (map[string]string)(nil)
	case AlertLogInfo_FieldPathSelectorViolatingLog:
		return ""
	default:
		panic(fmt.Sprintf("Invalid selector for Alert_LogInfo: %d", fp.selector))
	}
}

func (fp *AlertLogInfo_FieldTerminalPath) ClearValue(item *Alert_LogInfo) {
	if item != nil {
		switch fp.selector {
		case AlertLogInfo_FieldPathSelectorCommonKey:
			item.CommonKey = nil
		case AlertLogInfo_FieldPathSelectorLogTypes:
			item.LogTypes = nil
		case AlertLogInfo_FieldPathSelectorCommonLogLabels:
			item.CommonLogLabels = nil
		case AlertLogInfo_FieldPathSelectorViolatingLog:
			item.ViolatingLog = ""
		default:
			panic(fmt.Sprintf("Invalid selector for Alert_LogInfo: %d", fp.selector))
		}
	}
}

func (fp *AlertLogInfo_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*Alert_LogInfo))
}

// IsLeaf - whether field path is holds simple value
func (fp *AlertLogInfo_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == AlertLogInfo_FieldPathSelectorCommonKey ||
		fp.selector == AlertLogInfo_FieldPathSelectorLogTypes ||
		fp.selector == AlertLogInfo_FieldPathSelectorCommonLogLabels ||
		fp.selector == AlertLogInfo_FieldPathSelectorViolatingLog
}

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

func (fp *AlertLogInfo_FieldTerminalPath) WithIValue(value interface{}) AlertLogInfo_FieldPathValue {
	switch fp.selector {
	case AlertLogInfo_FieldPathSelectorCommonKey:
		return &AlertLogInfo_FieldTerminalPathValue{AlertLogInfo_FieldTerminalPath: *fp, value: value.([]byte)}
	case AlertLogInfo_FieldPathSelectorLogTypes:
		return &AlertLogInfo_FieldTerminalPathValue{AlertLogInfo_FieldTerminalPath: *fp, value: value.([]string)}
	case AlertLogInfo_FieldPathSelectorCommonLogLabels:
		return &AlertLogInfo_FieldTerminalPathValue{AlertLogInfo_FieldTerminalPath: *fp, value: value.(map[string]string)}
	case AlertLogInfo_FieldPathSelectorViolatingLog:
		return &AlertLogInfo_FieldTerminalPathValue{AlertLogInfo_FieldTerminalPath: *fp, value: value.(string)}
	default:
		panic(fmt.Sprintf("Invalid selector for Alert_LogInfo: %d", fp.selector))
	}
}

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

func (fp *AlertLogInfo_FieldTerminalPath) WithIArrayOfValues(values interface{}) AlertLogInfo_FieldPathArrayOfValues {
	fpaov := &AlertLogInfo_FieldTerminalPathArrayOfValues{AlertLogInfo_FieldTerminalPath: *fp}
	switch fp.selector {
	case AlertLogInfo_FieldPathSelectorCommonKey:
		return &AlertLogInfo_FieldTerminalPathArrayOfValues{AlertLogInfo_FieldTerminalPath: *fp, values: values.([][]byte)}
	case AlertLogInfo_FieldPathSelectorLogTypes:
		return &AlertLogInfo_FieldTerminalPathArrayOfValues{AlertLogInfo_FieldTerminalPath: *fp, values: values.([][]string)}
	case AlertLogInfo_FieldPathSelectorCommonLogLabels:
		return &AlertLogInfo_FieldTerminalPathArrayOfValues{AlertLogInfo_FieldTerminalPath: *fp, values: values.([]map[string]string)}
	case AlertLogInfo_FieldPathSelectorViolatingLog:
		return &AlertLogInfo_FieldTerminalPathArrayOfValues{AlertLogInfo_FieldTerminalPath: *fp, values: values.([]string)}
	default:
		panic(fmt.Sprintf("Invalid selector for Alert_LogInfo: %d", fp.selector))
	}
	return fpaov
}

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

func (fp *AlertLogInfo_FieldTerminalPath) WithIArrayItemValue(value interface{}) AlertLogInfo_FieldPathArrayItemValue {
	switch fp.selector {
	case AlertLogInfo_FieldPathSelectorLogTypes:
		return &AlertLogInfo_FieldTerminalPathArrayItemValue{AlertLogInfo_FieldTerminalPath: *fp, value: value.(string)}
	default:
		panic(fmt.Sprintf("Invalid selector for Alert_LogInfo: %d", fp.selector))
	}
}

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

// FieldPath for map type with additional Key information
type AlertLogInfo_FieldPathMap struct {
	key      string
	selector AlertLogInfo_FieldPathSelector
}

var _ AlertLogInfo_FieldPath = (*AlertLogInfo_FieldPathMap)(nil)

func (fpm *AlertLogInfo_FieldPathMap) Selector() AlertLogInfo_FieldPathSelector {
	return fpm.selector
}

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

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

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

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

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

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

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

func (fpm *AlertLogInfo_FieldPathMap) ClearValue(item *Alert_LogInfo) {
	if item != nil {
		switch fpm.selector {
		case AlertLogInfo_FieldPathSelectorCommonLogLabels:
			delete(item.CommonLogLabels, fpm.key)
		default:
			panic(fmt.Sprintf("Invalid selector for Alert_LogInfo: %d", fpm.selector))
		}
	}
}

func (fpm *AlertLogInfo_FieldPathMap) ClearValueRaw(item proto.Message) {
	fpm.ClearValue(item.(*Alert_LogInfo))
}

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

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

func (fpm *AlertLogInfo_FieldPathMap) WithIValue(value interface{}) AlertLogInfo_FieldPathValue {
	switch fpm.selector {
	case AlertLogInfo_FieldPathSelectorCommonLogLabels:
		return &AlertLogInfo_FieldPathMapValue{AlertLogInfo_FieldPathMap: *fpm, value: value.(string)}
	default:
		panic(fmt.Sprintf("Invalid selector for Alert_LogInfo: %d", fpm.selector))
	}
}

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

func (fpm *AlertLogInfo_FieldPathMap) WithIArrayOfValues(values interface{}) AlertLogInfo_FieldPathArrayOfValues {
	switch fpm.selector {
	case AlertLogInfo_FieldPathSelectorCommonLogLabels:
		return &AlertLogInfo_FieldPathMapArrayOfValues{AlertLogInfo_FieldPathMap: *fpm, values: values.([]string)}
	default:
		panic(fmt.Sprintf("Invalid selector for Alert_LogInfo: %d", fpm.selector))
	}
}

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

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

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

// AlertLogInfo_FieldPathValue allows storing values for LogInfo fields according to their type
type AlertLogInfo_FieldPathValue interface {
	AlertLogInfo_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **Alert_LogInfo)
	CompareWith(*Alert_LogInfo) (cmp int, comparable bool)
}

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

func MustParseAlertLogInfo_FieldPathValue(pathStr, valueStr string) AlertLogInfo_FieldPathValue {
	fpv, err := ParseAlertLogInfo_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type AlertLogInfo_FieldTerminalPathValue struct {
	AlertLogInfo_FieldTerminalPath
	value interface{}
}

var _ AlertLogInfo_FieldPathValue = (*AlertLogInfo_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'LogInfo' as interface{}
func (fpv *AlertLogInfo_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *AlertLogInfo_FieldTerminalPathValue) AsCommonKeyValue() ([]byte, bool) {
	res, ok := fpv.value.([]byte)
	return res, ok
}
func (fpv *AlertLogInfo_FieldTerminalPathValue) AsLogTypesValue() ([]string, bool) {
	res, ok := fpv.value.([]string)
	return res, ok
}
func (fpv *AlertLogInfo_FieldTerminalPathValue) AsCommonLogLabelsValue() (map[string]string, bool) {
	res, ok := fpv.value.(map[string]string)
	return res, ok
}
func (fpv *AlertLogInfo_FieldTerminalPathValue) AsViolatingLogValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}

// SetTo stores value for selected field for object LogInfo
func (fpv *AlertLogInfo_FieldTerminalPathValue) SetTo(target **Alert_LogInfo) {
	if *target == nil {
		*target = new(Alert_LogInfo)
	}
	switch fpv.selector {
	case AlertLogInfo_FieldPathSelectorCommonKey:
		(*target).CommonKey = fpv.value.([]byte)
	case AlertLogInfo_FieldPathSelectorLogTypes:
		(*target).LogTypes = fpv.value.([]string)
	case AlertLogInfo_FieldPathSelectorCommonLogLabels:
		(*target).CommonLogLabels = fpv.value.(map[string]string)
	case AlertLogInfo_FieldPathSelectorViolatingLog:
		(*target).ViolatingLog = fpv.value.(string)
	default:
		panic(fmt.Sprintf("Invalid selector for Alert_LogInfo: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'AlertLogInfo_FieldTerminalPathValue' with the value under path in 'Alert_LogInfo'.
func (fpv *AlertLogInfo_FieldTerminalPathValue) CompareWith(source *Alert_LogInfo) (int, bool) {
	switch fpv.selector {
	case AlertLogInfo_FieldPathSelectorCommonKey:
		return 0, false
	case AlertLogInfo_FieldPathSelectorLogTypes:
		return 0, false
	case AlertLogInfo_FieldPathSelectorCommonLogLabels:
		return 0, false
	case AlertLogInfo_FieldPathSelectorViolatingLog:
		leftValue := fpv.value.(string)
		rightValue := source.GetViolatingLog()
		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_LogInfo: %d", fpv.selector))
	}
}

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

type AlertLogInfo_FieldPathMapValue struct {
	AlertLogInfo_FieldPathMap
	value interface{}
}

var _ AlertLogInfo_FieldPathValue = (*AlertLogInfo_FieldPathMapValue)(nil)

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

// SetTo stores value for selected field in LogInfo
func (fpmv *AlertLogInfo_FieldPathMapValue) SetTo(target **Alert_LogInfo) {
	if *target == nil {
		*target = new(Alert_LogInfo)
	}
	switch fpmv.selector {
	case AlertLogInfo_FieldPathSelectorCommonLogLabels:
		if (*target).CommonLogLabels == nil {
			(*target).CommonLogLabels = make(map[string]string)
		}
		(*target).CommonLogLabels[fpmv.key] = fpmv.value.(string)
	default:
		panic(fmt.Sprintf("Invalid selector for Alert_LogInfo: %d", fpmv.selector))
	}
}

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

// CompareWith compares value in the 'AlertLogInfo_FieldPathMapValue' with the value under path in 'Alert_LogInfo'.
func (fpmv *AlertLogInfo_FieldPathMapValue) CompareWith(source *Alert_LogInfo) (int, bool) {
	switch fpmv.selector {
	case AlertLogInfo_FieldPathSelectorCommonLogLabels:
		leftValue := fpmv.value.(string)
		rightValue := source.GetCommonLogLabels()[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_LogInfo: %d", fpmv.selector))
	}
}

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

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

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

func MustParseAlertLogInfo_FieldPathArrayItemValue(pathStr, valueStr string) AlertLogInfo_FieldPathArrayItemValue {
	fpaiv, err := ParseAlertLogInfo_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type AlertLogInfo_FieldTerminalPathArrayItemValue struct {
	AlertLogInfo_FieldTerminalPath
	value interface{}
}

var _ AlertLogInfo_FieldPathArrayItemValue = (*AlertLogInfo_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object Alert_LogInfo as interface{}
func (fpaiv *AlertLogInfo_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}
func (fpaiv *AlertLogInfo_FieldTerminalPathArrayItemValue) AsLogTypesItemValue() (string, bool) {
	res, ok := fpaiv.value.(string)
	return res, ok
}

func (fpaiv *AlertLogInfo_FieldTerminalPathArrayItemValue) GetSingle(source *Alert_LogInfo) (interface{}, bool) {
	return nil, false
}

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

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

// AlertLogInfo_FieldPathArrayOfValues allows storing slice of values for LogInfo fields according to their type
type AlertLogInfo_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	AlertLogInfo_FieldPath
}

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

func MustParseAlertLogInfo_FieldPathArrayOfValues(pathStr, valuesStr string) AlertLogInfo_FieldPathArrayOfValues {
	fpaov, err := ParseAlertLogInfo_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type AlertLogInfo_FieldTerminalPathArrayOfValues struct {
	AlertLogInfo_FieldTerminalPath
	values interface{}
}

var _ AlertLogInfo_FieldPathArrayOfValues = (*AlertLogInfo_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *AlertLogInfo_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case AlertLogInfo_FieldPathSelectorCommonKey:
		for _, v := range fpaov.values.([][]byte) {
			values = append(values, v)
		}
	case AlertLogInfo_FieldPathSelectorLogTypes:
		for _, v := range fpaov.values.([][]string) {
			values = append(values, v)
		}
	case AlertLogInfo_FieldPathSelectorCommonLogLabels:
		for _, v := range fpaov.values.([]map[string]string) {
			values = append(values, v)
		}
	case AlertLogInfo_FieldPathSelectorViolatingLog:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *AlertLogInfo_FieldTerminalPathArrayOfValues) AsCommonKeyArrayOfValues() ([][]byte, bool) {
	res, ok := fpaov.values.([][]byte)
	return res, ok
}
func (fpaov *AlertLogInfo_FieldTerminalPathArrayOfValues) AsLogTypesArrayOfValues() ([][]string, bool) {
	res, ok := fpaov.values.([][]string)
	return res, ok
}
func (fpaov *AlertLogInfo_FieldTerminalPathArrayOfValues) AsCommonLogLabelsArrayOfValues() ([]map[string]string, bool) {
	res, ok := fpaov.values.([]map[string]string)
	return res, ok
}
func (fpaov *AlertLogInfo_FieldTerminalPathArrayOfValues) AsViolatingLogArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}

type AlertLogInfo_FieldPathMapArrayOfValues struct {
	AlertLogInfo_FieldPathMap
	values interface{}
}

var _ AlertLogInfo_FieldPathArrayOfValues = (*AlertLogInfo_FieldPathMapArrayOfValues)(nil)

func (fpmaov *AlertLogInfo_FieldPathMapArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpmaov.selector {
	case AlertLogInfo_FieldPathSelectorCommonLogLabels:
		for _, v := range fpmaov.values.([]string) {
			values = append(values, v)
		}
	}
	return
}
func (fpmaov *AlertLogInfo_FieldPathMapArrayOfValues) AsCommonLogLabelsArrayOfElementValues() ([]string, bool) {
	res, ok := fpmaov.values.([]string)
	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_FieldPathSelectorStartTime                   AlertState_FieldPathSelector = 1
	AlertState_FieldPathSelectorEndTime                     AlertState_FieldPathSelector = 2
	AlertState_FieldPathSelectorNotificationStatuses        AlertState_FieldPathSelector = 3
	AlertState_FieldPathSelectorEscalationLevel             AlertState_FieldPathSelector = 4
	AlertState_FieldPathSelectorAiAgentHandlingState        AlertState_FieldPathSelector = 5
	AlertState_FieldPathSelectorAiAgentLastStateChangeTime  AlertState_FieldPathSelector = 6
	AlertState_FieldPathSelectorAiAgentDiagnosisNotes       AlertState_FieldPathSelector = 7
	AlertState_FieldPathSelectorAiRemediationArg            AlertState_FieldPathSelector = 8
	AlertState_FieldPathSelectorAiRemediation               AlertState_FieldPathSelector = 9
	AlertState_FieldPathSelectorOperatorHandlingState       AlertState_FieldPathSelector = 10
	AlertState_FieldPathSelectorOperatorLastStateChangeTime AlertState_FieldPathSelector = 11
	AlertState_FieldPathSelectorOperatorNotes               AlertState_FieldPathSelector = 12
	AlertState_FieldPathSelectorLifecycleCompleted          AlertState_FieldPathSelector = 13
)

func (s AlertState_FieldPathSelector) String() string {
	switch s {
	case AlertState_FieldPathSelectorIsFiring:
		return "is_firing"
	case AlertState_FieldPathSelectorStartTime:
		return "start_time"
	case AlertState_FieldPathSelectorEndTime:
		return "end_time"
	case AlertState_FieldPathSelectorNotificationStatuses:
		return "notification_statuses"
	case AlertState_FieldPathSelectorEscalationLevel:
		return "escalation_level"
	case AlertState_FieldPathSelectorAiAgentHandlingState:
		return "ai_agent_handling_state"
	case AlertState_FieldPathSelectorAiAgentLastStateChangeTime:
		return "ai_agent_last_state_change_time"
	case AlertState_FieldPathSelectorAiAgentDiagnosisNotes:
		return "ai_agent_diagnosis_notes"
	case AlertState_FieldPathSelectorAiRemediationArg:
		return "ai_remediation_arg"
	case AlertState_FieldPathSelectorAiRemediation:
		return "ai_remediation"
	case AlertState_FieldPathSelectorOperatorHandlingState:
		return "operator_handling_state"
	case AlertState_FieldPathSelectorOperatorLastStateChangeTime:
		return "operator_last_state_change_time"
	case AlertState_FieldPathSelectorOperatorNotes:
		return "operator_notes"
	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 "start_time", "startTime", "start-time":
			return &AlertState_FieldTerminalPath{selector: AlertState_FieldPathSelectorStartTime}, nil
		case "end_time", "endTime", "end-time":
			return &AlertState_FieldTerminalPath{selector: AlertState_FieldPathSelectorEndTime}, nil
		case "notification_statuses", "notificationStatuses", "notification-statuses":
			return &AlertState_FieldTerminalPath{selector: AlertState_FieldPathSelectorNotificationStatuses}, nil
		case "escalation_level", "escalationLevel", "escalation-level":
			return &AlertState_FieldTerminalPath{selector: AlertState_FieldPathSelectorEscalationLevel}, nil
		case "ai_agent_handling_state", "aiAgentHandlingState", "ai-agent-handling-state":
			return &AlertState_FieldTerminalPath{selector: AlertState_FieldPathSelectorAiAgentHandlingState}, nil
		case "ai_agent_last_state_change_time", "aiAgentLastStateChangeTime", "ai-agent-last-state-change-time":
			return &AlertState_FieldTerminalPath{selector: AlertState_FieldPathSelectorAiAgentLastStateChangeTime}, nil
		case "ai_agent_diagnosis_notes", "aiAgentDiagnosisNotes", "ai-agent-diagnosis-notes":
			return &AlertState_FieldTerminalPath{selector: AlertState_FieldPathSelectorAiAgentDiagnosisNotes}, nil
		case "ai_remediation_arg", "aiRemediationArg", "ai-remediation-arg":
			return &AlertState_FieldTerminalPath{selector: AlertState_FieldPathSelectorAiRemediationArg}, nil
		case "ai_remediation", "aiRemediation", "ai-remediation":
			return &AlertState_FieldTerminalPath{selector: AlertState_FieldPathSelectorAiRemediation}, nil
		case "operator_handling_state", "operatorHandlingState", "operator-handling-state":
			return &AlertState_FieldTerminalPath{selector: AlertState_FieldPathSelectorOperatorHandlingState}, nil
		case "operator_last_state_change_time", "operatorLastStateChangeTime", "operator-last-state-change-time":
			return &AlertState_FieldTerminalPath{selector: AlertState_FieldPathSelectorOperatorLastStateChangeTime}, nil
		case "operator_notes", "operatorNotes", "operator-notes":
			return &AlertState_FieldTerminalPath{selector: AlertState_FieldPathSelectorOperatorNotes}, nil
		case "lifecycle_completed", "lifecycleCompleted", "lifecycle-completed":
			return &AlertState_FieldTerminalPath{selector: AlertState_FieldPathSelectorLifecycleCompleted}, nil
		}
	} else {
		switch fp[0] {
		case "notification_statuses", "notificationStatuses", "notification-statuses":
			if subpath, err := BuildAlertStateNotification_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &AlertState_FieldSubPath{selector: AlertState_FieldPathSelectorNotificationStatuses, subPath: subpath}, nil
			}
		case "ai_remediation", "aiRemediation", "ai-remediation":
			if subpath, err := rcommon.BuildPolicySpecAIAgentHandlingRemediation_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &AlertState_FieldSubPath{selector: AlertState_FieldPathSelectorAiRemediation, 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_FieldPathSelectorStartTime:
			if source.StartTime != nil {
				values = append(values, source.StartTime)
			}
		case AlertState_FieldPathSelectorEndTime:
			if source.EndTime != nil {
				values = append(values, source.EndTime)
			}
		case AlertState_FieldPathSelectorNotificationStatuses:
			for _, value := range source.GetNotificationStatuses() {
				values = append(values, value)
			}
		case AlertState_FieldPathSelectorEscalationLevel:
			values = append(values, source.EscalationLevel)
		case AlertState_FieldPathSelectorAiAgentHandlingState:
			values = append(values, source.AiAgentHandlingState)
		case AlertState_FieldPathSelectorAiAgentLastStateChangeTime:
			if source.AiAgentLastStateChangeTime != nil {
				values = append(values, source.AiAgentLastStateChangeTime)
			}
		case AlertState_FieldPathSelectorAiAgentDiagnosisNotes:
			values = append(values, source.AiAgentDiagnosisNotes)
		case AlertState_FieldPathSelectorAiRemediationArg:
			values = append(values, source.AiRemediationArg)
		case AlertState_FieldPathSelectorAiRemediation:
			if source.AiRemediation != nil {
				values = append(values, source.AiRemediation)
			}
		case AlertState_FieldPathSelectorOperatorHandlingState:
			values = append(values, source.OperatorHandlingState)
		case AlertState_FieldPathSelectorOperatorLastStateChangeTime:
			if source.OperatorLastStateChangeTime != nil {
				values = append(values, source.OperatorLastStateChangeTime)
			}
		case AlertState_FieldPathSelectorOperatorNotes:
			values = append(values, source.OperatorNotes)
		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_FieldPathSelectorStartTime:
		res := source.GetStartTime()
		return res, res != nil
	case AlertState_FieldPathSelectorEndTime:
		res := source.GetEndTime()
		return res, res != nil
	case AlertState_FieldPathSelectorNotificationStatuses:
		res := source.GetNotificationStatuses()
		return res, res != nil
	case AlertState_FieldPathSelectorEscalationLevel:
		return source.GetEscalationLevel(), source != nil
	case AlertState_FieldPathSelectorAiAgentHandlingState:
		return source.GetAiAgentHandlingState(), source != nil
	case AlertState_FieldPathSelectorAiAgentLastStateChangeTime:
		res := source.GetAiAgentLastStateChangeTime()
		return res, res != nil
	case AlertState_FieldPathSelectorAiAgentDiagnosisNotes:
		return source.GetAiAgentDiagnosisNotes(), source != nil
	case AlertState_FieldPathSelectorAiRemediationArg:
		return source.GetAiRemediationArg(), source != nil
	case AlertState_FieldPathSelectorAiRemediation:
		res := source.GetAiRemediation()
		return res, res != nil
	case AlertState_FieldPathSelectorOperatorHandlingState:
		return source.GetOperatorHandlingState(), source != nil
	case AlertState_FieldPathSelectorOperatorLastStateChangeTime:
		res := source.GetOperatorLastStateChangeTime()
		return res, res != nil
	case AlertState_FieldPathSelectorOperatorNotes:
		return source.GetOperatorNotes(), 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_FieldPathSelectorStartTime:
		return (*timestamppb.Timestamp)(nil)
	case AlertState_FieldPathSelectorEndTime:
		return (*timestamppb.Timestamp)(nil)
	case AlertState_FieldPathSelectorNotificationStatuses:
		return ([]*Alert_State_Notification)(nil)
	case AlertState_FieldPathSelectorEscalationLevel:
		return Alert_State_NONE
	case AlertState_FieldPathSelectorAiAgentHandlingState:
		return Alert_State_AI_AGENT_NOT_INVOLVED
	case AlertState_FieldPathSelectorAiAgentLastStateChangeTime:
		return (*timestamppb.Timestamp)(nil)
	case AlertState_FieldPathSelectorAiAgentDiagnosisNotes:
		return ""
	case AlertState_FieldPathSelectorAiRemediationArg:
		return ""
	case AlertState_FieldPathSelectorAiRemediation:
		return (*rcommon.PolicySpec_AIAgentHandling_Remediation)(nil)
	case AlertState_FieldPathSelectorOperatorHandlingState:
		return Alert_State_OP_NOT_INVOLVED
	case AlertState_FieldPathSelectorOperatorLastStateChangeTime:
		return (*timestamppb.Timestamp)(nil)
	case AlertState_FieldPathSelectorOperatorNotes:
		return ""
	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_FieldPathSelectorStartTime:
			item.StartTime = nil
		case AlertState_FieldPathSelectorEndTime:
			item.EndTime = nil
		case AlertState_FieldPathSelectorNotificationStatuses:
			item.NotificationStatuses = nil
		case AlertState_FieldPathSelectorEscalationLevel:
			item.EscalationLevel = Alert_State_NONE
		case AlertState_FieldPathSelectorAiAgentHandlingState:
			item.AiAgentHandlingState = Alert_State_AI_AGENT_NOT_INVOLVED
		case AlertState_FieldPathSelectorAiAgentLastStateChangeTime:
			item.AiAgentLastStateChangeTime = nil
		case AlertState_FieldPathSelectorAiAgentDiagnosisNotes:
			item.AiAgentDiagnosisNotes = ""
		case AlertState_FieldPathSelectorAiRemediationArg:
			item.AiRemediationArg = ""
		case AlertState_FieldPathSelectorAiRemediation:
			item.AiRemediation = nil
		case AlertState_FieldPathSelectorOperatorHandlingState:
			item.OperatorHandlingState = Alert_State_OP_NOT_INVOLVED
		case AlertState_FieldPathSelectorOperatorLastStateChangeTime:
			item.OperatorLastStateChangeTime = nil
		case AlertState_FieldPathSelectorOperatorNotes:
			item.OperatorNotes = ""
		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_FieldPathSelectorStartTime ||
		fp.selector == AlertState_FieldPathSelectorEndTime ||
		fp.selector == AlertState_FieldPathSelectorEscalationLevel ||
		fp.selector == AlertState_FieldPathSelectorAiAgentHandlingState ||
		fp.selector == AlertState_FieldPathSelectorAiAgentLastStateChangeTime ||
		fp.selector == AlertState_FieldPathSelectorAiAgentDiagnosisNotes ||
		fp.selector == AlertState_FieldPathSelectorAiRemediationArg ||
		fp.selector == AlertState_FieldPathSelectorOperatorHandlingState ||
		fp.selector == AlertState_FieldPathSelectorOperatorLastStateChangeTime ||
		fp.selector == AlertState_FieldPathSelectorOperatorNotes ||
		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_FieldPathSelectorStartTime:
		return &AlertState_FieldTerminalPathValue{AlertState_FieldTerminalPath: *fp, value: value.(*timestamppb.Timestamp)}
	case AlertState_FieldPathSelectorEndTime:
		return &AlertState_FieldTerminalPathValue{AlertState_FieldTerminalPath: *fp, value: value.(*timestamppb.Timestamp)}
	case AlertState_FieldPathSelectorNotificationStatuses:
		return &AlertState_FieldTerminalPathValue{AlertState_FieldTerminalPath: *fp, value: value.([]*Alert_State_Notification)}
	case AlertState_FieldPathSelectorEscalationLevel:
		return &AlertState_FieldTerminalPathValue{AlertState_FieldTerminalPath: *fp, value: value.(Alert_State_EscalationLevel)}
	case AlertState_FieldPathSelectorAiAgentHandlingState:
		return &AlertState_FieldTerminalPathValue{AlertState_FieldTerminalPath: *fp, value: value.(Alert_State_AiHandlingState)}
	case AlertState_FieldPathSelectorAiAgentLastStateChangeTime:
		return &AlertState_FieldTerminalPathValue{AlertState_FieldTerminalPath: *fp, value: value.(*timestamppb.Timestamp)}
	case AlertState_FieldPathSelectorAiAgentDiagnosisNotes:
		return &AlertState_FieldTerminalPathValue{AlertState_FieldTerminalPath: *fp, value: value.(string)}
	case AlertState_FieldPathSelectorAiRemediationArg:
		return &AlertState_FieldTerminalPathValue{AlertState_FieldTerminalPath: *fp, value: value.(string)}
	case AlertState_FieldPathSelectorAiRemediation:
		return &AlertState_FieldTerminalPathValue{AlertState_FieldTerminalPath: *fp, value: value.(*rcommon.PolicySpec_AIAgentHandling_Remediation)}
	case AlertState_FieldPathSelectorOperatorHandlingState:
		return &AlertState_FieldTerminalPathValue{AlertState_FieldTerminalPath: *fp, value: value.(Alert_State_OperatorHandlingState)}
	case AlertState_FieldPathSelectorOperatorLastStateChangeTime:
		return &AlertState_FieldTerminalPathValue{AlertState_FieldTerminalPath: *fp, value: value.(*timestamppb.Timestamp)}
	case AlertState_FieldPathSelectorOperatorNotes:
		return &AlertState_FieldTerminalPathValue{AlertState_FieldTerminalPath: *fp, value: value.(string)}
	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_FieldPathSelectorStartTime:
		return &AlertState_FieldTerminalPathArrayOfValues{AlertState_FieldTerminalPath: *fp, values: values.([]*timestamppb.Timestamp)}
	case AlertState_FieldPathSelectorEndTime:
		return &AlertState_FieldTerminalPathArrayOfValues{AlertState_FieldTerminalPath: *fp, values: values.([]*timestamppb.Timestamp)}
	case AlertState_FieldPathSelectorNotificationStatuses:
		return &AlertState_FieldTerminalPathArrayOfValues{AlertState_FieldTerminalPath: *fp, values: values.([][]*Alert_State_Notification)}
	case AlertState_FieldPathSelectorEscalationLevel:
		return &AlertState_FieldTerminalPathArrayOfValues{AlertState_FieldTerminalPath: *fp, values: values.([]Alert_State_EscalationLevel)}
	case AlertState_FieldPathSelectorAiAgentHandlingState:
		return &AlertState_FieldTerminalPathArrayOfValues{AlertState_FieldTerminalPath: *fp, values: values.([]Alert_State_AiHandlingState)}
	case AlertState_FieldPathSelectorAiAgentLastStateChangeTime:
		return &AlertState_FieldTerminalPathArrayOfValues{AlertState_FieldTerminalPath: *fp, values: values.([]*timestamppb.Timestamp)}
	case AlertState_FieldPathSelectorAiAgentDiagnosisNotes:
		return &AlertState_FieldTerminalPathArrayOfValues{AlertState_FieldTerminalPath: *fp, values: values.([]string)}
	case AlertState_FieldPathSelectorAiRemediationArg:
		return &AlertState_FieldTerminalPathArrayOfValues{AlertState_FieldTerminalPath: *fp, values: values.([]string)}
	case AlertState_FieldPathSelectorAiRemediation:
		return &AlertState_FieldTerminalPathArrayOfValues{AlertState_FieldTerminalPath: *fp, values: values.([]*rcommon.PolicySpec_AIAgentHandling_Remediation)}
	case AlertState_FieldPathSelectorOperatorHandlingState:
		return &AlertState_FieldTerminalPathArrayOfValues{AlertState_FieldTerminalPath: *fp, values: values.([]Alert_State_OperatorHandlingState)}
	case AlertState_FieldPathSelectorOperatorLastStateChangeTime:
		return &AlertState_FieldTerminalPathArrayOfValues{AlertState_FieldTerminalPath: *fp, values: values.([]*timestamppb.Timestamp)}
	case AlertState_FieldPathSelectorOperatorNotes:
		return &AlertState_FieldTerminalPathArrayOfValues{AlertState_FieldTerminalPath: *fp, values: values.([]string)}
	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 {
	case AlertState_FieldPathSelectorNotificationStatuses:
		return &AlertState_FieldTerminalPathArrayItemValue{AlertState_FieldTerminalPath: *fp, value: value.(*Alert_State_Notification)}
	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) AsNotificationStatusesSubPath() (AlertStateNotification_FieldPath, bool) {
	res, ok := fps.subPath.(AlertStateNotification_FieldPath)
	return res, ok
}
func (fps *AlertState_FieldSubPath) AsAiRemediationSubPath() (rcommon.PolicySpecAIAgentHandlingRemediation_FieldPath, bool) {
	res, ok := fps.subPath.(rcommon.PolicySpecAIAgentHandlingRemediation_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_FieldPathSelectorNotificationStatuses:
		for _, item := range source.GetNotificationStatuses() {
			values = append(values, fps.subPath.GetRaw(item)...)
		}
	case AlertState_FieldPathSelectorAiRemediation:
		values = append(values, fps.subPath.GetRaw(source.GetAiRemediation())...)
	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_FieldPathSelectorNotificationStatuses:
		if len(source.GetNotificationStatuses()) == 0 {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetNotificationStatuses()[0])
	case AlertState_FieldPathSelectorAiRemediation:
		if source.GetAiRemediation() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetAiRemediation())
	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_FieldPathSelectorNotificationStatuses:
			for _, subItem := range item.NotificationStatuses {
				fps.subPath.ClearValueRaw(subItem)
			}
		case AlertState_FieldPathSelectorAiRemediation:
			fps.subPath.ClearValueRaw(item.AiRemediation)
		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) AsStartTimeValue() (*timestamppb.Timestamp, bool) {
	res, ok := fpv.value.(*timestamppb.Timestamp)
	return res, ok
}
func (fpv *AlertState_FieldTerminalPathValue) AsEndTimeValue() (*timestamppb.Timestamp, bool) {
	res, ok := fpv.value.(*timestamppb.Timestamp)
	return res, ok
}
func (fpv *AlertState_FieldTerminalPathValue) AsNotificationStatusesValue() ([]*Alert_State_Notification, bool) {
	res, ok := fpv.value.([]*Alert_State_Notification)
	return res, ok
}
func (fpv *AlertState_FieldTerminalPathValue) AsEscalationLevelValue() (Alert_State_EscalationLevel, bool) {
	res, ok := fpv.value.(Alert_State_EscalationLevel)
	return res, ok
}
func (fpv *AlertState_FieldTerminalPathValue) AsAiAgentHandlingStateValue() (Alert_State_AiHandlingState, bool) {
	res, ok := fpv.value.(Alert_State_AiHandlingState)
	return res, ok
}
func (fpv *AlertState_FieldTerminalPathValue) AsAiAgentLastStateChangeTimeValue() (*timestamppb.Timestamp, bool) {
	res, ok := fpv.value.(*timestamppb.Timestamp)
	return res, ok
}
func (fpv *AlertState_FieldTerminalPathValue) AsAiAgentDiagnosisNotesValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *AlertState_FieldTerminalPathValue) AsAiRemediationArgValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *AlertState_FieldTerminalPathValue) AsAiRemediationValue() (*rcommon.PolicySpec_AIAgentHandling_Remediation, bool) {
	res, ok := fpv.value.(*rcommon.PolicySpec_AIAgentHandling_Remediation)
	return res, ok
}
func (fpv *AlertState_FieldTerminalPathValue) AsOperatorHandlingStateValue() (Alert_State_OperatorHandlingState, bool) {
	res, ok := fpv.value.(Alert_State_OperatorHandlingState)
	return res, ok
}
func (fpv *AlertState_FieldTerminalPathValue) AsOperatorLastStateChangeTimeValue() (*timestamppb.Timestamp, bool) {
	res, ok := fpv.value.(*timestamppb.Timestamp)
	return res, ok
}
func (fpv *AlertState_FieldTerminalPathValue) AsOperatorNotesValue() (string, bool) {
	res, ok := fpv.value.(string)
	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_FieldPathSelectorStartTime:
		(*target).StartTime = fpv.value.(*timestamppb.Timestamp)
	case AlertState_FieldPathSelectorEndTime:
		(*target).EndTime = fpv.value.(*timestamppb.Timestamp)
	case AlertState_FieldPathSelectorNotificationStatuses:
		(*target).NotificationStatuses = fpv.value.([]*Alert_State_Notification)
	case AlertState_FieldPathSelectorEscalationLevel:
		(*target).EscalationLevel = fpv.value.(Alert_State_EscalationLevel)
	case AlertState_FieldPathSelectorAiAgentHandlingState:
		(*target).AiAgentHandlingState = fpv.value.(Alert_State_AiHandlingState)
	case AlertState_FieldPathSelectorAiAgentLastStateChangeTime:
		(*target).AiAgentLastStateChangeTime = fpv.value.(*timestamppb.Timestamp)
	case AlertState_FieldPathSelectorAiAgentDiagnosisNotes:
		(*target).AiAgentDiagnosisNotes = fpv.value.(string)
	case AlertState_FieldPathSelectorAiRemediationArg:
		(*target).AiRemediationArg = fpv.value.(string)
	case AlertState_FieldPathSelectorAiRemediation:
		(*target).AiRemediation = fpv.value.(*rcommon.PolicySpec_AIAgentHandling_Remediation)
	case AlertState_FieldPathSelectorOperatorHandlingState:
		(*target).OperatorHandlingState = fpv.value.(Alert_State_OperatorHandlingState)
	case AlertState_FieldPathSelectorOperatorLastStateChangeTime:
		(*target).OperatorLastStateChangeTime = fpv.value.(*timestamppb.Timestamp)
	case AlertState_FieldPathSelectorOperatorNotes:
		(*target).OperatorNotes = fpv.value.(string)
	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_FieldPathSelectorStartTime:
		leftValue := fpv.value.(*timestamppb.Timestamp)
		rightValue := source.GetStartTime()
		if leftValue == nil {
			if rightValue != nil {
				return -1, true
			}
			return 0, true
		}
		if rightValue == nil {
			return 1, true
		}
		if leftValue.AsTime().Equal(rightValue.AsTime()) {
			return 0, true
		} else if leftValue.AsTime().Before(rightValue.AsTime()) {
			return -1, true
		} else {
			return 1, true
		}
	case AlertState_FieldPathSelectorEndTime:
		leftValue := fpv.value.(*timestamppb.Timestamp)
		rightValue := source.GetEndTime()
		if leftValue == nil {
			if rightValue != nil {
				return -1, true
			}
			return 0, true
		}
		if rightValue == nil {
			return 1, true
		}
		if leftValue.AsTime().Equal(rightValue.AsTime()) {
			return 0, true
		} else if leftValue.AsTime().Before(rightValue.AsTime()) {
			return -1, true
		} else {
			return 1, true
		}
	case AlertState_FieldPathSelectorNotificationStatuses:
		return 0, false
	case AlertState_FieldPathSelectorEscalationLevel:
		leftValue := fpv.value.(Alert_State_EscalationLevel)
		rightValue := source.GetEscalationLevel()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case AlertState_FieldPathSelectorAiAgentHandlingState:
		leftValue := fpv.value.(Alert_State_AiHandlingState)
		rightValue := source.GetAiAgentHandlingState()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case AlertState_FieldPathSelectorAiAgentLastStateChangeTime:
		leftValue := fpv.value.(*timestamppb.Timestamp)
		rightValue := source.GetAiAgentLastStateChangeTime()
		if leftValue == nil {
			if rightValue != nil {
				return -1, true
			}
			return 0, true
		}
		if rightValue == nil {
			return 1, true
		}
		if leftValue.AsTime().Equal(rightValue.AsTime()) {
			return 0, true
		} else if leftValue.AsTime().Before(rightValue.AsTime()) {
			return -1, true
		} else {
			return 1, true
		}
	case AlertState_FieldPathSelectorAiAgentDiagnosisNotes:
		leftValue := fpv.value.(string)
		rightValue := source.GetAiAgentDiagnosisNotes()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case AlertState_FieldPathSelectorAiRemediationArg:
		leftValue := fpv.value.(string)
		rightValue := source.GetAiRemediationArg()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case AlertState_FieldPathSelectorAiRemediation:
		return 0, false
	case AlertState_FieldPathSelectorOperatorHandlingState:
		leftValue := fpv.value.(Alert_State_OperatorHandlingState)
		rightValue := source.GetOperatorHandlingState()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case AlertState_FieldPathSelectorOperatorLastStateChangeTime:
		leftValue := fpv.value.(*timestamppb.Timestamp)
		rightValue := source.GetOperatorLastStateChangeTime()
		if leftValue == nil {
			if rightValue != nil {
				return -1, true
			}
			return 0, true
		}
		if rightValue == nil {
			return 1, true
		}
		if leftValue.AsTime().Equal(rightValue.AsTime()) {
			return 0, true
		} else if leftValue.AsTime().Before(rightValue.AsTime()) {
			return -1, true
		} else {
			return 1, true
		}
	case AlertState_FieldPathSelectorOperatorNotes:
		leftValue := fpv.value.(string)
		rightValue := source.GetOperatorNotes()
		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) AsNotificationStatusesPathValue() (AlertStateNotification_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(AlertStateNotification_FieldPathValue)
	return res, ok
}
func (fpvs *AlertState_FieldSubPathValue) AsAiRemediationPathValue() (rcommon.PolicySpecAIAgentHandlingRemediation_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(rcommon.PolicySpecAIAgentHandlingRemediation_FieldPathValue)
	return res, ok
}

func (fpvs *AlertState_FieldSubPathValue) SetTo(target **Alert_State) {
	if *target == nil {
		*target = new(Alert_State)
	}
	switch fpvs.Selector() {
	case AlertState_FieldPathSelectorNotificationStatuses:
		panic("FieldPath setter is unsupported for array subpaths")
	case AlertState_FieldPathSelectorAiRemediation:
		fpvs.subPathValue.(rcommon.PolicySpecAIAgentHandlingRemediation_FieldPathValue).SetTo(&(*target).AiRemediation)
	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_FieldPathSelectorNotificationStatuses:
		return 0, false // repeated field
	case AlertState_FieldPathSelectorAiRemediation:
		return fpvs.subPathValue.(rcommon.PolicySpecAIAgentHandlingRemediation_FieldPathValue).CompareWith(source.GetAiRemediation())
	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) AsNotificationStatusesItemValue() (*Alert_State_Notification, bool) {
	res, ok := fpaiv.value.(*Alert_State_Notification)
	return res, ok
}

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) AsNotificationStatusesPathItemValue() (AlertStateNotification_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(AlertStateNotification_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *AlertState_FieldSubPathArrayItemValue) AsAiRemediationPathItemValue() (rcommon.PolicySpecAIAgentHandlingRemediation_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(rcommon.PolicySpecAIAgentHandlingRemediation_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_FieldPathSelectorNotificationStatuses:
		return false // repeated/map field
	case AlertState_FieldPathSelectorAiRemediation:
		return fpaivs.subPathItemValue.(rcommon.PolicySpecAIAgentHandlingRemediation_FieldPathArrayItemValue).ContainsValue(source.GetAiRemediation())
	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_FieldPathSelectorStartTime:
		for _, v := range fpaov.values.([]*timestamppb.Timestamp) {
			values = append(values, v)
		}
	case AlertState_FieldPathSelectorEndTime:
		for _, v := range fpaov.values.([]*timestamppb.Timestamp) {
			values = append(values, v)
		}
	case AlertState_FieldPathSelectorNotificationStatuses:
		for _, v := range fpaov.values.([][]*Alert_State_Notification) {
			values = append(values, v)
		}
	case AlertState_FieldPathSelectorEscalationLevel:
		for _, v := range fpaov.values.([]Alert_State_EscalationLevel) {
			values = append(values, v)
		}
	case AlertState_FieldPathSelectorAiAgentHandlingState:
		for _, v := range fpaov.values.([]Alert_State_AiHandlingState) {
			values = append(values, v)
		}
	case AlertState_FieldPathSelectorAiAgentLastStateChangeTime:
		for _, v := range fpaov.values.([]*timestamppb.Timestamp) {
			values = append(values, v)
		}
	case AlertState_FieldPathSelectorAiAgentDiagnosisNotes:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case AlertState_FieldPathSelectorAiRemediationArg:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case AlertState_FieldPathSelectorAiRemediation:
		for _, v := range fpaov.values.([]*rcommon.PolicySpec_AIAgentHandling_Remediation) {
			values = append(values, v)
		}
	case AlertState_FieldPathSelectorOperatorHandlingState:
		for _, v := range fpaov.values.([]Alert_State_OperatorHandlingState) {
			values = append(values, v)
		}
	case AlertState_FieldPathSelectorOperatorLastStateChangeTime:
		for _, v := range fpaov.values.([]*timestamppb.Timestamp) {
			values = append(values, v)
		}
	case AlertState_FieldPathSelectorOperatorNotes:
		for _, v := range fpaov.values.([]string) {
			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) AsStartTimeArrayOfValues() ([]*timestamppb.Timestamp, bool) {
	res, ok := fpaov.values.([]*timestamppb.Timestamp)
	return res, ok
}
func (fpaov *AlertState_FieldTerminalPathArrayOfValues) AsEndTimeArrayOfValues() ([]*timestamppb.Timestamp, bool) {
	res, ok := fpaov.values.([]*timestamppb.Timestamp)
	return res, ok
}
func (fpaov *AlertState_FieldTerminalPathArrayOfValues) AsNotificationStatusesArrayOfValues() ([][]*Alert_State_Notification, bool) {
	res, ok := fpaov.values.([][]*Alert_State_Notification)
	return res, ok
}
func (fpaov *AlertState_FieldTerminalPathArrayOfValues) AsEscalationLevelArrayOfValues() ([]Alert_State_EscalationLevel, bool) {
	res, ok := fpaov.values.([]Alert_State_EscalationLevel)
	return res, ok
}
func (fpaov *AlertState_FieldTerminalPathArrayOfValues) AsAiAgentHandlingStateArrayOfValues() ([]Alert_State_AiHandlingState, bool) {
	res, ok := fpaov.values.([]Alert_State_AiHandlingState)
	return res, ok
}
func (fpaov *AlertState_FieldTerminalPathArrayOfValues) AsAiAgentLastStateChangeTimeArrayOfValues() ([]*timestamppb.Timestamp, bool) {
	res, ok := fpaov.values.([]*timestamppb.Timestamp)
	return res, ok
}
func (fpaov *AlertState_FieldTerminalPathArrayOfValues) AsAiAgentDiagnosisNotesArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *AlertState_FieldTerminalPathArrayOfValues) AsAiRemediationArgArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *AlertState_FieldTerminalPathArrayOfValues) AsAiRemediationArrayOfValues() ([]*rcommon.PolicySpec_AIAgentHandling_Remediation, bool) {
	res, ok := fpaov.values.([]*rcommon.PolicySpec_AIAgentHandling_Remediation)
	return res, ok
}
func (fpaov *AlertState_FieldTerminalPathArrayOfValues) AsOperatorHandlingStateArrayOfValues() ([]Alert_State_OperatorHandlingState, bool) {
	res, ok := fpaov.values.([]Alert_State_OperatorHandlingState)
	return res, ok
}
func (fpaov *AlertState_FieldTerminalPathArrayOfValues) AsOperatorLastStateChangeTimeArrayOfValues() ([]*timestamppb.Timestamp, bool) {
	res, ok := fpaov.values.([]*timestamppb.Timestamp)
	return res, ok
}
func (fpaov *AlertState_FieldTerminalPathArrayOfValues) AsOperatorNotesArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	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) AsNotificationStatusesPathArrayOfValues() (AlertStateNotification_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(AlertStateNotification_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *AlertState_FieldSubPathArrayOfValues) AsAiRemediationPathArrayOfValues() (rcommon.PolicySpecAIAgentHandlingRemediation_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(rcommon.PolicySpecAIAgentHandlingRemediation_FieldPathArrayOfValues)
	return res, ok
}

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

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

type AlertInternal_FieldPathSelector int32

const (
	AlertInternal_FieldPathSelectorAlertingLocation AlertInternal_FieldPathSelector = 0
)

func (s AlertInternal_FieldPathSelector) String() string {
	switch s {
	case AlertInternal_FieldPathSelectorAlertingLocation:
		return "alerting_location"
	default:
		panic(fmt.Sprintf("Invalid selector for Alert_Internal: %d", s))
	}
}

func BuildAlertInternal_FieldPath(fp gotenobject.RawFieldPath) (AlertInternal_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object Alert_Internal")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "alerting_location", "alertingLocation", "alerting-location":
			return &AlertInternal_FieldTerminalPath{selector: AlertInternal_FieldPathSelectorAlertingLocation}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object Alert_Internal", fp)
}

func ParseAlertInternal_FieldPath(rawField string) (AlertInternal_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildAlertInternal_FieldPath(fp)
}

func MustParseAlertInternal_FieldPath(rawField string) AlertInternal_FieldPath {
	fp, err := ParseAlertInternal_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type AlertInternal_FieldTerminalPath struct {
	selector AlertInternal_FieldPathSelector
}

var _ AlertInternal_FieldPath = (*AlertInternal_FieldTerminalPath)(nil)

func (fp *AlertInternal_FieldTerminalPath) Selector() AlertInternal_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

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

func (fp *AlertInternal_FieldTerminalPath) ClearValue(item *Alert_Internal) {
	if item != nil {
		switch fp.selector {
		case AlertInternal_FieldPathSelectorAlertingLocation:
			item.AlertingLocation = rcommon.PolicySpec_UNDEFINED
		default:
			panic(fmt.Sprintf("Invalid selector for Alert_Internal: %d", fp.selector))
		}
	}
}

func (fp *AlertInternal_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*Alert_Internal))
}

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

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

func (fp *AlertInternal_FieldTerminalPath) WithIValue(value interface{}) AlertInternal_FieldPathValue {
	switch fp.selector {
	case AlertInternal_FieldPathSelectorAlertingLocation:
		return &AlertInternal_FieldTerminalPathValue{AlertInternal_FieldTerminalPath: *fp, value: value.(rcommon.PolicySpec_ProcessingLocation)}
	default:
		panic(fmt.Sprintf("Invalid selector for Alert_Internal: %d", fp.selector))
	}
}

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

func (fp *AlertInternal_FieldTerminalPath) WithIArrayOfValues(values interface{}) AlertInternal_FieldPathArrayOfValues {
	fpaov := &AlertInternal_FieldTerminalPathArrayOfValues{AlertInternal_FieldTerminalPath: *fp}
	switch fp.selector {
	case AlertInternal_FieldPathSelectorAlertingLocation:
		return &AlertInternal_FieldTerminalPathArrayOfValues{AlertInternal_FieldTerminalPath: *fp, values: values.([]rcommon.PolicySpec_ProcessingLocation)}
	default:
		panic(fmt.Sprintf("Invalid selector for Alert_Internal: %d", fp.selector))
	}
	return fpaov
}

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

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

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

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

func ParseAlertInternal_FieldPathValue(pathStr, valueStr string) (AlertInternal_FieldPathValue, error) {
	fp, err := ParseAlertInternal_FieldPath(pathStr)
	if err != nil {
		return nil, err
	}
	fpv, err := gotenobject.ParseFieldPathValue(fp, valueStr)
	if err != nil {
		return nil, status.Errorf(codes.InvalidArgument, "error parsing Internal field path value from %s: %v", valueStr, err)
	}
	return fpv.(AlertInternal_FieldPathValue), nil
}

func MustParseAlertInternal_FieldPathValue(pathStr, valueStr string) AlertInternal_FieldPathValue {
	fpv, err := ParseAlertInternal_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type AlertInternal_FieldTerminalPathValue struct {
	AlertInternal_FieldTerminalPath
	value interface{}
}

var _ AlertInternal_FieldPathValue = (*AlertInternal_FieldTerminalPathValue)(nil)

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

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

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

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

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

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

// ParseAlertInternal_FieldPathArrayItemValue parses string and JSON-encoded value to its Value
func ParseAlertInternal_FieldPathArrayItemValue(pathStr, valueStr string) (AlertInternal_FieldPathArrayItemValue, error) {
	fp, err := ParseAlertInternal_FieldPath(pathStr)
	if err != nil {
		return nil, err
	}
	fpaiv, err := gotenobject.ParseFieldPathArrayItemValue(fp, valueStr)
	if err != nil {
		return nil, status.Errorf(codes.InvalidArgument, "error parsing Internal field path array item value from %s: %v", valueStr, err)
	}
	return fpaiv.(AlertInternal_FieldPathArrayItemValue), nil
}

func MustParseAlertInternal_FieldPathArrayItemValue(pathStr, valueStr string) AlertInternal_FieldPathArrayItemValue {
	fpaiv, err := ParseAlertInternal_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type AlertInternal_FieldTerminalPathArrayItemValue struct {
	AlertInternal_FieldTerminalPath
	value interface{}
}

var _ AlertInternal_FieldPathArrayItemValue = (*AlertInternal_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *AlertInternal_FieldTerminalPathArrayItemValue) GetSingle(source *Alert_Internal) (interface{}, bool) {
	return nil, false
}

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

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

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

func ParseAlertInternal_FieldPathArrayOfValues(pathStr, valuesStr string) (AlertInternal_FieldPathArrayOfValues, error) {
	fp, err := ParseAlertInternal_FieldPath(pathStr)
	if err != nil {
		return nil, err
	}
	fpaov, err := gotenobject.ParseFieldPathArrayOfValues(fp, valuesStr)
	if err != nil {
		return nil, status.Errorf(codes.InvalidArgument, "error parsing Internal field path array of values from %s: %v", valuesStr, err)
	}
	return fpaov.(AlertInternal_FieldPathArrayOfValues), nil
}

func MustParseAlertInternal_FieldPathArrayOfValues(pathStr, valuesStr string) AlertInternal_FieldPathArrayOfValues {
	fpaov, err := ParseAlertInternal_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type AlertInternal_FieldTerminalPathArrayOfValues struct {
	AlertInternal_FieldTerminalPath
	values interface{}
}

var _ AlertInternal_FieldPathArrayOfValues = (*AlertInternal_FieldTerminalPathArrayOfValues)(nil)

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

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

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

type AlertTsInfoTimeSeries_FieldPathSelector int32

const (
	AlertTsInfoTimeSeries_FieldPathSelectorQueryName        AlertTsInfoTimeSeries_FieldPathSelector = 0
	AlertTsInfoTimeSeries_FieldPathSelectorValues           AlertTsInfoTimeSeries_FieldPathSelector = 1
	AlertTsInfoTimeSeries_FieldPathSelectorAnomalies        AlertTsInfoTimeSeries_FieldPathSelector = 2
	AlertTsInfoTimeSeries_FieldPathSelectorUpperThreshold   AlertTsInfoTimeSeries_FieldPathSelector = 3
	AlertTsInfoTimeSeries_FieldPathSelectorLowerThreshold   AlertTsInfoTimeSeries_FieldPathSelector = 4
	AlertTsInfoTimeSeries_FieldPathSelectorAnomalyThreshold AlertTsInfoTimeSeries_FieldPathSelector = 5
	AlertTsInfoTimeSeries_FieldPathSelectorAfterDuration    AlertTsInfoTimeSeries_FieldPathSelector = 6
)

func (s AlertTsInfoTimeSeries_FieldPathSelector) String() string {
	switch s {
	case AlertTsInfoTimeSeries_FieldPathSelectorQueryName:
		return "query_name"
	case AlertTsInfoTimeSeries_FieldPathSelectorValues:
		return "values"
	case AlertTsInfoTimeSeries_FieldPathSelectorAnomalies:
		return "anomalies"
	case AlertTsInfoTimeSeries_FieldPathSelectorUpperThreshold:
		return "upper_threshold"
	case AlertTsInfoTimeSeries_FieldPathSelectorLowerThreshold:
		return "lower_threshold"
	case AlertTsInfoTimeSeries_FieldPathSelectorAnomalyThreshold:
		return "anomaly_threshold"
	case AlertTsInfoTimeSeries_FieldPathSelectorAfterDuration:
		return "after_duration"
	default:
		panic(fmt.Sprintf("Invalid selector for Alert_TsInfo_TimeSeries: %d", s))
	}
}

func BuildAlertTsInfoTimeSeries_FieldPath(fp gotenobject.RawFieldPath) (AlertTsInfoTimeSeries_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object Alert_TsInfo_TimeSeries")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "query_name", "queryName", "query-name":
			return &AlertTsInfoTimeSeries_FieldTerminalPath{selector: AlertTsInfoTimeSeries_FieldPathSelectorQueryName}, nil
		case "values":
			return &AlertTsInfoTimeSeries_FieldTerminalPath{selector: AlertTsInfoTimeSeries_FieldPathSelectorValues}, nil
		case "anomalies":
			return &AlertTsInfoTimeSeries_FieldTerminalPath{selector: AlertTsInfoTimeSeries_FieldPathSelectorAnomalies}, nil
		case "upper_threshold", "upperThreshold", "upper-threshold":
			return &AlertTsInfoTimeSeries_FieldTerminalPath{selector: AlertTsInfoTimeSeries_FieldPathSelectorUpperThreshold}, nil
		case "lower_threshold", "lowerThreshold", "lower-threshold":
			return &AlertTsInfoTimeSeries_FieldTerminalPath{selector: AlertTsInfoTimeSeries_FieldPathSelectorLowerThreshold}, nil
		case "anomaly_threshold", "anomalyThreshold", "anomaly-threshold":
			return &AlertTsInfoTimeSeries_FieldTerminalPath{selector: AlertTsInfoTimeSeries_FieldPathSelectorAnomalyThreshold}, nil
		case "after_duration", "afterDuration", "after-duration":
			return &AlertTsInfoTimeSeries_FieldTerminalPath{selector: AlertTsInfoTimeSeries_FieldPathSelectorAfterDuration}, nil
		}
	} else {
		switch fp[0] {
		case "upper_threshold", "upperThreshold", "upper-threshold":
			if subpath, err := rcommon.BuildAlertingThreshold_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &AlertTsInfoTimeSeries_FieldSubPath{selector: AlertTsInfoTimeSeries_FieldPathSelectorUpperThreshold, subPath: subpath}, nil
			}
		case "lower_threshold", "lowerThreshold", "lower-threshold":
			if subpath, err := rcommon.BuildAlertingThreshold_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &AlertTsInfoTimeSeries_FieldSubPath{selector: AlertTsInfoTimeSeries_FieldPathSelectorLowerThreshold, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object Alert_TsInfo_TimeSeries", fp)
}

func ParseAlertTsInfoTimeSeries_FieldPath(rawField string) (AlertTsInfoTimeSeries_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildAlertTsInfoTimeSeries_FieldPath(fp)
}

func MustParseAlertTsInfoTimeSeries_FieldPath(rawField string) AlertTsInfoTimeSeries_FieldPath {
	fp, err := ParseAlertTsInfoTimeSeries_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type AlertTsInfoTimeSeries_FieldTerminalPath struct {
	selector AlertTsInfoTimeSeries_FieldPathSelector
}

var _ AlertTsInfoTimeSeries_FieldPath = (*AlertTsInfoTimeSeries_FieldTerminalPath)(nil)

func (fp *AlertTsInfoTimeSeries_FieldTerminalPath) Selector() AlertTsInfoTimeSeries_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source Alert_TsInfo_TimeSeries
func (fp *AlertTsInfoTimeSeries_FieldTerminalPath) Get(source *Alert_TsInfo_TimeSeries) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case AlertTsInfoTimeSeries_FieldPathSelectorQueryName:
			values = append(values, source.QueryName)
		case AlertTsInfoTimeSeries_FieldPathSelectorValues:
			for _, value := range source.GetValues() {
				values = append(values, value)
			}
		case AlertTsInfoTimeSeries_FieldPathSelectorAnomalies:
			for _, value := range source.GetAnomalies() {
				values = append(values, value)
			}
		case AlertTsInfoTimeSeries_FieldPathSelectorUpperThreshold:
			if source.UpperThreshold != nil {
				values = append(values, source.UpperThreshold)
			}
		case AlertTsInfoTimeSeries_FieldPathSelectorLowerThreshold:
			if source.LowerThreshold != nil {
				values = append(values, source.LowerThreshold)
			}
		case AlertTsInfoTimeSeries_FieldPathSelectorAnomalyThreshold:
			values = append(values, source.AnomalyThreshold)
		case AlertTsInfoTimeSeries_FieldPathSelectorAfterDuration:
			if source.AfterDuration != nil {
				values = append(values, source.AfterDuration)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for Alert_TsInfo_TimeSeries: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source Alert_TsInfo_TimeSeries
func (fp *AlertTsInfoTimeSeries_FieldTerminalPath) GetSingle(source *Alert_TsInfo_TimeSeries) (interface{}, bool) {
	switch fp.selector {
	case AlertTsInfoTimeSeries_FieldPathSelectorQueryName:
		return source.GetQueryName(), source != nil
	case AlertTsInfoTimeSeries_FieldPathSelectorValues:
		res := source.GetValues()
		return res, res != nil
	case AlertTsInfoTimeSeries_FieldPathSelectorAnomalies:
		res := source.GetAnomalies()
		return res, res != nil
	case AlertTsInfoTimeSeries_FieldPathSelectorUpperThreshold:
		res := source.GetUpperThreshold()
		return res, res != nil
	case AlertTsInfoTimeSeries_FieldPathSelectorLowerThreshold:
		res := source.GetLowerThreshold()
		return res, res != nil
	case AlertTsInfoTimeSeries_FieldPathSelectorAnomalyThreshold:
		return source.GetAnomalyThreshold(), source != nil
	case AlertTsInfoTimeSeries_FieldPathSelectorAfterDuration:
		res := source.GetAfterDuration()
		return res, res != nil
	default:
		panic(fmt.Sprintf("Invalid selector for Alert_TsInfo_TimeSeries: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *AlertTsInfoTimeSeries_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case AlertTsInfoTimeSeries_FieldPathSelectorQueryName:
		return ""
	case AlertTsInfoTimeSeries_FieldPathSelectorValues:
		return ([]float64)(nil)
	case AlertTsInfoTimeSeries_FieldPathSelectorAnomalies:
		return ([]float64)(nil)
	case AlertTsInfoTimeSeries_FieldPathSelectorUpperThreshold:
		return (*rcommon.AlertingThreshold)(nil)
	case AlertTsInfoTimeSeries_FieldPathSelectorLowerThreshold:
		return (*rcommon.AlertingThreshold)(nil)
	case AlertTsInfoTimeSeries_FieldPathSelectorAnomalyThreshold:
		return float64(0)
	case AlertTsInfoTimeSeries_FieldPathSelectorAfterDuration:
		return (*durationpb.Duration)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for Alert_TsInfo_TimeSeries: %d", fp.selector))
	}
}

func (fp *AlertTsInfoTimeSeries_FieldTerminalPath) ClearValue(item *Alert_TsInfo_TimeSeries) {
	if item != nil {
		switch fp.selector {
		case AlertTsInfoTimeSeries_FieldPathSelectorQueryName:
			item.QueryName = ""
		case AlertTsInfoTimeSeries_FieldPathSelectorValues:
			item.Values = nil
		case AlertTsInfoTimeSeries_FieldPathSelectorAnomalies:
			item.Anomalies = nil
		case AlertTsInfoTimeSeries_FieldPathSelectorUpperThreshold:
			item.UpperThreshold = nil
		case AlertTsInfoTimeSeries_FieldPathSelectorLowerThreshold:
			item.LowerThreshold = nil
		case AlertTsInfoTimeSeries_FieldPathSelectorAnomalyThreshold:
			item.AnomalyThreshold = float64(0)
		case AlertTsInfoTimeSeries_FieldPathSelectorAfterDuration:
			item.AfterDuration = nil
		default:
			panic(fmt.Sprintf("Invalid selector for Alert_TsInfo_TimeSeries: %d", fp.selector))
		}
	}
}

func (fp *AlertTsInfoTimeSeries_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*Alert_TsInfo_TimeSeries))
}

// IsLeaf - whether field path is holds simple value
func (fp *AlertTsInfoTimeSeries_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == AlertTsInfoTimeSeries_FieldPathSelectorQueryName ||
		fp.selector == AlertTsInfoTimeSeries_FieldPathSelectorValues ||
		fp.selector == AlertTsInfoTimeSeries_FieldPathSelectorAnomalies ||
		fp.selector == AlertTsInfoTimeSeries_FieldPathSelectorAnomalyThreshold ||
		fp.selector == AlertTsInfoTimeSeries_FieldPathSelectorAfterDuration
}

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

func (fp *AlertTsInfoTimeSeries_FieldTerminalPath) WithIValue(value interface{}) AlertTsInfoTimeSeries_FieldPathValue {
	switch fp.selector {
	case AlertTsInfoTimeSeries_FieldPathSelectorQueryName:
		return &AlertTsInfoTimeSeries_FieldTerminalPathValue{AlertTsInfoTimeSeries_FieldTerminalPath: *fp, value: value.(string)}
	case AlertTsInfoTimeSeries_FieldPathSelectorValues:
		return &AlertTsInfoTimeSeries_FieldTerminalPathValue{AlertTsInfoTimeSeries_FieldTerminalPath: *fp, value: value.([]float64)}
	case AlertTsInfoTimeSeries_FieldPathSelectorAnomalies:
		return &AlertTsInfoTimeSeries_FieldTerminalPathValue{AlertTsInfoTimeSeries_FieldTerminalPath: *fp, value: value.([]float64)}
	case AlertTsInfoTimeSeries_FieldPathSelectorUpperThreshold:
		return &AlertTsInfoTimeSeries_FieldTerminalPathValue{AlertTsInfoTimeSeries_FieldTerminalPath: *fp, value: value.(*rcommon.AlertingThreshold)}
	case AlertTsInfoTimeSeries_FieldPathSelectorLowerThreshold:
		return &AlertTsInfoTimeSeries_FieldTerminalPathValue{AlertTsInfoTimeSeries_FieldTerminalPath: *fp, value: value.(*rcommon.AlertingThreshold)}
	case AlertTsInfoTimeSeries_FieldPathSelectorAnomalyThreshold:
		return &AlertTsInfoTimeSeries_FieldTerminalPathValue{AlertTsInfoTimeSeries_FieldTerminalPath: *fp, value: value.(float64)}
	case AlertTsInfoTimeSeries_FieldPathSelectorAfterDuration:
		return &AlertTsInfoTimeSeries_FieldTerminalPathValue{AlertTsInfoTimeSeries_FieldTerminalPath: *fp, value: value.(*durationpb.Duration)}
	default:
		panic(fmt.Sprintf("Invalid selector for Alert_TsInfo_TimeSeries: %d", fp.selector))
	}
}

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

func (fp *AlertTsInfoTimeSeries_FieldTerminalPath) WithIArrayOfValues(values interface{}) AlertTsInfoTimeSeries_FieldPathArrayOfValues {
	fpaov := &AlertTsInfoTimeSeries_FieldTerminalPathArrayOfValues{AlertTsInfoTimeSeries_FieldTerminalPath: *fp}
	switch fp.selector {
	case AlertTsInfoTimeSeries_FieldPathSelectorQueryName:
		return &AlertTsInfoTimeSeries_FieldTerminalPathArrayOfValues{AlertTsInfoTimeSeries_FieldTerminalPath: *fp, values: values.([]string)}
	case AlertTsInfoTimeSeries_FieldPathSelectorValues:
		return &AlertTsInfoTimeSeries_FieldTerminalPathArrayOfValues{AlertTsInfoTimeSeries_FieldTerminalPath: *fp, values: values.([][]float64)}
	case AlertTsInfoTimeSeries_FieldPathSelectorAnomalies:
		return &AlertTsInfoTimeSeries_FieldTerminalPathArrayOfValues{AlertTsInfoTimeSeries_FieldTerminalPath: *fp, values: values.([][]float64)}
	case AlertTsInfoTimeSeries_FieldPathSelectorUpperThreshold:
		return &AlertTsInfoTimeSeries_FieldTerminalPathArrayOfValues{AlertTsInfoTimeSeries_FieldTerminalPath: *fp, values: values.([]*rcommon.AlertingThreshold)}
	case AlertTsInfoTimeSeries_FieldPathSelectorLowerThreshold:
		return &AlertTsInfoTimeSeries_FieldTerminalPathArrayOfValues{AlertTsInfoTimeSeries_FieldTerminalPath: *fp, values: values.([]*rcommon.AlertingThreshold)}
	case AlertTsInfoTimeSeries_FieldPathSelectorAnomalyThreshold:
		return &AlertTsInfoTimeSeries_FieldTerminalPathArrayOfValues{AlertTsInfoTimeSeries_FieldTerminalPath: *fp, values: values.([]float64)}
	case AlertTsInfoTimeSeries_FieldPathSelectorAfterDuration:
		return &AlertTsInfoTimeSeries_FieldTerminalPathArrayOfValues{AlertTsInfoTimeSeries_FieldTerminalPath: *fp, values: values.([]*durationpb.Duration)}
	default:
		panic(fmt.Sprintf("Invalid selector for Alert_TsInfo_TimeSeries: %d", fp.selector))
	}
	return fpaov
}

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

func (fp *AlertTsInfoTimeSeries_FieldTerminalPath) WithIArrayItemValue(value interface{}) AlertTsInfoTimeSeries_FieldPathArrayItemValue {
	switch fp.selector {
	case AlertTsInfoTimeSeries_FieldPathSelectorValues:
		return &AlertTsInfoTimeSeries_FieldTerminalPathArrayItemValue{AlertTsInfoTimeSeries_FieldTerminalPath: *fp, value: value.(float64)}
	case AlertTsInfoTimeSeries_FieldPathSelectorAnomalies:
		return &AlertTsInfoTimeSeries_FieldTerminalPathArrayItemValue{AlertTsInfoTimeSeries_FieldTerminalPath: *fp, value: value.(float64)}
	default:
		panic(fmt.Sprintf("Invalid selector for Alert_TsInfo_TimeSeries: %d", fp.selector))
	}
}

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

type AlertTsInfoTimeSeries_FieldSubPath struct {
	selector AlertTsInfoTimeSeries_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ AlertTsInfoTimeSeries_FieldPath = (*AlertTsInfoTimeSeries_FieldSubPath)(nil)

func (fps *AlertTsInfoTimeSeries_FieldSubPath) Selector() AlertTsInfoTimeSeries_FieldPathSelector {
	return fps.selector
}
func (fps *AlertTsInfoTimeSeries_FieldSubPath) AsUpperThresholdSubPath() (rcommon.AlertingThreshold_FieldPath, bool) {
	res, ok := fps.subPath.(rcommon.AlertingThreshold_FieldPath)
	return res, ok
}
func (fps *AlertTsInfoTimeSeries_FieldSubPath) AsLowerThresholdSubPath() (rcommon.AlertingThreshold_FieldPath, bool) {
	res, ok := fps.subPath.(rcommon.AlertingThreshold_FieldPath)
	return res, ok
}

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

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

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

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

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

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

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

func (fps *AlertTsInfoTimeSeries_FieldSubPath) ClearValue(item *Alert_TsInfo_TimeSeries) {
	if item != nil {
		switch fps.selector {
		case AlertTsInfoTimeSeries_FieldPathSelectorUpperThreshold:
			fps.subPath.ClearValueRaw(item.UpperThreshold)
		case AlertTsInfoTimeSeries_FieldPathSelectorLowerThreshold:
			fps.subPath.ClearValueRaw(item.LowerThreshold)
		default:
			panic(fmt.Sprintf("Invalid selector for Alert_TsInfo_TimeSeries: %d", fps.selector))
		}
	}
}

func (fps *AlertTsInfoTimeSeries_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*Alert_TsInfo_TimeSeries))
}

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

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

func (fps *AlertTsInfoTimeSeries_FieldSubPath) WithIValue(value interface{}) AlertTsInfoTimeSeries_FieldPathValue {
	return &AlertTsInfoTimeSeries_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *AlertTsInfoTimeSeries_FieldSubPath) WithIArrayOfValues(values interface{}) AlertTsInfoTimeSeries_FieldPathArrayOfValues {
	return &AlertTsInfoTimeSeries_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *AlertTsInfoTimeSeries_FieldSubPath) WithIArrayItemValue(value interface{}) AlertTsInfoTimeSeries_FieldPathArrayItemValue {
	return &AlertTsInfoTimeSeries_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

// AlertTsInfoTimeSeries_FieldPathValue allows storing values for TimeSeries fields according to their type
type AlertTsInfoTimeSeries_FieldPathValue interface {
	AlertTsInfoTimeSeries_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **Alert_TsInfo_TimeSeries)
	CompareWith(*Alert_TsInfo_TimeSeries) (cmp int, comparable bool)
}

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

func MustParseAlertTsInfoTimeSeries_FieldPathValue(pathStr, valueStr string) AlertTsInfoTimeSeries_FieldPathValue {
	fpv, err := ParseAlertTsInfoTimeSeries_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type AlertTsInfoTimeSeries_FieldTerminalPathValue struct {
	AlertTsInfoTimeSeries_FieldTerminalPath
	value interface{}
}

var _ AlertTsInfoTimeSeries_FieldPathValue = (*AlertTsInfoTimeSeries_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'TimeSeries' as interface{}
func (fpv *AlertTsInfoTimeSeries_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *AlertTsInfoTimeSeries_FieldTerminalPathValue) AsQueryNameValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *AlertTsInfoTimeSeries_FieldTerminalPathValue) AsValuesValue() ([]float64, bool) {
	res, ok := fpv.value.([]float64)
	return res, ok
}
func (fpv *AlertTsInfoTimeSeries_FieldTerminalPathValue) AsAnomaliesValue() ([]float64, bool) {
	res, ok := fpv.value.([]float64)
	return res, ok
}
func (fpv *AlertTsInfoTimeSeries_FieldTerminalPathValue) AsUpperThresholdValue() (*rcommon.AlertingThreshold, bool) {
	res, ok := fpv.value.(*rcommon.AlertingThreshold)
	return res, ok
}
func (fpv *AlertTsInfoTimeSeries_FieldTerminalPathValue) AsLowerThresholdValue() (*rcommon.AlertingThreshold, bool) {
	res, ok := fpv.value.(*rcommon.AlertingThreshold)
	return res, ok
}
func (fpv *AlertTsInfoTimeSeries_FieldTerminalPathValue) AsAnomalyThresholdValue() (float64, bool) {
	res, ok := fpv.value.(float64)
	return res, ok
}
func (fpv *AlertTsInfoTimeSeries_FieldTerminalPathValue) AsAfterDurationValue() (*durationpb.Duration, bool) {
	res, ok := fpv.value.(*durationpb.Duration)
	return res, ok
}

// SetTo stores value for selected field for object TimeSeries
func (fpv *AlertTsInfoTimeSeries_FieldTerminalPathValue) SetTo(target **Alert_TsInfo_TimeSeries) {
	if *target == nil {
		*target = new(Alert_TsInfo_TimeSeries)
	}
	switch fpv.selector {
	case AlertTsInfoTimeSeries_FieldPathSelectorQueryName:
		(*target).QueryName = fpv.value.(string)
	case AlertTsInfoTimeSeries_FieldPathSelectorValues:
		(*target).Values = fpv.value.([]float64)
	case AlertTsInfoTimeSeries_FieldPathSelectorAnomalies:
		(*target).Anomalies = fpv.value.([]float64)
	case AlertTsInfoTimeSeries_FieldPathSelectorUpperThreshold:
		(*target).UpperThreshold = fpv.value.(*rcommon.AlertingThreshold)
	case AlertTsInfoTimeSeries_FieldPathSelectorLowerThreshold:
		(*target).LowerThreshold = fpv.value.(*rcommon.AlertingThreshold)
	case AlertTsInfoTimeSeries_FieldPathSelectorAnomalyThreshold:
		(*target).AnomalyThreshold = fpv.value.(float64)
	case AlertTsInfoTimeSeries_FieldPathSelectorAfterDuration:
		(*target).AfterDuration = fpv.value.(*durationpb.Duration)
	default:
		panic(fmt.Sprintf("Invalid selector for Alert_TsInfo_TimeSeries: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'AlertTsInfoTimeSeries_FieldTerminalPathValue' with the value under path in 'Alert_TsInfo_TimeSeries'.
func (fpv *AlertTsInfoTimeSeries_FieldTerminalPathValue) CompareWith(source *Alert_TsInfo_TimeSeries) (int, bool) {
	switch fpv.selector {
	case AlertTsInfoTimeSeries_FieldPathSelectorQueryName:
		leftValue := fpv.value.(string)
		rightValue := source.GetQueryName()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case AlertTsInfoTimeSeries_FieldPathSelectorValues:
		return 0, false
	case AlertTsInfoTimeSeries_FieldPathSelectorAnomalies:
		return 0, false
	case AlertTsInfoTimeSeries_FieldPathSelectorUpperThreshold:
		return 0, false
	case AlertTsInfoTimeSeries_FieldPathSelectorLowerThreshold:
		return 0, false
	case AlertTsInfoTimeSeries_FieldPathSelectorAnomalyThreshold:
		leftValue := fpv.value.(float64)
		rightValue := source.GetAnomalyThreshold()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case AlertTsInfoTimeSeries_FieldPathSelectorAfterDuration:
		leftValue := fpv.value.(*durationpb.Duration)
		rightValue := source.GetAfterDuration()
		if leftValue == nil {
			if rightValue != nil {
				return -1, true
			}
			return 0, true
		}
		if rightValue == nil {
			return 1, true
		}
		if leftValue.AsDuration() == rightValue.AsDuration() {
			return 0, true
		} else if leftValue.AsDuration() < rightValue.AsDuration() {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for Alert_TsInfo_TimeSeries: %d", fpv.selector))
	}
}

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

type AlertTsInfoTimeSeries_FieldSubPathValue struct {
	AlertTsInfoTimeSeries_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ AlertTsInfoTimeSeries_FieldPathValue = (*AlertTsInfoTimeSeries_FieldSubPathValue)(nil)

func (fpvs *AlertTsInfoTimeSeries_FieldSubPathValue) AsUpperThresholdPathValue() (rcommon.AlertingThreshold_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(rcommon.AlertingThreshold_FieldPathValue)
	return res, ok
}
func (fpvs *AlertTsInfoTimeSeries_FieldSubPathValue) AsLowerThresholdPathValue() (rcommon.AlertingThreshold_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(rcommon.AlertingThreshold_FieldPathValue)
	return res, ok
}

func (fpvs *AlertTsInfoTimeSeries_FieldSubPathValue) SetTo(target **Alert_TsInfo_TimeSeries) {
	if *target == nil {
		*target = new(Alert_TsInfo_TimeSeries)
	}
	switch fpvs.Selector() {
	case AlertTsInfoTimeSeries_FieldPathSelectorUpperThreshold:
		fpvs.subPathValue.(rcommon.AlertingThreshold_FieldPathValue).SetTo(&(*target).UpperThreshold)
	case AlertTsInfoTimeSeries_FieldPathSelectorLowerThreshold:
		fpvs.subPathValue.(rcommon.AlertingThreshold_FieldPathValue).SetTo(&(*target).LowerThreshold)
	default:
		panic(fmt.Sprintf("Invalid selector for Alert_TsInfo_TimeSeries: %d", fpvs.Selector()))
	}
}

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

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

func (fpvs *AlertTsInfoTimeSeries_FieldSubPathValue) CompareWith(source *Alert_TsInfo_TimeSeries) (int, bool) {
	switch fpvs.Selector() {
	case AlertTsInfoTimeSeries_FieldPathSelectorUpperThreshold:
		return fpvs.subPathValue.(rcommon.AlertingThreshold_FieldPathValue).CompareWith(source.GetUpperThreshold())
	case AlertTsInfoTimeSeries_FieldPathSelectorLowerThreshold:
		return fpvs.subPathValue.(rcommon.AlertingThreshold_FieldPathValue).CompareWith(source.GetLowerThreshold())
	default:
		panic(fmt.Sprintf("Invalid selector for Alert_TsInfo_TimeSeries: %d", fpvs.Selector()))
	}
}

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

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

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

func MustParseAlertTsInfoTimeSeries_FieldPathArrayItemValue(pathStr, valueStr string) AlertTsInfoTimeSeries_FieldPathArrayItemValue {
	fpaiv, err := ParseAlertTsInfoTimeSeries_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type AlertTsInfoTimeSeries_FieldTerminalPathArrayItemValue struct {
	AlertTsInfoTimeSeries_FieldTerminalPath
	value interface{}
}

var _ AlertTsInfoTimeSeries_FieldPathArrayItemValue = (*AlertTsInfoTimeSeries_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object Alert_TsInfo_TimeSeries as interface{}
func (fpaiv *AlertTsInfoTimeSeries_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}
func (fpaiv *AlertTsInfoTimeSeries_FieldTerminalPathArrayItemValue) AsValuesItemValue() (float64, bool) {
	res, ok := fpaiv.value.(float64)
	return res, ok
}
func (fpaiv *AlertTsInfoTimeSeries_FieldTerminalPathArrayItemValue) AsAnomaliesItemValue() (float64, bool) {
	res, ok := fpaiv.value.(float64)
	return res, ok
}

func (fpaiv *AlertTsInfoTimeSeries_FieldTerminalPathArrayItemValue) GetSingle(source *Alert_TsInfo_TimeSeries) (interface{}, bool) {
	return nil, false
}

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

// Contains returns a boolean indicating if value that is being held is present in given 'TimeSeries'
func (fpaiv *AlertTsInfoTimeSeries_FieldTerminalPathArrayItemValue) ContainsValue(source *Alert_TsInfo_TimeSeries) bool {
	slice := fpaiv.AlertTsInfoTimeSeries_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 AlertTsInfoTimeSeries_FieldSubPathArrayItemValue struct {
	AlertTsInfoTimeSeries_FieldPath
	subPathItemValue gotenobject.FieldPathArrayItemValue
}

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

// Contains returns a boolean indicating if value that is being held is present in given 'TimeSeries'
func (fpaivs *AlertTsInfoTimeSeries_FieldSubPathArrayItemValue) ContainsValue(source *Alert_TsInfo_TimeSeries) bool {
	switch fpaivs.Selector() {
	case AlertTsInfoTimeSeries_FieldPathSelectorUpperThreshold:
		return fpaivs.subPathItemValue.(rcommon.AlertingThreshold_FieldPathArrayItemValue).ContainsValue(source.GetUpperThreshold())
	case AlertTsInfoTimeSeries_FieldPathSelectorLowerThreshold:
		return fpaivs.subPathItemValue.(rcommon.AlertingThreshold_FieldPathArrayItemValue).ContainsValue(source.GetLowerThreshold())
	default:
		panic(fmt.Sprintf("Invalid selector for Alert_TsInfo_TimeSeries: %d", fpaivs.Selector()))
	}
}

// AlertTsInfoTimeSeries_FieldPathArrayOfValues allows storing slice of values for TimeSeries fields according to their type
type AlertTsInfoTimeSeries_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	AlertTsInfoTimeSeries_FieldPath
}

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

func MustParseAlertTsInfoTimeSeries_FieldPathArrayOfValues(pathStr, valuesStr string) AlertTsInfoTimeSeries_FieldPathArrayOfValues {
	fpaov, err := ParseAlertTsInfoTimeSeries_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type AlertTsInfoTimeSeries_FieldTerminalPathArrayOfValues struct {
	AlertTsInfoTimeSeries_FieldTerminalPath
	values interface{}
}

var _ AlertTsInfoTimeSeries_FieldPathArrayOfValues = (*AlertTsInfoTimeSeries_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *AlertTsInfoTimeSeries_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case AlertTsInfoTimeSeries_FieldPathSelectorQueryName:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case AlertTsInfoTimeSeries_FieldPathSelectorValues:
		for _, v := range fpaov.values.([][]float64) {
			values = append(values, v)
		}
	case AlertTsInfoTimeSeries_FieldPathSelectorAnomalies:
		for _, v := range fpaov.values.([][]float64) {
			values = append(values, v)
		}
	case AlertTsInfoTimeSeries_FieldPathSelectorUpperThreshold:
		for _, v := range fpaov.values.([]*rcommon.AlertingThreshold) {
			values = append(values, v)
		}
	case AlertTsInfoTimeSeries_FieldPathSelectorLowerThreshold:
		for _, v := range fpaov.values.([]*rcommon.AlertingThreshold) {
			values = append(values, v)
		}
	case AlertTsInfoTimeSeries_FieldPathSelectorAnomalyThreshold:
		for _, v := range fpaov.values.([]float64) {
			values = append(values, v)
		}
	case AlertTsInfoTimeSeries_FieldPathSelectorAfterDuration:
		for _, v := range fpaov.values.([]*durationpb.Duration) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *AlertTsInfoTimeSeries_FieldTerminalPathArrayOfValues) AsQueryNameArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *AlertTsInfoTimeSeries_FieldTerminalPathArrayOfValues) AsValuesArrayOfValues() ([][]float64, bool) {
	res, ok := fpaov.values.([][]float64)
	return res, ok
}
func (fpaov *AlertTsInfoTimeSeries_FieldTerminalPathArrayOfValues) AsAnomaliesArrayOfValues() ([][]float64, bool) {
	res, ok := fpaov.values.([][]float64)
	return res, ok
}
func (fpaov *AlertTsInfoTimeSeries_FieldTerminalPathArrayOfValues) AsUpperThresholdArrayOfValues() ([]*rcommon.AlertingThreshold, bool) {
	res, ok := fpaov.values.([]*rcommon.AlertingThreshold)
	return res, ok
}
func (fpaov *AlertTsInfoTimeSeries_FieldTerminalPathArrayOfValues) AsLowerThresholdArrayOfValues() ([]*rcommon.AlertingThreshold, bool) {
	res, ok := fpaov.values.([]*rcommon.AlertingThreshold)
	return res, ok
}
func (fpaov *AlertTsInfoTimeSeries_FieldTerminalPathArrayOfValues) AsAnomalyThresholdArrayOfValues() ([]float64, bool) {
	res, ok := fpaov.values.([]float64)
	return res, ok
}
func (fpaov *AlertTsInfoTimeSeries_FieldTerminalPathArrayOfValues) AsAfterDurationArrayOfValues() ([]*durationpb.Duration, bool) {
	res, ok := fpaov.values.([]*durationpb.Duration)
	return res, ok
}

type AlertTsInfoTimeSeries_FieldSubPathArrayOfValues struct {
	AlertTsInfoTimeSeries_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ AlertTsInfoTimeSeries_FieldPathArrayOfValues = (*AlertTsInfoTimeSeries_FieldSubPathArrayOfValues)(nil)

func (fpsaov *AlertTsInfoTimeSeries_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *AlertTsInfoTimeSeries_FieldSubPathArrayOfValues) AsUpperThresholdPathArrayOfValues() (rcommon.AlertingThreshold_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(rcommon.AlertingThreshold_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *AlertTsInfoTimeSeries_FieldSubPathArrayOfValues) AsLowerThresholdPathArrayOfValues() (rcommon.AlertingThreshold_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(rcommon.AlertingThreshold_FieldPathArrayOfValues)
	return res, ok
}

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

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

type AlertStateNotification_FieldPathSelector int32

const (
	AlertStateNotification_FieldPathSelectorKind            AlertStateNotification_FieldPathSelector = 0
	AlertStateNotification_FieldPathSelectorPendingChannels AlertStateNotification_FieldPathSelector = 1
)

func (s AlertStateNotification_FieldPathSelector) String() string {
	switch s {
	case AlertStateNotification_FieldPathSelectorKind:
		return "kind"
	case AlertStateNotification_FieldPathSelectorPendingChannels:
		return "pending_channels"
	default:
		panic(fmt.Sprintf("Invalid selector for Alert_State_Notification: %d", s))
	}
}

func BuildAlertStateNotification_FieldPath(fp gotenobject.RawFieldPath) (AlertStateNotification_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object Alert_State_Notification")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "kind":
			return &AlertStateNotification_FieldTerminalPath{selector: AlertStateNotification_FieldPathSelectorKind}, nil
		case "pending_channels", "pendingChannels", "pending-channels":
			return &AlertStateNotification_FieldTerminalPath{selector: AlertStateNotification_FieldPathSelectorPendingChannels}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object Alert_State_Notification", fp)
}

func ParseAlertStateNotification_FieldPath(rawField string) (AlertStateNotification_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildAlertStateNotification_FieldPath(fp)
}

func MustParseAlertStateNotification_FieldPath(rawField string) AlertStateNotification_FieldPath {
	fp, err := ParseAlertStateNotification_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type AlertStateNotification_FieldTerminalPath struct {
	selector AlertStateNotification_FieldPathSelector
}

var _ AlertStateNotification_FieldPath = (*AlertStateNotification_FieldTerminalPath)(nil)

func (fp *AlertStateNotification_FieldTerminalPath) Selector() AlertStateNotification_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source Alert_State_Notification
func (fp *AlertStateNotification_FieldTerminalPath) Get(source *Alert_State_Notification) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case AlertStateNotification_FieldPathSelectorKind:
			values = append(values, source.Kind)
		case AlertStateNotification_FieldPathSelectorPendingChannels:
			for _, value := range source.GetPendingChannels() {
				values = append(values, value)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for Alert_State_Notification: %d", fp.selector))
		}
	}
	return
}

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

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

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

// GetDefault returns a default value of the field type
func (fp *AlertStateNotification_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case AlertStateNotification_FieldPathSelectorKind:
		return rcommon.NotificationChannelSpec_UNDEFINED
	case AlertStateNotification_FieldPathSelectorPendingChannels:
		return ([]*notification_channel.Reference)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for Alert_State_Notification: %d", fp.selector))
	}
}

func (fp *AlertStateNotification_FieldTerminalPath) ClearValue(item *Alert_State_Notification) {
	if item != nil {
		switch fp.selector {
		case AlertStateNotification_FieldPathSelectorKind:
			item.Kind = rcommon.NotificationChannelSpec_UNDEFINED
		case AlertStateNotification_FieldPathSelectorPendingChannels:
			item.PendingChannels = nil
		default:
			panic(fmt.Sprintf("Invalid selector for Alert_State_Notification: %d", fp.selector))
		}
	}
}

func (fp *AlertStateNotification_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*Alert_State_Notification))
}

// IsLeaf - whether field path is holds simple value
func (fp *AlertStateNotification_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == AlertStateNotification_FieldPathSelectorKind ||
		fp.selector == AlertStateNotification_FieldPathSelectorPendingChannels
}

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

func (fp *AlertStateNotification_FieldTerminalPath) WithIValue(value interface{}) AlertStateNotification_FieldPathValue {
	switch fp.selector {
	case AlertStateNotification_FieldPathSelectorKind:
		return &AlertStateNotification_FieldTerminalPathValue{AlertStateNotification_FieldTerminalPath: *fp, value: value.(rcommon.NotificationChannelSpec_EventKind)}
	case AlertStateNotification_FieldPathSelectorPendingChannels:
		return &AlertStateNotification_FieldTerminalPathValue{AlertStateNotification_FieldTerminalPath: *fp, value: value.([]*notification_channel.Reference)}
	default:
		panic(fmt.Sprintf("Invalid selector for Alert_State_Notification: %d", fp.selector))
	}
}

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

func (fp *AlertStateNotification_FieldTerminalPath) WithIArrayOfValues(values interface{}) AlertStateNotification_FieldPathArrayOfValues {
	fpaov := &AlertStateNotification_FieldTerminalPathArrayOfValues{AlertStateNotification_FieldTerminalPath: *fp}
	switch fp.selector {
	case AlertStateNotification_FieldPathSelectorKind:
		return &AlertStateNotification_FieldTerminalPathArrayOfValues{AlertStateNotification_FieldTerminalPath: *fp, values: values.([]rcommon.NotificationChannelSpec_EventKind)}
	case AlertStateNotification_FieldPathSelectorPendingChannels:
		return &AlertStateNotification_FieldTerminalPathArrayOfValues{AlertStateNotification_FieldTerminalPath: *fp, values: values.([][]*notification_channel.Reference)}
	default:
		panic(fmt.Sprintf("Invalid selector for Alert_State_Notification: %d", fp.selector))
	}
	return fpaov
}

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

func (fp *AlertStateNotification_FieldTerminalPath) WithIArrayItemValue(value interface{}) AlertStateNotification_FieldPathArrayItemValue {
	switch fp.selector {
	case AlertStateNotification_FieldPathSelectorPendingChannels:
		return &AlertStateNotification_FieldTerminalPathArrayItemValue{AlertStateNotification_FieldTerminalPath: *fp, value: value.(*notification_channel.Reference)}
	default:
		panic(fmt.Sprintf("Invalid selector for Alert_State_Notification: %d", fp.selector))
	}
}

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

// AlertStateNotification_FieldPathValue allows storing values for Notification fields according to their type
type AlertStateNotification_FieldPathValue interface {
	AlertStateNotification_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **Alert_State_Notification)
	CompareWith(*Alert_State_Notification) (cmp int, comparable bool)
}

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

func MustParseAlertStateNotification_FieldPathValue(pathStr, valueStr string) AlertStateNotification_FieldPathValue {
	fpv, err := ParseAlertStateNotification_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type AlertStateNotification_FieldTerminalPathValue struct {
	AlertStateNotification_FieldTerminalPath
	value interface{}
}

var _ AlertStateNotification_FieldPathValue = (*AlertStateNotification_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'Notification' as interface{}
func (fpv *AlertStateNotification_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *AlertStateNotification_FieldTerminalPathValue) AsKindValue() (rcommon.NotificationChannelSpec_EventKind, bool) {
	res, ok := fpv.value.(rcommon.NotificationChannelSpec_EventKind)
	return res, ok
}
func (fpv *AlertStateNotification_FieldTerminalPathValue) AsPendingChannelsValue() ([]*notification_channel.Reference, bool) {
	res, ok := fpv.value.([]*notification_channel.Reference)
	return res, ok
}

// SetTo stores value for selected field for object Notification
func (fpv *AlertStateNotification_FieldTerminalPathValue) SetTo(target **Alert_State_Notification) {
	if *target == nil {
		*target = new(Alert_State_Notification)
	}
	switch fpv.selector {
	case AlertStateNotification_FieldPathSelectorKind:
		(*target).Kind = fpv.value.(rcommon.NotificationChannelSpec_EventKind)
	case AlertStateNotification_FieldPathSelectorPendingChannels:
		(*target).PendingChannels = fpv.value.([]*notification_channel.Reference)
	default:
		panic(fmt.Sprintf("Invalid selector for Alert_State_Notification: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'AlertStateNotification_FieldTerminalPathValue' with the value under path in 'Alert_State_Notification'.
func (fpv *AlertStateNotification_FieldTerminalPathValue) CompareWith(source *Alert_State_Notification) (int, bool) {
	switch fpv.selector {
	case AlertStateNotification_FieldPathSelectorKind:
		leftValue := fpv.value.(rcommon.NotificationChannelSpec_EventKind)
		rightValue := source.GetKind()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case AlertStateNotification_FieldPathSelectorPendingChannels:
		return 0, false
	default:
		panic(fmt.Sprintf("Invalid selector for Alert_State_Notification: %d", fpv.selector))
	}
}

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

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

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

func MustParseAlertStateNotification_FieldPathArrayItemValue(pathStr, valueStr string) AlertStateNotification_FieldPathArrayItemValue {
	fpaiv, err := ParseAlertStateNotification_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type AlertStateNotification_FieldTerminalPathArrayItemValue struct {
	AlertStateNotification_FieldTerminalPath
	value interface{}
}

var _ AlertStateNotification_FieldPathArrayItemValue = (*AlertStateNotification_FieldTerminalPathArrayItemValue)(nil)

// GetRawValue returns stored element value for array in object Alert_State_Notification as interface{}
func (fpaiv *AlertStateNotification_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaiv.value
}
func (fpaiv *AlertStateNotification_FieldTerminalPathArrayItemValue) AsPendingChannelsItemValue() (*notification_channel.Reference, bool) {
	res, ok := fpaiv.value.(*notification_channel.Reference)
	return res, ok
}

func (fpaiv *AlertStateNotification_FieldTerminalPathArrayItemValue) GetSingle(source *Alert_State_Notification) (interface{}, bool) {
	return nil, false
}

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

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

// AlertStateNotification_FieldPathArrayOfValues allows storing slice of values for Notification fields according to their type
type AlertStateNotification_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	AlertStateNotification_FieldPath
}

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

func MustParseAlertStateNotification_FieldPathArrayOfValues(pathStr, valuesStr string) AlertStateNotification_FieldPathArrayOfValues {
	fpaov, err := ParseAlertStateNotification_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type AlertStateNotification_FieldTerminalPathArrayOfValues struct {
	AlertStateNotification_FieldTerminalPath
	values interface{}
}

var _ AlertStateNotification_FieldPathArrayOfValues = (*AlertStateNotification_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *AlertStateNotification_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case AlertStateNotification_FieldPathSelectorKind:
		for _, v := range fpaov.values.([]rcommon.NotificationChannelSpec_EventKind) {
			values = append(values, v)
		}
	case AlertStateNotification_FieldPathSelectorPendingChannels:
		for _, v := range fpaov.values.([][]*notification_channel.Reference) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *AlertStateNotification_FieldTerminalPathArrayOfValues) AsKindArrayOfValues() ([]rcommon.NotificationChannelSpec_EventKind, bool) {
	res, ok := fpaov.values.([]rcommon.NotificationChannelSpec_EventKind)
	return res, ok
}
func (fpaov *AlertStateNotification_FieldTerminalPathArrayOfValues) AsPendingChannelsArrayOfValues() ([][]*notification_channel.Reference, bool) {
	res, ok := fpaov.values.([][]*notification_channel.Reference)
	return res, ok
}