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

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

package alerting_condition

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

	"google.golang.org/grpc/codes"
	"google.golang.org/grpc/status"
	"google.golang.org/protobuf/encoding/protojson"
	"google.golang.org/protobuf/proto"
	"google.golang.org/protobuf/reflect/protoregistry"

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

// proto imports
import (
	alerting_policy "github.com/cloudwan/edgelq-sdk/monitoring/resources/v3/alerting_policy"
	common "github.com/cloudwan/edgelq-sdk/monitoring/resources/v3/common"
	meta "github.com/cloudwan/goten-sdk/types/meta"
	durationpb "google.golang.org/protobuf/types/known/durationpb"
)

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

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

	_ = new(gotenobject.FieldPath)
)

// make sure we're using proto imports
var (
	_ = &alerting_policy.AlertingPolicy{}
	_ = &common.LabelDescriptor{}
	_ = &durationpb.Duration{}
	_ = &meta.Meta{}
)

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

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

type AlertingCondition_FieldPathSelector int32

const (
	AlertingCondition_FieldPathSelectorName        AlertingCondition_FieldPathSelector = 0
	AlertingCondition_FieldPathSelectorMetadata    AlertingCondition_FieldPathSelector = 1
	AlertingCondition_FieldPathSelectorDisplayName AlertingCondition_FieldPathSelector = 2
	AlertingCondition_FieldPathSelectorDescription AlertingCondition_FieldPathSelector = 3
	AlertingCondition_FieldPathSelectorSpec        AlertingCondition_FieldPathSelector = 4
	AlertingCondition_FieldPathSelectorState       AlertingCondition_FieldPathSelector = 5
)

func (s AlertingCondition_FieldPathSelector) String() string {
	switch s {
	case AlertingCondition_FieldPathSelectorName:
		return "name"
	case AlertingCondition_FieldPathSelectorMetadata:
		return "metadata"
	case AlertingCondition_FieldPathSelectorDisplayName:
		return "display_name"
	case AlertingCondition_FieldPathSelectorDescription:
		return "description"
	case AlertingCondition_FieldPathSelectorSpec:
		return "spec"
	case AlertingCondition_FieldPathSelectorState:
		return "state"
	default:
		panic(fmt.Sprintf("Invalid selector for AlertingCondition: %d", s))
	}
}

func BuildAlertingCondition_FieldPath(fp gotenobject.RawFieldPath) (AlertingCondition_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object AlertingCondition")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "name":
			return &AlertingCondition_FieldTerminalPath{selector: AlertingCondition_FieldPathSelectorName}, nil
		case "metadata":
			return &AlertingCondition_FieldTerminalPath{selector: AlertingCondition_FieldPathSelectorMetadata}, nil
		case "display_name", "displayName", "display-name":
			return &AlertingCondition_FieldTerminalPath{selector: AlertingCondition_FieldPathSelectorDisplayName}, nil
		case "description":
			return &AlertingCondition_FieldTerminalPath{selector: AlertingCondition_FieldPathSelectorDescription}, nil
		case "spec":
			return &AlertingCondition_FieldTerminalPath{selector: AlertingCondition_FieldPathSelectorSpec}, nil
		case "state":
			return &AlertingCondition_FieldTerminalPath{selector: AlertingCondition_FieldPathSelectorState}, nil
		}
	} else {
		switch fp[0] {
		case "metadata":
			if subpath, err := meta.BuildMeta_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &AlertingCondition_FieldSubPath{selector: AlertingCondition_FieldPathSelectorMetadata, subPath: subpath}, nil
			}
		case "spec":
			if subpath, err := BuildAlertingConditionSpec_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &AlertingCondition_FieldSubPath{selector: AlertingCondition_FieldPathSelectorSpec, subPath: subpath}, nil
			}
		case "state":
			if subpath, err := BuildAlertingConditionState_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &AlertingCondition_FieldSubPath{selector: AlertingCondition_FieldPathSelectorState, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object AlertingCondition", fp)
}

func ParseAlertingCondition_FieldPath(rawField string) (AlertingCondition_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildAlertingCondition_FieldPath(fp)
}

func MustParseAlertingCondition_FieldPath(rawField string) AlertingCondition_FieldPath {
	fp, err := ParseAlertingCondition_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type AlertingCondition_FieldTerminalPath struct {
	selector AlertingCondition_FieldPathSelector
}

var _ AlertingCondition_FieldPath = (*AlertingCondition_FieldTerminalPath)(nil)

func (fp *AlertingCondition_FieldTerminalPath) Selector() AlertingCondition_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source AlertingCondition
func (fp *AlertingCondition_FieldTerminalPath) Get(source *AlertingCondition) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case AlertingCondition_FieldPathSelectorName:
			if source.Name != nil {
				values = append(values, source.Name)
			}
		case AlertingCondition_FieldPathSelectorMetadata:
			if source.Metadata != nil {
				values = append(values, source.Metadata)
			}
		case AlertingCondition_FieldPathSelectorDisplayName:
			values = append(values, source.DisplayName)
		case AlertingCondition_FieldPathSelectorDescription:
			values = append(values, source.Description)
		case AlertingCondition_FieldPathSelectorSpec:
			if source.Spec != nil {
				values = append(values, source.Spec)
			}
		case AlertingCondition_FieldPathSelectorState:
			if source.State != nil {
				values = append(values, source.State)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for AlertingCondition: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source AlertingCondition
func (fp *AlertingCondition_FieldTerminalPath) GetSingle(source *AlertingCondition) (interface{}, bool) {
	switch fp.selector {
	case AlertingCondition_FieldPathSelectorName:
		res := source.GetName()
		return res, res != nil
	case AlertingCondition_FieldPathSelectorMetadata:
		res := source.GetMetadata()
		return res, res != nil
	case AlertingCondition_FieldPathSelectorDisplayName:
		return source.GetDisplayName(), source != nil
	case AlertingCondition_FieldPathSelectorDescription:
		return source.GetDescription(), source != nil
	case AlertingCondition_FieldPathSelectorSpec:
		res := source.GetSpec()
		return res, res != nil
	case AlertingCondition_FieldPathSelectorState:
		res := source.GetState()
		return res, res != nil
	default:
		panic(fmt.Sprintf("Invalid selector for AlertingCondition: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *AlertingCondition_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case AlertingCondition_FieldPathSelectorName:
		return (*Name)(nil)
	case AlertingCondition_FieldPathSelectorMetadata:
		return (*meta.Meta)(nil)
	case AlertingCondition_FieldPathSelectorDisplayName:
		return ""
	case AlertingCondition_FieldPathSelectorDescription:
		return ""
	case AlertingCondition_FieldPathSelectorSpec:
		return (*AlertingCondition_Spec)(nil)
	case AlertingCondition_FieldPathSelectorState:
		return (*AlertingCondition_State)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for AlertingCondition: %d", fp.selector))
	}
}

func (fp *AlertingCondition_FieldTerminalPath) ClearValue(item *AlertingCondition) {
	if item != nil {
		switch fp.selector {
		case AlertingCondition_FieldPathSelectorName:
			item.Name = nil
		case AlertingCondition_FieldPathSelectorMetadata:
			item.Metadata = nil
		case AlertingCondition_FieldPathSelectorDisplayName:
			item.DisplayName = ""
		case AlertingCondition_FieldPathSelectorDescription:
			item.Description = ""
		case AlertingCondition_FieldPathSelectorSpec:
			item.Spec = nil
		case AlertingCondition_FieldPathSelectorState:
			item.State = nil
		default:
			panic(fmt.Sprintf("Invalid selector for AlertingCondition: %d", fp.selector))
		}
	}
}

func (fp *AlertingCondition_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*AlertingCondition))
}

// IsLeaf - whether field path is holds simple value
func (fp *AlertingCondition_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == AlertingCondition_FieldPathSelectorName ||
		fp.selector == AlertingCondition_FieldPathSelectorDisplayName ||
		fp.selector == AlertingCondition_FieldPathSelectorDescription
}

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

func (fp *AlertingCondition_FieldTerminalPath) WithIValue(value interface{}) AlertingCondition_FieldPathValue {
	switch fp.selector {
	case AlertingCondition_FieldPathSelectorName:
		return &AlertingCondition_FieldTerminalPathValue{AlertingCondition_FieldTerminalPath: *fp, value: value.(*Name)}
	case AlertingCondition_FieldPathSelectorMetadata:
		return &AlertingCondition_FieldTerminalPathValue{AlertingCondition_FieldTerminalPath: *fp, value: value.(*meta.Meta)}
	case AlertingCondition_FieldPathSelectorDisplayName:
		return &AlertingCondition_FieldTerminalPathValue{AlertingCondition_FieldTerminalPath: *fp, value: value.(string)}
	case AlertingCondition_FieldPathSelectorDescription:
		return &AlertingCondition_FieldTerminalPathValue{AlertingCondition_FieldTerminalPath: *fp, value: value.(string)}
	case AlertingCondition_FieldPathSelectorSpec:
		return &AlertingCondition_FieldTerminalPathValue{AlertingCondition_FieldTerminalPath: *fp, value: value.(*AlertingCondition_Spec)}
	case AlertingCondition_FieldPathSelectorState:
		return &AlertingCondition_FieldTerminalPathValue{AlertingCondition_FieldTerminalPath: *fp, value: value.(*AlertingCondition_State)}
	default:
		panic(fmt.Sprintf("Invalid selector for AlertingCondition: %d", fp.selector))
	}
}

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

func (fp *AlertingCondition_FieldTerminalPath) WithIArrayOfValues(values interface{}) AlertingCondition_FieldPathArrayOfValues {
	fpaov := &AlertingCondition_FieldTerminalPathArrayOfValues{AlertingCondition_FieldTerminalPath: *fp}
	switch fp.selector {
	case AlertingCondition_FieldPathSelectorName:
		return &AlertingCondition_FieldTerminalPathArrayOfValues{AlertingCondition_FieldTerminalPath: *fp, values: values.([]*Name)}
	case AlertingCondition_FieldPathSelectorMetadata:
		return &AlertingCondition_FieldTerminalPathArrayOfValues{AlertingCondition_FieldTerminalPath: *fp, values: values.([]*meta.Meta)}
	case AlertingCondition_FieldPathSelectorDisplayName:
		return &AlertingCondition_FieldTerminalPathArrayOfValues{AlertingCondition_FieldTerminalPath: *fp, values: values.([]string)}
	case AlertingCondition_FieldPathSelectorDescription:
		return &AlertingCondition_FieldTerminalPathArrayOfValues{AlertingCondition_FieldTerminalPath: *fp, values: values.([]string)}
	case AlertingCondition_FieldPathSelectorSpec:
		return &AlertingCondition_FieldTerminalPathArrayOfValues{AlertingCondition_FieldTerminalPath: *fp, values: values.([]*AlertingCondition_Spec)}
	case AlertingCondition_FieldPathSelectorState:
		return &AlertingCondition_FieldTerminalPathArrayOfValues{AlertingCondition_FieldTerminalPath: *fp, values: values.([]*AlertingCondition_State)}
	default:
		panic(fmt.Sprintf("Invalid selector for AlertingCondition: %d", fp.selector))
	}
	return fpaov
}

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

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

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

type AlertingCondition_FieldSubPath struct {
	selector AlertingCondition_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ AlertingCondition_FieldPath = (*AlertingCondition_FieldSubPath)(nil)

func (fps *AlertingCondition_FieldSubPath) Selector() AlertingCondition_FieldPathSelector {
	return fps.selector
}
func (fps *AlertingCondition_FieldSubPath) AsMetadataSubPath() (meta.Meta_FieldPath, bool) {
	res, ok := fps.subPath.(meta.Meta_FieldPath)
	return res, ok
}
func (fps *AlertingCondition_FieldSubPath) AsSpecSubPath() (AlertingConditionSpec_FieldPath, bool) {
	res, ok := fps.subPath.(AlertingConditionSpec_FieldPath)
	return res, ok
}
func (fps *AlertingCondition_FieldSubPath) AsStateSubPath() (AlertingConditionState_FieldPath, bool) {
	res, ok := fps.subPath.(AlertingConditionState_FieldPath)
	return res, ok
}

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

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

// Get returns all values pointed by selected field from source AlertingCondition
func (fps *AlertingCondition_FieldSubPath) Get(source *AlertingCondition) (values []interface{}) {
	switch fps.selector {
	case AlertingCondition_FieldPathSelectorMetadata:
		values = append(values, fps.subPath.GetRaw(source.GetMetadata())...)
	case AlertingCondition_FieldPathSelectorSpec:
		values = append(values, fps.subPath.GetRaw(source.GetSpec())...)
	case AlertingCondition_FieldPathSelectorState:
		values = append(values, fps.subPath.GetRaw(source.GetState())...)
	default:
		panic(fmt.Sprintf("Invalid selector for AlertingCondition: %d", fps.selector))
	}
	return
}

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

// GetSingle returns value of selected field from source AlertingCondition
func (fps *AlertingCondition_FieldSubPath) GetSingle(source *AlertingCondition) (interface{}, bool) {
	switch fps.selector {
	case AlertingCondition_FieldPathSelectorMetadata:
		if source.GetMetadata() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetMetadata())
	case AlertingCondition_FieldPathSelectorSpec:
		if source.GetSpec() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetSpec())
	case AlertingCondition_FieldPathSelectorState:
		if source.GetState() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetState())
	default:
		panic(fmt.Sprintf("Invalid selector for AlertingCondition: %d", fps.selector))
	}
}

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

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

func (fps *AlertingCondition_FieldSubPath) ClearValue(item *AlertingCondition) {
	if item != nil {
		switch fps.selector {
		case AlertingCondition_FieldPathSelectorMetadata:
			fps.subPath.ClearValueRaw(item.Metadata)
		case AlertingCondition_FieldPathSelectorSpec:
			fps.subPath.ClearValueRaw(item.Spec)
		case AlertingCondition_FieldPathSelectorState:
			fps.subPath.ClearValueRaw(item.State)
		default:
			panic(fmt.Sprintf("Invalid selector for AlertingCondition: %d", fps.selector))
		}
	}
}

func (fps *AlertingCondition_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*AlertingCondition))
}

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

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

func (fps *AlertingCondition_FieldSubPath) WithIValue(value interface{}) AlertingCondition_FieldPathValue {
	return &AlertingCondition_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *AlertingCondition_FieldSubPath) WithIArrayOfValues(values interface{}) AlertingCondition_FieldPathArrayOfValues {
	return &AlertingCondition_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *AlertingCondition_FieldSubPath) WithIArrayItemValue(value interface{}) AlertingCondition_FieldPathArrayItemValue {
	return &AlertingCondition_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

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

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

func MustParseAlertingCondition_FieldPathValue(pathStr, valueStr string) AlertingCondition_FieldPathValue {
	fpv, err := ParseAlertingCondition_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type AlertingCondition_FieldTerminalPathValue struct {
	AlertingCondition_FieldTerminalPath
	value interface{}
}

var _ AlertingCondition_FieldPathValue = (*AlertingCondition_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'AlertingCondition' as interface{}
func (fpv *AlertingCondition_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *AlertingCondition_FieldTerminalPathValue) AsNameValue() (*Name, bool) {
	res, ok := fpv.value.(*Name)
	return res, ok
}
func (fpv *AlertingCondition_FieldTerminalPathValue) AsMetadataValue() (*meta.Meta, bool) {
	res, ok := fpv.value.(*meta.Meta)
	return res, ok
}
func (fpv *AlertingCondition_FieldTerminalPathValue) AsDisplayNameValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *AlertingCondition_FieldTerminalPathValue) AsDescriptionValue() (string, bool) {
	res, ok := fpv.value.(string)
	return res, ok
}
func (fpv *AlertingCondition_FieldTerminalPathValue) AsSpecValue() (*AlertingCondition_Spec, bool) {
	res, ok := fpv.value.(*AlertingCondition_Spec)
	return res, ok
}
func (fpv *AlertingCondition_FieldTerminalPathValue) AsStateValue() (*AlertingCondition_State, bool) {
	res, ok := fpv.value.(*AlertingCondition_State)
	return res, ok
}

// SetTo stores value for selected field for object AlertingCondition
func (fpv *AlertingCondition_FieldTerminalPathValue) SetTo(target **AlertingCondition) {
	if *target == nil {
		*target = new(AlertingCondition)
	}
	switch fpv.selector {
	case AlertingCondition_FieldPathSelectorName:
		(*target).Name = fpv.value.(*Name)
	case AlertingCondition_FieldPathSelectorMetadata:
		(*target).Metadata = fpv.value.(*meta.Meta)
	case AlertingCondition_FieldPathSelectorDisplayName:
		(*target).DisplayName = fpv.value.(string)
	case AlertingCondition_FieldPathSelectorDescription:
		(*target).Description = fpv.value.(string)
	case AlertingCondition_FieldPathSelectorSpec:
		(*target).Spec = fpv.value.(*AlertingCondition_Spec)
	case AlertingCondition_FieldPathSelectorState:
		(*target).State = fpv.value.(*AlertingCondition_State)
	default:
		panic(fmt.Sprintf("Invalid selector for AlertingCondition: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'AlertingCondition_FieldTerminalPathValue' with the value under path in 'AlertingCondition'.
func (fpv *AlertingCondition_FieldTerminalPathValue) CompareWith(source *AlertingCondition) (int, bool) {
	switch fpv.selector {
	case AlertingCondition_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 AlertingCondition_FieldPathSelectorMetadata:
		return 0, false
	case AlertingCondition_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 AlertingCondition_FieldPathSelectorDescription:
		leftValue := fpv.value.(string)
		rightValue := source.GetDescription()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	case AlertingCondition_FieldPathSelectorSpec:
		return 0, false
	case AlertingCondition_FieldPathSelectorState:
		return 0, false
	default:
		panic(fmt.Sprintf("Invalid selector for AlertingCondition: %d", fpv.selector))
	}
}

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

type AlertingCondition_FieldSubPathValue struct {
	AlertingCondition_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ AlertingCondition_FieldPathValue = (*AlertingCondition_FieldSubPathValue)(nil)

func (fpvs *AlertingCondition_FieldSubPathValue) AsMetadataPathValue() (meta.Meta_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(meta.Meta_FieldPathValue)
	return res, ok
}
func (fpvs *AlertingCondition_FieldSubPathValue) AsSpecPathValue() (AlertingConditionSpec_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(AlertingConditionSpec_FieldPathValue)
	return res, ok
}
func (fpvs *AlertingCondition_FieldSubPathValue) AsStatePathValue() (AlertingConditionState_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(AlertingConditionState_FieldPathValue)
	return res, ok
}

func (fpvs *AlertingCondition_FieldSubPathValue) SetTo(target **AlertingCondition) {
	if *target == nil {
		*target = new(AlertingCondition)
	}
	switch fpvs.Selector() {
	case AlertingCondition_FieldPathSelectorMetadata:
		fpvs.subPathValue.(meta.Meta_FieldPathValue).SetTo(&(*target).Metadata)
	case AlertingCondition_FieldPathSelectorSpec:
		fpvs.subPathValue.(AlertingConditionSpec_FieldPathValue).SetTo(&(*target).Spec)
	case AlertingCondition_FieldPathSelectorState:
		fpvs.subPathValue.(AlertingConditionState_FieldPathValue).SetTo(&(*target).State)
	default:
		panic(fmt.Sprintf("Invalid selector for AlertingCondition: %d", fpvs.Selector()))
	}
}

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

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

func (fpvs *AlertingCondition_FieldSubPathValue) CompareWith(source *AlertingCondition) (int, bool) {
	switch fpvs.Selector() {
	case AlertingCondition_FieldPathSelectorMetadata:
		return fpvs.subPathValue.(meta.Meta_FieldPathValue).CompareWith(source.GetMetadata())
	case AlertingCondition_FieldPathSelectorSpec:
		return fpvs.subPathValue.(AlertingConditionSpec_FieldPathValue).CompareWith(source.GetSpec())
	case AlertingCondition_FieldPathSelectorState:
		return fpvs.subPathValue.(AlertingConditionState_FieldPathValue).CompareWith(source.GetState())
	default:
		panic(fmt.Sprintf("Invalid selector for AlertingCondition: %d", fpvs.Selector()))
	}
}

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

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

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

func MustParseAlertingCondition_FieldPathArrayItemValue(pathStr, valueStr string) AlertingCondition_FieldPathArrayItemValue {
	fpaiv, err := ParseAlertingCondition_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type AlertingCondition_FieldTerminalPathArrayItemValue struct {
	AlertingCondition_FieldTerminalPath
	value interface{}
}

var _ AlertingCondition_FieldPathArrayItemValue = (*AlertingCondition_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *AlertingCondition_FieldTerminalPathArrayItemValue) GetSingle(source *AlertingCondition) (interface{}, bool) {
	return nil, false
}

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

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

// GetRawValue returns stored array item value
func (fpaivs *AlertingCondition_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *AlertingCondition_FieldSubPathArrayItemValue) AsMetadataPathItemValue() (meta.Meta_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(meta.Meta_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *AlertingCondition_FieldSubPathArrayItemValue) AsSpecPathItemValue() (AlertingConditionSpec_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(AlertingConditionSpec_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *AlertingCondition_FieldSubPathArrayItemValue) AsStatePathItemValue() (AlertingConditionState_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(AlertingConditionState_FieldPathArrayItemValue)
	return res, ok
}

// Contains returns a boolean indicating if value that is being held is present in given 'AlertingCondition'
func (fpaivs *AlertingCondition_FieldSubPathArrayItemValue) ContainsValue(source *AlertingCondition) bool {
	switch fpaivs.Selector() {
	case AlertingCondition_FieldPathSelectorMetadata:
		return fpaivs.subPathItemValue.(meta.Meta_FieldPathArrayItemValue).ContainsValue(source.GetMetadata())
	case AlertingCondition_FieldPathSelectorSpec:
		return fpaivs.subPathItemValue.(AlertingConditionSpec_FieldPathArrayItemValue).ContainsValue(source.GetSpec())
	case AlertingCondition_FieldPathSelectorState:
		return fpaivs.subPathItemValue.(AlertingConditionState_FieldPathArrayItemValue).ContainsValue(source.GetState())
	default:
		panic(fmt.Sprintf("Invalid selector for AlertingCondition: %d", fpaivs.Selector()))
	}
}

// AlertingCondition_FieldPathArrayOfValues allows storing slice of values for AlertingCondition fields according to their type
type AlertingCondition_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	AlertingCondition_FieldPath
}

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

func MustParseAlertingCondition_FieldPathArrayOfValues(pathStr, valuesStr string) AlertingCondition_FieldPathArrayOfValues {
	fpaov, err := ParseAlertingCondition_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type AlertingCondition_FieldTerminalPathArrayOfValues struct {
	AlertingCondition_FieldTerminalPath
	values interface{}
}

var _ AlertingCondition_FieldPathArrayOfValues = (*AlertingCondition_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *AlertingCondition_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case AlertingCondition_FieldPathSelectorName:
		for _, v := range fpaov.values.([]*Name) {
			values = append(values, v)
		}
	case AlertingCondition_FieldPathSelectorMetadata:
		for _, v := range fpaov.values.([]*meta.Meta) {
			values = append(values, v)
		}
	case AlertingCondition_FieldPathSelectorDisplayName:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case AlertingCondition_FieldPathSelectorDescription:
		for _, v := range fpaov.values.([]string) {
			values = append(values, v)
		}
	case AlertingCondition_FieldPathSelectorSpec:
		for _, v := range fpaov.values.([]*AlertingCondition_Spec) {
			values = append(values, v)
		}
	case AlertingCondition_FieldPathSelectorState:
		for _, v := range fpaov.values.([]*AlertingCondition_State) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *AlertingCondition_FieldTerminalPathArrayOfValues) AsNameArrayOfValues() ([]*Name, bool) {
	res, ok := fpaov.values.([]*Name)
	return res, ok
}
func (fpaov *AlertingCondition_FieldTerminalPathArrayOfValues) AsMetadataArrayOfValues() ([]*meta.Meta, bool) {
	res, ok := fpaov.values.([]*meta.Meta)
	return res, ok
}
func (fpaov *AlertingCondition_FieldTerminalPathArrayOfValues) AsDisplayNameArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *AlertingCondition_FieldTerminalPathArrayOfValues) AsDescriptionArrayOfValues() ([]string, bool) {
	res, ok := fpaov.values.([]string)
	return res, ok
}
func (fpaov *AlertingCondition_FieldTerminalPathArrayOfValues) AsSpecArrayOfValues() ([]*AlertingCondition_Spec, bool) {
	res, ok := fpaov.values.([]*AlertingCondition_Spec)
	return res, ok
}
func (fpaov *AlertingCondition_FieldTerminalPathArrayOfValues) AsStateArrayOfValues() ([]*AlertingCondition_State, bool) {
	res, ok := fpaov.values.([]*AlertingCondition_State)
	return res, ok
}

type AlertingCondition_FieldSubPathArrayOfValues struct {
	AlertingCondition_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ AlertingCondition_FieldPathArrayOfValues = (*AlertingCondition_FieldSubPathArrayOfValues)(nil)

func (fpsaov *AlertingCondition_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *AlertingCondition_FieldSubPathArrayOfValues) AsMetadataPathArrayOfValues() (meta.Meta_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(meta.Meta_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *AlertingCondition_FieldSubPathArrayOfValues) AsSpecPathArrayOfValues() (AlertingConditionSpec_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(AlertingConditionSpec_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *AlertingCondition_FieldSubPathArrayOfValues) AsStatePathArrayOfValues() (AlertingConditionState_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(AlertingConditionState_FieldPathArrayOfValues)
	return res, ok
}

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

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

type AlertingConditionSpec_FieldPathSelector int32

const (
	AlertingConditionSpec_FieldPathSelectorTimeSeries AlertingConditionSpec_FieldPathSelector = 0
	AlertingConditionSpec_FieldPathSelectorTrigger    AlertingConditionSpec_FieldPathSelector = 1
)

func (s AlertingConditionSpec_FieldPathSelector) String() string {
	switch s {
	case AlertingConditionSpec_FieldPathSelectorTimeSeries:
		return "time_series"
	case AlertingConditionSpec_FieldPathSelectorTrigger:
		return "trigger"
	default:
		panic(fmt.Sprintf("Invalid selector for AlertingCondition_Spec: %d", s))
	}
}

func BuildAlertingConditionSpec_FieldPath(fp gotenobject.RawFieldPath) (AlertingConditionSpec_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object AlertingCondition_Spec")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "time_series", "timeSeries", "time-series":
			return &AlertingConditionSpec_FieldTerminalPath{selector: AlertingConditionSpec_FieldPathSelectorTimeSeries}, nil
		case "trigger":
			return &AlertingConditionSpec_FieldTerminalPath{selector: AlertingConditionSpec_FieldPathSelectorTrigger}, nil
		}
	} else {
		switch fp[0] {
		case "time_series", "timeSeries", "time-series":
			if subpath, err := BuildAlertingConditionSpecTimeSeries_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &AlertingConditionSpec_FieldSubPath{selector: AlertingConditionSpec_FieldPathSelectorTimeSeries, subPath: subpath}, nil
			}
		case "trigger":
			if subpath, err := BuildAlertingConditionSpecTrigger_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &AlertingConditionSpec_FieldSubPath{selector: AlertingConditionSpec_FieldPathSelectorTrigger, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object AlertingCondition_Spec", fp)
}

func ParseAlertingConditionSpec_FieldPath(rawField string) (AlertingConditionSpec_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildAlertingConditionSpec_FieldPath(fp)
}

func MustParseAlertingConditionSpec_FieldPath(rawField string) AlertingConditionSpec_FieldPath {
	fp, err := ParseAlertingConditionSpec_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type AlertingConditionSpec_FieldTerminalPath struct {
	selector AlertingConditionSpec_FieldPathSelector
}

var _ AlertingConditionSpec_FieldPath = (*AlertingConditionSpec_FieldTerminalPath)(nil)

func (fp *AlertingConditionSpec_FieldTerminalPath) Selector() AlertingConditionSpec_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

// GetDefault returns a default value of the field type
func (fp *AlertingConditionSpec_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case AlertingConditionSpec_FieldPathSelectorTimeSeries:
		return (*AlertingCondition_Spec_TimeSeries)(nil)
	case AlertingConditionSpec_FieldPathSelectorTrigger:
		return (*AlertingCondition_Spec_Trigger)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for AlertingCondition_Spec: %d", fp.selector))
	}
}

func (fp *AlertingConditionSpec_FieldTerminalPath) ClearValue(item *AlertingCondition_Spec) {
	if item != nil {
		switch fp.selector {
		case AlertingConditionSpec_FieldPathSelectorTimeSeries:
			item.TimeSeries = nil
		case AlertingConditionSpec_FieldPathSelectorTrigger:
			item.Trigger = nil
		default:
			panic(fmt.Sprintf("Invalid selector for AlertingCondition_Spec: %d", fp.selector))
		}
	}
}

func (fp *AlertingConditionSpec_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*AlertingCondition_Spec))
}

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

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

func (fp *AlertingConditionSpec_FieldTerminalPath) WithIValue(value interface{}) AlertingConditionSpec_FieldPathValue {
	switch fp.selector {
	case AlertingConditionSpec_FieldPathSelectorTimeSeries:
		return &AlertingConditionSpec_FieldTerminalPathValue{AlertingConditionSpec_FieldTerminalPath: *fp, value: value.(*AlertingCondition_Spec_TimeSeries)}
	case AlertingConditionSpec_FieldPathSelectorTrigger:
		return &AlertingConditionSpec_FieldTerminalPathValue{AlertingConditionSpec_FieldTerminalPath: *fp, value: value.(*AlertingCondition_Spec_Trigger)}
	default:
		panic(fmt.Sprintf("Invalid selector for AlertingCondition_Spec: %d", fp.selector))
	}
}

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

func (fp *AlertingConditionSpec_FieldTerminalPath) WithIArrayOfValues(values interface{}) AlertingConditionSpec_FieldPathArrayOfValues {
	fpaov := &AlertingConditionSpec_FieldTerminalPathArrayOfValues{AlertingConditionSpec_FieldTerminalPath: *fp}
	switch fp.selector {
	case AlertingConditionSpec_FieldPathSelectorTimeSeries:
		return &AlertingConditionSpec_FieldTerminalPathArrayOfValues{AlertingConditionSpec_FieldTerminalPath: *fp, values: values.([]*AlertingCondition_Spec_TimeSeries)}
	case AlertingConditionSpec_FieldPathSelectorTrigger:
		return &AlertingConditionSpec_FieldTerminalPathArrayOfValues{AlertingConditionSpec_FieldTerminalPath: *fp, values: values.([]*AlertingCondition_Spec_Trigger)}
	default:
		panic(fmt.Sprintf("Invalid selector for AlertingCondition_Spec: %d", fp.selector))
	}
	return fpaov
}

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

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

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

type AlertingConditionSpec_FieldSubPath struct {
	selector AlertingConditionSpec_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ AlertingConditionSpec_FieldPath = (*AlertingConditionSpec_FieldSubPath)(nil)

func (fps *AlertingConditionSpec_FieldSubPath) Selector() AlertingConditionSpec_FieldPathSelector {
	return fps.selector
}
func (fps *AlertingConditionSpec_FieldSubPath) AsTimeSeriesSubPath() (AlertingConditionSpecTimeSeries_FieldPath, bool) {
	res, ok := fps.subPath.(AlertingConditionSpecTimeSeries_FieldPath)
	return res, ok
}
func (fps *AlertingConditionSpec_FieldSubPath) AsTriggerSubPath() (AlertingConditionSpecTrigger_FieldPath, bool) {
	res, ok := fps.subPath.(AlertingConditionSpecTrigger_FieldPath)
	return res, ok
}

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

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

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

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

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

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

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

func (fps *AlertingConditionSpec_FieldSubPath) ClearValue(item *AlertingCondition_Spec) {
	if item != nil {
		switch fps.selector {
		case AlertingConditionSpec_FieldPathSelectorTimeSeries:
			fps.subPath.ClearValueRaw(item.TimeSeries)
		case AlertingConditionSpec_FieldPathSelectorTrigger:
			fps.subPath.ClearValueRaw(item.Trigger)
		default:
			panic(fmt.Sprintf("Invalid selector for AlertingCondition_Spec: %d", fps.selector))
		}
	}
}

func (fps *AlertingConditionSpec_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*AlertingCondition_Spec))
}

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

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

func (fps *AlertingConditionSpec_FieldSubPath) WithIValue(value interface{}) AlertingConditionSpec_FieldPathValue {
	return &AlertingConditionSpec_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *AlertingConditionSpec_FieldSubPath) WithIArrayOfValues(values interface{}) AlertingConditionSpec_FieldPathArrayOfValues {
	return &AlertingConditionSpec_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *AlertingConditionSpec_FieldSubPath) WithIArrayItemValue(value interface{}) AlertingConditionSpec_FieldPathArrayItemValue {
	return &AlertingConditionSpec_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

// AlertingConditionSpec_FieldPathValue allows storing values for Spec fields according to their type
type AlertingConditionSpec_FieldPathValue interface {
	AlertingConditionSpec_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **AlertingCondition_Spec)
	CompareWith(*AlertingCondition_Spec) (cmp int, comparable bool)
}

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

func MustParseAlertingConditionSpec_FieldPathValue(pathStr, valueStr string) AlertingConditionSpec_FieldPathValue {
	fpv, err := ParseAlertingConditionSpec_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type AlertingConditionSpec_FieldTerminalPathValue struct {
	AlertingConditionSpec_FieldTerminalPath
	value interface{}
}

var _ AlertingConditionSpec_FieldPathValue = (*AlertingConditionSpec_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'Spec' as interface{}
func (fpv *AlertingConditionSpec_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *AlertingConditionSpec_FieldTerminalPathValue) AsTimeSeriesValue() (*AlertingCondition_Spec_TimeSeries, bool) {
	res, ok := fpv.value.(*AlertingCondition_Spec_TimeSeries)
	return res, ok
}
func (fpv *AlertingConditionSpec_FieldTerminalPathValue) AsTriggerValue() (*AlertingCondition_Spec_Trigger, bool) {
	res, ok := fpv.value.(*AlertingCondition_Spec_Trigger)
	return res, ok
}

// SetTo stores value for selected field for object Spec
func (fpv *AlertingConditionSpec_FieldTerminalPathValue) SetTo(target **AlertingCondition_Spec) {
	if *target == nil {
		*target = new(AlertingCondition_Spec)
	}
	switch fpv.selector {
	case AlertingConditionSpec_FieldPathSelectorTimeSeries:
		(*target).TimeSeries = fpv.value.(*AlertingCondition_Spec_TimeSeries)
	case AlertingConditionSpec_FieldPathSelectorTrigger:
		(*target).Trigger = fpv.value.(*AlertingCondition_Spec_Trigger)
	default:
		panic(fmt.Sprintf("Invalid selector for AlertingCondition_Spec: %d", fpv.selector))
	}
}

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

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

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

type AlertingConditionSpec_FieldSubPathValue struct {
	AlertingConditionSpec_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ AlertingConditionSpec_FieldPathValue = (*AlertingConditionSpec_FieldSubPathValue)(nil)

func (fpvs *AlertingConditionSpec_FieldSubPathValue) AsTimeSeriesPathValue() (AlertingConditionSpecTimeSeries_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(AlertingConditionSpecTimeSeries_FieldPathValue)
	return res, ok
}
func (fpvs *AlertingConditionSpec_FieldSubPathValue) AsTriggerPathValue() (AlertingConditionSpecTrigger_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(AlertingConditionSpecTrigger_FieldPathValue)
	return res, ok
}

func (fpvs *AlertingConditionSpec_FieldSubPathValue) SetTo(target **AlertingCondition_Spec) {
	if *target == nil {
		*target = new(AlertingCondition_Spec)
	}
	switch fpvs.Selector() {
	case AlertingConditionSpec_FieldPathSelectorTimeSeries:
		fpvs.subPathValue.(AlertingConditionSpecTimeSeries_FieldPathValue).SetTo(&(*target).TimeSeries)
	case AlertingConditionSpec_FieldPathSelectorTrigger:
		fpvs.subPathValue.(AlertingConditionSpecTrigger_FieldPathValue).SetTo(&(*target).Trigger)
	default:
		panic(fmt.Sprintf("Invalid selector for AlertingCondition_Spec: %d", fpvs.Selector()))
	}
}

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

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

func (fpvs *AlertingConditionSpec_FieldSubPathValue) CompareWith(source *AlertingCondition_Spec) (int, bool) {
	switch fpvs.Selector() {
	case AlertingConditionSpec_FieldPathSelectorTimeSeries:
		return fpvs.subPathValue.(AlertingConditionSpecTimeSeries_FieldPathValue).CompareWith(source.GetTimeSeries())
	case AlertingConditionSpec_FieldPathSelectorTrigger:
		return fpvs.subPathValue.(AlertingConditionSpecTrigger_FieldPathValue).CompareWith(source.GetTrigger())
	default:
		panic(fmt.Sprintf("Invalid selector for AlertingCondition_Spec: %d", fpvs.Selector()))
	}
}

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

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

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

func MustParseAlertingConditionSpec_FieldPathArrayItemValue(pathStr, valueStr string) AlertingConditionSpec_FieldPathArrayItemValue {
	fpaiv, err := ParseAlertingConditionSpec_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type AlertingConditionSpec_FieldTerminalPathArrayItemValue struct {
	AlertingConditionSpec_FieldTerminalPath
	value interface{}
}

var _ AlertingConditionSpec_FieldPathArrayItemValue = (*AlertingConditionSpec_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *AlertingConditionSpec_FieldTerminalPathArrayItemValue) GetSingle(source *AlertingCondition_Spec) (interface{}, bool) {
	return nil, false
}

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

// Contains returns a boolean indicating if value that is being held is present in given 'Spec'
func (fpaiv *AlertingConditionSpec_FieldTerminalPathArrayItemValue) ContainsValue(source *AlertingCondition_Spec) bool {
	slice := fpaiv.AlertingConditionSpec_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 AlertingConditionSpec_FieldSubPathArrayItemValue struct {
	AlertingConditionSpec_FieldPath
	subPathItemValue gotenobject.FieldPathArrayItemValue
}

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

// Contains returns a boolean indicating if value that is being held is present in given 'Spec'
func (fpaivs *AlertingConditionSpec_FieldSubPathArrayItemValue) ContainsValue(source *AlertingCondition_Spec) bool {
	switch fpaivs.Selector() {
	case AlertingConditionSpec_FieldPathSelectorTimeSeries:
		return fpaivs.subPathItemValue.(AlertingConditionSpecTimeSeries_FieldPathArrayItemValue).ContainsValue(source.GetTimeSeries())
	case AlertingConditionSpec_FieldPathSelectorTrigger:
		return fpaivs.subPathItemValue.(AlertingConditionSpecTrigger_FieldPathArrayItemValue).ContainsValue(source.GetTrigger())
	default:
		panic(fmt.Sprintf("Invalid selector for AlertingCondition_Spec: %d", fpaivs.Selector()))
	}
}

// AlertingConditionSpec_FieldPathArrayOfValues allows storing slice of values for Spec fields according to their type
type AlertingConditionSpec_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	AlertingConditionSpec_FieldPath
}

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

func MustParseAlertingConditionSpec_FieldPathArrayOfValues(pathStr, valuesStr string) AlertingConditionSpec_FieldPathArrayOfValues {
	fpaov, err := ParseAlertingConditionSpec_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type AlertingConditionSpec_FieldTerminalPathArrayOfValues struct {
	AlertingConditionSpec_FieldTerminalPath
	values interface{}
}

var _ AlertingConditionSpec_FieldPathArrayOfValues = (*AlertingConditionSpec_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *AlertingConditionSpec_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case AlertingConditionSpec_FieldPathSelectorTimeSeries:
		for _, v := range fpaov.values.([]*AlertingCondition_Spec_TimeSeries) {
			values = append(values, v)
		}
	case AlertingConditionSpec_FieldPathSelectorTrigger:
		for _, v := range fpaov.values.([]*AlertingCondition_Spec_Trigger) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *AlertingConditionSpec_FieldTerminalPathArrayOfValues) AsTimeSeriesArrayOfValues() ([]*AlertingCondition_Spec_TimeSeries, bool) {
	res, ok := fpaov.values.([]*AlertingCondition_Spec_TimeSeries)
	return res, ok
}
func (fpaov *AlertingConditionSpec_FieldTerminalPathArrayOfValues) AsTriggerArrayOfValues() ([]*AlertingCondition_Spec_Trigger, bool) {
	res, ok := fpaov.values.([]*AlertingCondition_Spec_Trigger)
	return res, ok
}

type AlertingConditionSpec_FieldSubPathArrayOfValues struct {
	AlertingConditionSpec_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ AlertingConditionSpec_FieldPathArrayOfValues = (*AlertingConditionSpec_FieldSubPathArrayOfValues)(nil)

func (fpsaov *AlertingConditionSpec_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *AlertingConditionSpec_FieldSubPathArrayOfValues) AsTimeSeriesPathArrayOfValues() (AlertingConditionSpecTimeSeries_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(AlertingConditionSpecTimeSeries_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *AlertingConditionSpec_FieldSubPathArrayOfValues) AsTriggerPathArrayOfValues() (AlertingConditionSpecTrigger_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(AlertingConditionSpecTrigger_FieldPathArrayOfValues)
	return res, ok
}

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

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

type AlertingConditionState_FieldPathSelector int32

const (
	AlertingConditionState_FieldPathSelectorFiringAlertsCount AlertingConditionState_FieldPathSelector = 0
)

func (s AlertingConditionState_FieldPathSelector) String() string {
	switch s {
	case AlertingConditionState_FieldPathSelectorFiringAlertsCount:
		return "firing_alerts_count"
	default:
		panic(fmt.Sprintf("Invalid selector for AlertingCondition_State: %d", s))
	}
}

func BuildAlertingConditionState_FieldPath(fp gotenobject.RawFieldPath) (AlertingConditionState_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object AlertingCondition_State")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "firing_alerts_count", "firingAlertsCount", "firing-alerts-count":
			return &AlertingConditionState_FieldTerminalPath{selector: AlertingConditionState_FieldPathSelectorFiringAlertsCount}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object AlertingCondition_State", fp)
}

func ParseAlertingConditionState_FieldPath(rawField string) (AlertingConditionState_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildAlertingConditionState_FieldPath(fp)
}

func MustParseAlertingConditionState_FieldPath(rawField string) AlertingConditionState_FieldPath {
	fp, err := ParseAlertingConditionState_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type AlertingConditionState_FieldTerminalPath struct {
	selector AlertingConditionState_FieldPathSelector
}

var _ AlertingConditionState_FieldPath = (*AlertingConditionState_FieldTerminalPath)(nil)

func (fp *AlertingConditionState_FieldTerminalPath) Selector() AlertingConditionState_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

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

func (fp *AlertingConditionState_FieldTerminalPath) ClearValue(item *AlertingCondition_State) {
	if item != nil {
		switch fp.selector {
		case AlertingConditionState_FieldPathSelectorFiringAlertsCount:
			item.FiringAlertsCount = int64(0)
		default:
			panic(fmt.Sprintf("Invalid selector for AlertingCondition_State: %d", fp.selector))
		}
	}
}

func (fp *AlertingConditionState_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*AlertingCondition_State))
}

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

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

func (fp *AlertingConditionState_FieldTerminalPath) WithIValue(value interface{}) AlertingConditionState_FieldPathValue {
	switch fp.selector {
	case AlertingConditionState_FieldPathSelectorFiringAlertsCount:
		return &AlertingConditionState_FieldTerminalPathValue{AlertingConditionState_FieldTerminalPath: *fp, value: value.(int64)}
	default:
		panic(fmt.Sprintf("Invalid selector for AlertingCondition_State: %d", fp.selector))
	}
}

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

func (fp *AlertingConditionState_FieldTerminalPath) WithIArrayOfValues(values interface{}) AlertingConditionState_FieldPathArrayOfValues {
	fpaov := &AlertingConditionState_FieldTerminalPathArrayOfValues{AlertingConditionState_FieldTerminalPath: *fp}
	switch fp.selector {
	case AlertingConditionState_FieldPathSelectorFiringAlertsCount:
		return &AlertingConditionState_FieldTerminalPathArrayOfValues{AlertingConditionState_FieldTerminalPath: *fp, values: values.([]int64)}
	default:
		panic(fmt.Sprintf("Invalid selector for AlertingCondition_State: %d", fp.selector))
	}
	return fpaov
}

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

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

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

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

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

func MustParseAlertingConditionState_FieldPathValue(pathStr, valueStr string) AlertingConditionState_FieldPathValue {
	fpv, err := ParseAlertingConditionState_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type AlertingConditionState_FieldTerminalPathValue struct {
	AlertingConditionState_FieldTerminalPath
	value interface{}
}

var _ AlertingConditionState_FieldPathValue = (*AlertingConditionState_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'State' as interface{}
func (fpv *AlertingConditionState_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *AlertingConditionState_FieldTerminalPathValue) AsFiringAlertsCountValue() (int64, bool) {
	res, ok := fpv.value.(int64)
	return res, ok
}

// SetTo stores value for selected field for object State
func (fpv *AlertingConditionState_FieldTerminalPathValue) SetTo(target **AlertingCondition_State) {
	if *target == nil {
		*target = new(AlertingCondition_State)
	}
	switch fpv.selector {
	case AlertingConditionState_FieldPathSelectorFiringAlertsCount:
		(*target).FiringAlertsCount = fpv.value.(int64)
	default:
		panic(fmt.Sprintf("Invalid selector for AlertingCondition_State: %d", fpv.selector))
	}
}

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

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

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

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

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

func MustParseAlertingConditionState_FieldPathArrayItemValue(pathStr, valueStr string) AlertingConditionState_FieldPathArrayItemValue {
	fpaiv, err := ParseAlertingConditionState_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type AlertingConditionState_FieldTerminalPathArrayItemValue struct {
	AlertingConditionState_FieldTerminalPath
	value interface{}
}

var _ AlertingConditionState_FieldPathArrayItemValue = (*AlertingConditionState_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *AlertingConditionState_FieldTerminalPathArrayItemValue) GetSingle(source *AlertingCondition_State) (interface{}, bool) {
	return nil, false
}

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

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

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

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

func MustParseAlertingConditionState_FieldPathArrayOfValues(pathStr, valuesStr string) AlertingConditionState_FieldPathArrayOfValues {
	fpaov, err := ParseAlertingConditionState_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type AlertingConditionState_FieldTerminalPathArrayOfValues struct {
	AlertingConditionState_FieldTerminalPath
	values interface{}
}

var _ AlertingConditionState_FieldPathArrayOfValues = (*AlertingConditionState_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *AlertingConditionState_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case AlertingConditionState_FieldPathSelectorFiringAlertsCount:
		for _, v := range fpaov.values.([]int64) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *AlertingConditionState_FieldTerminalPathArrayOfValues) AsFiringAlertsCountArrayOfValues() ([]int64, bool) {
	res, ok := fpaov.values.([]int64)
	return res, ok
}

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

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

type AlertingConditionSpecTimeSeries_FieldPathSelector int32

const (
	AlertingConditionSpecTimeSeries_FieldPathSelectorQuery            AlertingConditionSpecTimeSeries_FieldPathSelector = 0
	AlertingConditionSpecTimeSeries_FieldPathSelectorThreshold        AlertingConditionSpecTimeSeries_FieldPathSelector = 1
	AlertingConditionSpecTimeSeries_FieldPathSelectorCombineThreshold AlertingConditionSpecTimeSeries_FieldPathSelector = 2
	AlertingConditionSpecTimeSeries_FieldPathSelectorDuration         AlertingConditionSpecTimeSeries_FieldPathSelector = 3
)

func (s AlertingConditionSpecTimeSeries_FieldPathSelector) String() string {
	switch s {
	case AlertingConditionSpecTimeSeries_FieldPathSelectorQuery:
		return "query"
	case AlertingConditionSpecTimeSeries_FieldPathSelectorThreshold:
		return "threshold"
	case AlertingConditionSpecTimeSeries_FieldPathSelectorCombineThreshold:
		return "combine_threshold"
	case AlertingConditionSpecTimeSeries_FieldPathSelectorDuration:
		return "duration"
	default:
		panic(fmt.Sprintf("Invalid selector for AlertingCondition_Spec_TimeSeries: %d", s))
	}
}

func BuildAlertingConditionSpecTimeSeries_FieldPath(fp gotenobject.RawFieldPath) (AlertingConditionSpecTimeSeries_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object AlertingCondition_Spec_TimeSeries")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "query":
			return &AlertingConditionSpecTimeSeries_FieldTerminalPath{selector: AlertingConditionSpecTimeSeries_FieldPathSelectorQuery}, nil
		case "threshold":
			return &AlertingConditionSpecTimeSeries_FieldTerminalPath{selector: AlertingConditionSpecTimeSeries_FieldPathSelectorThreshold}, nil
		case "combine_threshold", "combineThreshold", "combine-threshold":
			return &AlertingConditionSpecTimeSeries_FieldTerminalPath{selector: AlertingConditionSpecTimeSeries_FieldPathSelectorCombineThreshold}, nil
		case "duration":
			return &AlertingConditionSpecTimeSeries_FieldTerminalPath{selector: AlertingConditionSpecTimeSeries_FieldPathSelectorDuration}, nil
		}
	} else {
		switch fp[0] {
		case "query":
			if subpath, err := BuildAlertingConditionSpecTimeSeriesQuery_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &AlertingConditionSpecTimeSeries_FieldSubPath{selector: AlertingConditionSpecTimeSeries_FieldPathSelectorQuery, subPath: subpath}, nil
			}
		case "threshold":
			if subpath, err := BuildAlertingConditionSpecTimeSeriesThreshold_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &AlertingConditionSpecTimeSeries_FieldSubPath{selector: AlertingConditionSpecTimeSeries_FieldPathSelectorThreshold, subPath: subpath}, nil
			}
		case "combine_threshold", "combineThreshold", "combine-threshold":
			if subpath, err := BuildAlertingConditionSpecTimeSeriesCombineThreshold_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &AlertingConditionSpecTimeSeries_FieldSubPath{selector: AlertingConditionSpecTimeSeries_FieldPathSelectorCombineThreshold, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object AlertingCondition_Spec_TimeSeries", fp)
}

func ParseAlertingConditionSpecTimeSeries_FieldPath(rawField string) (AlertingConditionSpecTimeSeries_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildAlertingConditionSpecTimeSeries_FieldPath(fp)
}

func MustParseAlertingConditionSpecTimeSeries_FieldPath(rawField string) AlertingConditionSpecTimeSeries_FieldPath {
	fp, err := ParseAlertingConditionSpecTimeSeries_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type AlertingConditionSpecTimeSeries_FieldTerminalPath struct {
	selector AlertingConditionSpecTimeSeries_FieldPathSelector
}

var _ AlertingConditionSpecTimeSeries_FieldPath = (*AlertingConditionSpecTimeSeries_FieldTerminalPath)(nil)

func (fp *AlertingConditionSpecTimeSeries_FieldTerminalPath) Selector() AlertingConditionSpecTimeSeries_FieldPathSelector {
	return fp.selector
}

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

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

// Get returns all values pointed by specific field from source AlertingCondition_Spec_TimeSeries
func (fp *AlertingConditionSpecTimeSeries_FieldTerminalPath) Get(source *AlertingCondition_Spec_TimeSeries) (values []interface{}) {
	if source != nil {
		switch fp.selector {
		case AlertingConditionSpecTimeSeries_FieldPathSelectorQuery:
			if source.Query != nil {
				values = append(values, source.Query)
			}
		case AlertingConditionSpecTimeSeries_FieldPathSelectorThreshold:
			if source.Threshold != nil {
				values = append(values, source.Threshold)
			}
		case AlertingConditionSpecTimeSeries_FieldPathSelectorCombineThreshold:
			if source.CombineThreshold != nil {
				values = append(values, source.CombineThreshold)
			}
		case AlertingConditionSpecTimeSeries_FieldPathSelectorDuration:
			if source.Duration != nil {
				values = append(values, source.Duration)
			}
		default:
			panic(fmt.Sprintf("Invalid selector for AlertingCondition_Spec_TimeSeries: %d", fp.selector))
		}
	}
	return
}

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

// GetSingle returns value pointed by specific field of from source AlertingCondition_Spec_TimeSeries
func (fp *AlertingConditionSpecTimeSeries_FieldTerminalPath) GetSingle(source *AlertingCondition_Spec_TimeSeries) (interface{}, bool) {
	switch fp.selector {
	case AlertingConditionSpecTimeSeries_FieldPathSelectorQuery:
		res := source.GetQuery()
		return res, res != nil
	case AlertingConditionSpecTimeSeries_FieldPathSelectorThreshold:
		res := source.GetThreshold()
		return res, res != nil
	case AlertingConditionSpecTimeSeries_FieldPathSelectorCombineThreshold:
		res := source.GetCombineThreshold()
		return res, res != nil
	case AlertingConditionSpecTimeSeries_FieldPathSelectorDuration:
		res := source.GetDuration()
		return res, res != nil
	default:
		panic(fmt.Sprintf("Invalid selector for AlertingCondition_Spec_TimeSeries: %d", fp.selector))
	}
}

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

// GetDefault returns a default value of the field type
func (fp *AlertingConditionSpecTimeSeries_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case AlertingConditionSpecTimeSeries_FieldPathSelectorQuery:
		return (*AlertingCondition_Spec_TimeSeries_Query)(nil)
	case AlertingConditionSpecTimeSeries_FieldPathSelectorThreshold:
		return (*AlertingCondition_Spec_TimeSeries_Threshold)(nil)
	case AlertingConditionSpecTimeSeries_FieldPathSelectorCombineThreshold:
		return (*AlertingCondition_Spec_TimeSeries_CombineThreshold)(nil)
	case AlertingConditionSpecTimeSeries_FieldPathSelectorDuration:
		return (*durationpb.Duration)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for AlertingCondition_Spec_TimeSeries: %d", fp.selector))
	}
}

func (fp *AlertingConditionSpecTimeSeries_FieldTerminalPath) ClearValue(item *AlertingCondition_Spec_TimeSeries) {
	if item != nil {
		switch fp.selector {
		case AlertingConditionSpecTimeSeries_FieldPathSelectorQuery:
			item.Query = nil
		case AlertingConditionSpecTimeSeries_FieldPathSelectorThreshold:
			item.Threshold = nil
		case AlertingConditionSpecTimeSeries_FieldPathSelectorCombineThreshold:
			item.CombineThreshold = nil
		case AlertingConditionSpecTimeSeries_FieldPathSelectorDuration:
			item.Duration = nil
		default:
			panic(fmt.Sprintf("Invalid selector for AlertingCondition_Spec_TimeSeries: %d", fp.selector))
		}
	}
}

func (fp *AlertingConditionSpecTimeSeries_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*AlertingCondition_Spec_TimeSeries))
}

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

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

func (fp *AlertingConditionSpecTimeSeries_FieldTerminalPath) WithIValue(value interface{}) AlertingConditionSpecTimeSeries_FieldPathValue {
	switch fp.selector {
	case AlertingConditionSpecTimeSeries_FieldPathSelectorQuery:
		return &AlertingConditionSpecTimeSeries_FieldTerminalPathValue{AlertingConditionSpecTimeSeries_FieldTerminalPath: *fp, value: value.(*AlertingCondition_Spec_TimeSeries_Query)}
	case AlertingConditionSpecTimeSeries_FieldPathSelectorThreshold:
		return &AlertingConditionSpecTimeSeries_FieldTerminalPathValue{AlertingConditionSpecTimeSeries_FieldTerminalPath: *fp, value: value.(*AlertingCondition_Spec_TimeSeries_Threshold)}
	case AlertingConditionSpecTimeSeries_FieldPathSelectorCombineThreshold:
		return &AlertingConditionSpecTimeSeries_FieldTerminalPathValue{AlertingConditionSpecTimeSeries_FieldTerminalPath: *fp, value: value.(*AlertingCondition_Spec_TimeSeries_CombineThreshold)}
	case AlertingConditionSpecTimeSeries_FieldPathSelectorDuration:
		return &AlertingConditionSpecTimeSeries_FieldTerminalPathValue{AlertingConditionSpecTimeSeries_FieldTerminalPath: *fp, value: value.(*durationpb.Duration)}
	default:
		panic(fmt.Sprintf("Invalid selector for AlertingCondition_Spec_TimeSeries: %d", fp.selector))
	}
}

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

func (fp *AlertingConditionSpecTimeSeries_FieldTerminalPath) WithIArrayOfValues(values interface{}) AlertingConditionSpecTimeSeries_FieldPathArrayOfValues {
	fpaov := &AlertingConditionSpecTimeSeries_FieldTerminalPathArrayOfValues{AlertingConditionSpecTimeSeries_FieldTerminalPath: *fp}
	switch fp.selector {
	case AlertingConditionSpecTimeSeries_FieldPathSelectorQuery:
		return &AlertingConditionSpecTimeSeries_FieldTerminalPathArrayOfValues{AlertingConditionSpecTimeSeries_FieldTerminalPath: *fp, values: values.([]*AlertingCondition_Spec_TimeSeries_Query)}
	case AlertingConditionSpecTimeSeries_FieldPathSelectorThreshold:
		return &AlertingConditionSpecTimeSeries_FieldTerminalPathArrayOfValues{AlertingConditionSpecTimeSeries_FieldTerminalPath: *fp, values: values.([]*AlertingCondition_Spec_TimeSeries_Threshold)}
	case AlertingConditionSpecTimeSeries_FieldPathSelectorCombineThreshold:
		return &AlertingConditionSpecTimeSeries_FieldTerminalPathArrayOfValues{AlertingConditionSpecTimeSeries_FieldTerminalPath: *fp, values: values.([]*AlertingCondition_Spec_TimeSeries_CombineThreshold)}
	case AlertingConditionSpecTimeSeries_FieldPathSelectorDuration:
		return &AlertingConditionSpecTimeSeries_FieldTerminalPathArrayOfValues{AlertingConditionSpecTimeSeries_FieldTerminalPath: *fp, values: values.([]*durationpb.Duration)}
	default:
		panic(fmt.Sprintf("Invalid selector for AlertingCondition_Spec_TimeSeries: %d", fp.selector))
	}
	return fpaov
}

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

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

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

type AlertingConditionSpecTimeSeries_FieldSubPath struct {
	selector AlertingConditionSpecTimeSeries_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ AlertingConditionSpecTimeSeries_FieldPath = (*AlertingConditionSpecTimeSeries_FieldSubPath)(nil)

func (fps *AlertingConditionSpecTimeSeries_FieldSubPath) Selector() AlertingConditionSpecTimeSeries_FieldPathSelector {
	return fps.selector
}
func (fps *AlertingConditionSpecTimeSeries_FieldSubPath) AsQuerySubPath() (AlertingConditionSpecTimeSeriesQuery_FieldPath, bool) {
	res, ok := fps.subPath.(AlertingConditionSpecTimeSeriesQuery_FieldPath)
	return res, ok
}
func (fps *AlertingConditionSpecTimeSeries_FieldSubPath) AsThresholdSubPath() (AlertingConditionSpecTimeSeriesThreshold_FieldPath, bool) {
	res, ok := fps.subPath.(AlertingConditionSpecTimeSeriesThreshold_FieldPath)
	return res, ok
}
func (fps *AlertingConditionSpecTimeSeries_FieldSubPath) AsCombineThresholdSubPath() (AlertingConditionSpecTimeSeriesCombineThreshold_FieldPath, bool) {
	res, ok := fps.subPath.(AlertingConditionSpecTimeSeriesCombineThreshold_FieldPath)
	return res, ok
}

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

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

// Get returns all values pointed by selected field from source AlertingCondition_Spec_TimeSeries
func (fps *AlertingConditionSpecTimeSeries_FieldSubPath) Get(source *AlertingCondition_Spec_TimeSeries) (values []interface{}) {
	switch fps.selector {
	case AlertingConditionSpecTimeSeries_FieldPathSelectorQuery:
		values = append(values, fps.subPath.GetRaw(source.GetQuery())...)
	case AlertingConditionSpecTimeSeries_FieldPathSelectorThreshold:
		values = append(values, fps.subPath.GetRaw(source.GetThreshold())...)
	case AlertingConditionSpecTimeSeries_FieldPathSelectorCombineThreshold:
		values = append(values, fps.subPath.GetRaw(source.GetCombineThreshold())...)
	default:
		panic(fmt.Sprintf("Invalid selector for AlertingCondition_Spec_TimeSeries: %d", fps.selector))
	}
	return
}

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

// GetSingle returns value of selected field from source AlertingCondition_Spec_TimeSeries
func (fps *AlertingConditionSpecTimeSeries_FieldSubPath) GetSingle(source *AlertingCondition_Spec_TimeSeries) (interface{}, bool) {
	switch fps.selector {
	case AlertingConditionSpecTimeSeries_FieldPathSelectorQuery:
		if source.GetQuery() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetQuery())
	case AlertingConditionSpecTimeSeries_FieldPathSelectorThreshold:
		if source.GetThreshold() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetThreshold())
	case AlertingConditionSpecTimeSeries_FieldPathSelectorCombineThreshold:
		if source.GetCombineThreshold() == nil {
			return nil, false
		}
		return fps.subPath.GetSingleRaw(source.GetCombineThreshold())
	default:
		panic(fmt.Sprintf("Invalid selector for AlertingCondition_Spec_TimeSeries: %d", fps.selector))
	}
}

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

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

func (fps *AlertingConditionSpecTimeSeries_FieldSubPath) ClearValue(item *AlertingCondition_Spec_TimeSeries) {
	if item != nil {
		switch fps.selector {
		case AlertingConditionSpecTimeSeries_FieldPathSelectorQuery:
			fps.subPath.ClearValueRaw(item.Query)
		case AlertingConditionSpecTimeSeries_FieldPathSelectorThreshold:
			fps.subPath.ClearValueRaw(item.Threshold)
		case AlertingConditionSpecTimeSeries_FieldPathSelectorCombineThreshold:
			fps.subPath.ClearValueRaw(item.CombineThreshold)
		default:
			panic(fmt.Sprintf("Invalid selector for AlertingCondition_Spec_TimeSeries: %d", fps.selector))
		}
	}
}

func (fps *AlertingConditionSpecTimeSeries_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*AlertingCondition_Spec_TimeSeries))
}

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

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

func (fps *AlertingConditionSpecTimeSeries_FieldSubPath) WithIValue(value interface{}) AlertingConditionSpecTimeSeries_FieldPathValue {
	return &AlertingConditionSpecTimeSeries_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *AlertingConditionSpecTimeSeries_FieldSubPath) WithIArrayOfValues(values interface{}) AlertingConditionSpecTimeSeries_FieldPathArrayOfValues {
	return &AlertingConditionSpecTimeSeries_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *AlertingConditionSpecTimeSeries_FieldSubPath) WithIArrayItemValue(value interface{}) AlertingConditionSpecTimeSeries_FieldPathArrayItemValue {
	return &AlertingConditionSpecTimeSeries_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

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

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

func MustParseAlertingConditionSpecTimeSeries_FieldPathValue(pathStr, valueStr string) AlertingConditionSpecTimeSeries_FieldPathValue {
	fpv, err := ParseAlertingConditionSpecTimeSeries_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type AlertingConditionSpecTimeSeries_FieldTerminalPathValue struct {
	AlertingConditionSpecTimeSeries_FieldTerminalPath
	value interface{}
}

var _ AlertingConditionSpecTimeSeries_FieldPathValue = (*AlertingConditionSpecTimeSeries_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'TimeSeries' as interface{}
func (fpv *AlertingConditionSpecTimeSeries_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *AlertingConditionSpecTimeSeries_FieldTerminalPathValue) AsQueryValue() (*AlertingCondition_Spec_TimeSeries_Query, bool) {
	res, ok := fpv.value.(*AlertingCondition_Spec_TimeSeries_Query)
	return res, ok
}
func (fpv *AlertingConditionSpecTimeSeries_FieldTerminalPathValue) AsThresholdValue() (*AlertingCondition_Spec_TimeSeries_Threshold, bool) {
	res, ok := fpv.value.(*AlertingCondition_Spec_TimeSeries_Threshold)
	return res, ok
}
func (fpv *AlertingConditionSpecTimeSeries_FieldTerminalPathValue) AsCombineThresholdValue() (*AlertingCondition_Spec_TimeSeries_CombineThreshold, bool) {
	res, ok := fpv.value.(*AlertingCondition_Spec_TimeSeries_CombineThreshold)
	return res, ok
}
func (fpv *AlertingConditionSpecTimeSeries_FieldTerminalPathValue) AsDurationValue() (*durationpb.Duration, bool) {
	res, ok := fpv.value.(*durationpb.Duration)
	return res, ok
}

// SetTo stores value for selected field for object TimeSeries
func (fpv *AlertingConditionSpecTimeSeries_FieldTerminalPathValue) SetTo(target **AlertingCondition_Spec_TimeSeries) {
	if *target == nil {
		*target = new(AlertingCondition_Spec_TimeSeries)
	}
	switch fpv.selector {
	case AlertingConditionSpecTimeSeries_FieldPathSelectorQuery:
		(*target).Query = fpv.value.(*AlertingCondition_Spec_TimeSeries_Query)
	case AlertingConditionSpecTimeSeries_FieldPathSelectorThreshold:
		(*target).Threshold = fpv.value.(*AlertingCondition_Spec_TimeSeries_Threshold)
	case AlertingConditionSpecTimeSeries_FieldPathSelectorCombineThreshold:
		(*target).CombineThreshold = fpv.value.(*AlertingCondition_Spec_TimeSeries_CombineThreshold)
	case AlertingConditionSpecTimeSeries_FieldPathSelectorDuration:
		(*target).Duration = fpv.value.(*durationpb.Duration)
	default:
		panic(fmt.Sprintf("Invalid selector for AlertingCondition_Spec_TimeSeries: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'AlertingConditionSpecTimeSeries_FieldTerminalPathValue' with the value under path in 'AlertingCondition_Spec_TimeSeries'.
func (fpv *AlertingConditionSpecTimeSeries_FieldTerminalPathValue) CompareWith(source *AlertingCondition_Spec_TimeSeries) (int, bool) {
	switch fpv.selector {
	case AlertingConditionSpecTimeSeries_FieldPathSelectorQuery:
		return 0, false
	case AlertingConditionSpecTimeSeries_FieldPathSelectorThreshold:
		return 0, false
	case AlertingConditionSpecTimeSeries_FieldPathSelectorCombineThreshold:
		return 0, false
	case AlertingConditionSpecTimeSeries_FieldPathSelectorDuration:
		leftValue := fpv.value.(*durationpb.Duration)
		rightValue := source.GetDuration()
		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 AlertingCondition_Spec_TimeSeries: %d", fpv.selector))
	}
}

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

type AlertingConditionSpecTimeSeries_FieldSubPathValue struct {
	AlertingConditionSpecTimeSeries_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ AlertingConditionSpecTimeSeries_FieldPathValue = (*AlertingConditionSpecTimeSeries_FieldSubPathValue)(nil)

func (fpvs *AlertingConditionSpecTimeSeries_FieldSubPathValue) AsQueryPathValue() (AlertingConditionSpecTimeSeriesQuery_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(AlertingConditionSpecTimeSeriesQuery_FieldPathValue)
	return res, ok
}
func (fpvs *AlertingConditionSpecTimeSeries_FieldSubPathValue) AsThresholdPathValue() (AlertingConditionSpecTimeSeriesThreshold_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(AlertingConditionSpecTimeSeriesThreshold_FieldPathValue)
	return res, ok
}
func (fpvs *AlertingConditionSpecTimeSeries_FieldSubPathValue) AsCombineThresholdPathValue() (AlertingConditionSpecTimeSeriesCombineThreshold_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(AlertingConditionSpecTimeSeriesCombineThreshold_FieldPathValue)
	return res, ok
}

func (fpvs *AlertingConditionSpecTimeSeries_FieldSubPathValue) SetTo(target **AlertingCondition_Spec_TimeSeries) {
	if *target == nil {
		*target = new(AlertingCondition_Spec_TimeSeries)
	}
	switch fpvs.Selector() {
	case AlertingConditionSpecTimeSeries_FieldPathSelectorQuery:
		fpvs.subPathValue.(AlertingConditionSpecTimeSeriesQuery_FieldPathValue).SetTo(&(*target).Query)
	case AlertingConditionSpecTimeSeries_FieldPathSelectorThreshold:
		fpvs.subPathValue.(AlertingConditionSpecTimeSeriesThreshold_FieldPathValue).SetTo(&(*target).Threshold)
	case AlertingConditionSpecTimeSeries_FieldPathSelectorCombineThreshold:
		fpvs.subPathValue.(AlertingConditionSpecTimeSeriesCombineThreshold_FieldPathValue).SetTo(&(*target).CombineThreshold)
	default:
		panic(fmt.Sprintf("Invalid selector for AlertingCondition_Spec_TimeSeries: %d", fpvs.Selector()))
	}
}

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

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

func (fpvs *AlertingConditionSpecTimeSeries_FieldSubPathValue) CompareWith(source *AlertingCondition_Spec_TimeSeries) (int, bool) {
	switch fpvs.Selector() {
	case AlertingConditionSpecTimeSeries_FieldPathSelectorQuery:
		return fpvs.subPathValue.(AlertingConditionSpecTimeSeriesQuery_FieldPathValue).CompareWith(source.GetQuery())
	case AlertingConditionSpecTimeSeries_FieldPathSelectorThreshold:
		return fpvs.subPathValue.(AlertingConditionSpecTimeSeriesThreshold_FieldPathValue).CompareWith(source.GetThreshold())
	case AlertingConditionSpecTimeSeries_FieldPathSelectorCombineThreshold:
		return fpvs.subPathValue.(AlertingConditionSpecTimeSeriesCombineThreshold_FieldPathValue).CompareWith(source.GetCombineThreshold())
	default:
		panic(fmt.Sprintf("Invalid selector for AlertingCondition_Spec_TimeSeries: %d", fpvs.Selector()))
	}
}

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

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

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

func MustParseAlertingConditionSpecTimeSeries_FieldPathArrayItemValue(pathStr, valueStr string) AlertingConditionSpecTimeSeries_FieldPathArrayItemValue {
	fpaiv, err := ParseAlertingConditionSpecTimeSeries_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type AlertingConditionSpecTimeSeries_FieldTerminalPathArrayItemValue struct {
	AlertingConditionSpecTimeSeries_FieldTerminalPath
	value interface{}
}

var _ AlertingConditionSpecTimeSeries_FieldPathArrayItemValue = (*AlertingConditionSpecTimeSeries_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *AlertingConditionSpecTimeSeries_FieldTerminalPathArrayItemValue) GetSingle(source *AlertingCondition_Spec_TimeSeries) (interface{}, bool) {
	return nil, false
}

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

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

// GetRawValue returns stored array item value
func (fpaivs *AlertingConditionSpecTimeSeries_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *AlertingConditionSpecTimeSeries_FieldSubPathArrayItemValue) AsQueryPathItemValue() (AlertingConditionSpecTimeSeriesQuery_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(AlertingConditionSpecTimeSeriesQuery_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *AlertingConditionSpecTimeSeries_FieldSubPathArrayItemValue) AsThresholdPathItemValue() (AlertingConditionSpecTimeSeriesThreshold_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(AlertingConditionSpecTimeSeriesThreshold_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *AlertingConditionSpecTimeSeries_FieldSubPathArrayItemValue) AsCombineThresholdPathItemValue() (AlertingConditionSpecTimeSeriesCombineThreshold_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(AlertingConditionSpecTimeSeriesCombineThreshold_FieldPathArrayItemValue)
	return res, ok
}

// Contains returns a boolean indicating if value that is being held is present in given 'TimeSeries'
func (fpaivs *AlertingConditionSpecTimeSeries_FieldSubPathArrayItemValue) ContainsValue(source *AlertingCondition_Spec_TimeSeries) bool {
	switch fpaivs.Selector() {
	case AlertingConditionSpecTimeSeries_FieldPathSelectorQuery:
		return fpaivs.subPathItemValue.(AlertingConditionSpecTimeSeriesQuery_FieldPathArrayItemValue).ContainsValue(source.GetQuery())
	case AlertingConditionSpecTimeSeries_FieldPathSelectorThreshold:
		return fpaivs.subPathItemValue.(AlertingConditionSpecTimeSeriesThreshold_FieldPathArrayItemValue).ContainsValue(source.GetThreshold())
	case AlertingConditionSpecTimeSeries_FieldPathSelectorCombineThreshold:
		return fpaivs.subPathItemValue.(AlertingConditionSpecTimeSeriesCombineThreshold_FieldPathArrayItemValue).ContainsValue(source.GetCombineThreshold())
	default:
		panic(fmt.Sprintf("Invalid selector for AlertingCondition_Spec_TimeSeries: %d", fpaivs.Selector()))
	}
}

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

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

func MustParseAlertingConditionSpecTimeSeries_FieldPathArrayOfValues(pathStr, valuesStr string) AlertingConditionSpecTimeSeries_FieldPathArrayOfValues {
	fpaov, err := ParseAlertingConditionSpecTimeSeries_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type AlertingConditionSpecTimeSeries_FieldTerminalPathArrayOfValues struct {
	AlertingConditionSpecTimeSeries_FieldTerminalPath
	values interface{}
}

var _ AlertingConditionSpecTimeSeries_FieldPathArrayOfValues = (*AlertingConditionSpecTimeSeries_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *AlertingConditionSpecTimeSeries_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case AlertingConditionSpecTimeSeries_FieldPathSelectorQuery:
		for _, v := range fpaov.values.([]*AlertingCondition_Spec_TimeSeries_Query) {
			values = append(values, v)
		}
	case AlertingConditionSpecTimeSeries_FieldPathSelectorThreshold:
		for _, v := range fpaov.values.([]*AlertingCondition_Spec_TimeSeries_Threshold) {
			values = append(values, v)
		}
	case AlertingConditionSpecTimeSeries_FieldPathSelectorCombineThreshold:
		for _, v := range fpaov.values.([]*AlertingCondition_Spec_TimeSeries_CombineThreshold) {
			values = append(values, v)
		}
	case AlertingConditionSpecTimeSeries_FieldPathSelectorDuration:
		for _, v := range fpaov.values.([]*durationpb.Duration) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *AlertingConditionSpecTimeSeries_FieldTerminalPathArrayOfValues) AsQueryArrayOfValues() ([]*AlertingCondition_Spec_TimeSeries_Query, bool) {
	res, ok := fpaov.values.([]*AlertingCondition_Spec_TimeSeries_Query)
	return res, ok
}
func (fpaov *AlertingConditionSpecTimeSeries_FieldTerminalPathArrayOfValues) AsThresholdArrayOfValues() ([]*AlertingCondition_Spec_TimeSeries_Threshold, bool) {
	res, ok := fpaov.values.([]*AlertingCondition_Spec_TimeSeries_Threshold)
	return res, ok
}
func (fpaov *AlertingConditionSpecTimeSeries_FieldTerminalPathArrayOfValues) AsCombineThresholdArrayOfValues() ([]*AlertingCondition_Spec_TimeSeries_CombineThreshold, bool) {
	res, ok := fpaov.values.([]*AlertingCondition_Spec_TimeSeries_CombineThreshold)
	return res, ok
}
func (fpaov *AlertingConditionSpecTimeSeries_FieldTerminalPathArrayOfValues) AsDurationArrayOfValues() ([]*durationpb.Duration, bool) {
	res, ok := fpaov.values.([]*durationpb.Duration)
	return res, ok
}

type AlertingConditionSpecTimeSeries_FieldSubPathArrayOfValues struct {
	AlertingConditionSpecTimeSeries_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ AlertingConditionSpecTimeSeries_FieldPathArrayOfValues = (*AlertingConditionSpecTimeSeries_FieldSubPathArrayOfValues)(nil)

func (fpsaov *AlertingConditionSpecTimeSeries_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *AlertingConditionSpecTimeSeries_FieldSubPathArrayOfValues) AsQueryPathArrayOfValues() (AlertingConditionSpecTimeSeriesQuery_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(AlertingConditionSpecTimeSeriesQuery_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *AlertingConditionSpecTimeSeries_FieldSubPathArrayOfValues) AsThresholdPathArrayOfValues() (AlertingConditionSpecTimeSeriesThreshold_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(AlertingConditionSpecTimeSeriesThreshold_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *AlertingConditionSpecTimeSeries_FieldSubPathArrayOfValues) AsCombineThresholdPathArrayOfValues() (AlertingConditionSpecTimeSeriesCombineThreshold_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(AlertingConditionSpecTimeSeriesCombineThreshold_FieldPathArrayOfValues)
	return res, ok
}

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

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

type AlertingConditionSpecTrigger_FieldPathSelector int32

const (
	AlertingConditionSpecTrigger_FieldPathSelectorType AlertingConditionSpecTrigger_FieldPathSelector = 0
)

func (s AlertingConditionSpecTrigger_FieldPathSelector) String() string {
	switch s {
	case AlertingConditionSpecTrigger_FieldPathSelectorType:
		return "type"
	default:
		panic(fmt.Sprintf("Invalid selector for AlertingCondition_Spec_Trigger: %d", s))
	}
}

func BuildAlertingConditionSpecTrigger_FieldPath(fp gotenobject.RawFieldPath) (AlertingConditionSpecTrigger_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object AlertingCondition_Spec_Trigger")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "type":
			return &AlertingConditionSpecTrigger_FieldTerminalPath{selector: AlertingConditionSpecTrigger_FieldPathSelectorType}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object AlertingCondition_Spec_Trigger", fp)
}

func ParseAlertingConditionSpecTrigger_FieldPath(rawField string) (AlertingConditionSpecTrigger_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildAlertingConditionSpecTrigger_FieldPath(fp)
}

func MustParseAlertingConditionSpecTrigger_FieldPath(rawField string) AlertingConditionSpecTrigger_FieldPath {
	fp, err := ParseAlertingConditionSpecTrigger_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type AlertingConditionSpecTrigger_FieldTerminalPath struct {
	selector AlertingConditionSpecTrigger_FieldPathSelector
}

var _ AlertingConditionSpecTrigger_FieldPath = (*AlertingConditionSpecTrigger_FieldTerminalPath)(nil)

func (fp *AlertingConditionSpecTrigger_FieldTerminalPath) Selector() AlertingConditionSpecTrigger_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

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

func (fp *AlertingConditionSpecTrigger_FieldTerminalPath) ClearValue(item *AlertingCondition_Spec_Trigger) {
	if item != nil {
		switch fp.selector {
		case AlertingConditionSpecTrigger_FieldPathSelectorType:
			item.Type = AlertingCondition_Spec_Trigger_EACH
		default:
			panic(fmt.Sprintf("Invalid selector for AlertingCondition_Spec_Trigger: %d", fp.selector))
		}
	}
}

func (fp *AlertingConditionSpecTrigger_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*AlertingCondition_Spec_Trigger))
}

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

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

func (fp *AlertingConditionSpecTrigger_FieldTerminalPath) WithIValue(value interface{}) AlertingConditionSpecTrigger_FieldPathValue {
	switch fp.selector {
	case AlertingConditionSpecTrigger_FieldPathSelectorType:
		return &AlertingConditionSpecTrigger_FieldTerminalPathValue{AlertingConditionSpecTrigger_FieldTerminalPath: *fp, value: value.(AlertingCondition_Spec_Trigger_Type)}
	default:
		panic(fmt.Sprintf("Invalid selector for AlertingCondition_Spec_Trigger: %d", fp.selector))
	}
}

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

func (fp *AlertingConditionSpecTrigger_FieldTerminalPath) WithIArrayOfValues(values interface{}) AlertingConditionSpecTrigger_FieldPathArrayOfValues {
	fpaov := &AlertingConditionSpecTrigger_FieldTerminalPathArrayOfValues{AlertingConditionSpecTrigger_FieldTerminalPath: *fp}
	switch fp.selector {
	case AlertingConditionSpecTrigger_FieldPathSelectorType:
		return &AlertingConditionSpecTrigger_FieldTerminalPathArrayOfValues{AlertingConditionSpecTrigger_FieldTerminalPath: *fp, values: values.([]AlertingCondition_Spec_Trigger_Type)}
	default:
		panic(fmt.Sprintf("Invalid selector for AlertingCondition_Spec_Trigger: %d", fp.selector))
	}
	return fpaov
}

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

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

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

// AlertingConditionSpecTrigger_FieldPathValue allows storing values for Trigger fields according to their type
type AlertingConditionSpecTrigger_FieldPathValue interface {
	AlertingConditionSpecTrigger_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **AlertingCondition_Spec_Trigger)
	CompareWith(*AlertingCondition_Spec_Trigger) (cmp int, comparable bool)
}

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

func MustParseAlertingConditionSpecTrigger_FieldPathValue(pathStr, valueStr string) AlertingConditionSpecTrigger_FieldPathValue {
	fpv, err := ParseAlertingConditionSpecTrigger_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type AlertingConditionSpecTrigger_FieldTerminalPathValue struct {
	AlertingConditionSpecTrigger_FieldTerminalPath
	value interface{}
}

var _ AlertingConditionSpecTrigger_FieldPathValue = (*AlertingConditionSpecTrigger_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'Trigger' as interface{}
func (fpv *AlertingConditionSpecTrigger_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *AlertingConditionSpecTrigger_FieldTerminalPathValue) AsTypeValue() (AlertingCondition_Spec_Trigger_Type, bool) {
	res, ok := fpv.value.(AlertingCondition_Spec_Trigger_Type)
	return res, ok
}

// SetTo stores value for selected field for object Trigger
func (fpv *AlertingConditionSpecTrigger_FieldTerminalPathValue) SetTo(target **AlertingCondition_Spec_Trigger) {
	if *target == nil {
		*target = new(AlertingCondition_Spec_Trigger)
	}
	switch fpv.selector {
	case AlertingConditionSpecTrigger_FieldPathSelectorType:
		(*target).Type = fpv.value.(AlertingCondition_Spec_Trigger_Type)
	default:
		panic(fmt.Sprintf("Invalid selector for AlertingCondition_Spec_Trigger: %d", fpv.selector))
	}
}

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

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

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

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

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

func MustParseAlertingConditionSpecTrigger_FieldPathArrayItemValue(pathStr, valueStr string) AlertingConditionSpecTrigger_FieldPathArrayItemValue {
	fpaiv, err := ParseAlertingConditionSpecTrigger_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type AlertingConditionSpecTrigger_FieldTerminalPathArrayItemValue struct {
	AlertingConditionSpecTrigger_FieldTerminalPath
	value interface{}
}

var _ AlertingConditionSpecTrigger_FieldPathArrayItemValue = (*AlertingConditionSpecTrigger_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *AlertingConditionSpecTrigger_FieldTerminalPathArrayItemValue) GetSingle(source *AlertingCondition_Spec_Trigger) (interface{}, bool) {
	return nil, false
}

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

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

// AlertingConditionSpecTrigger_FieldPathArrayOfValues allows storing slice of values for Trigger fields according to their type
type AlertingConditionSpecTrigger_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	AlertingConditionSpecTrigger_FieldPath
}

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

func MustParseAlertingConditionSpecTrigger_FieldPathArrayOfValues(pathStr, valuesStr string) AlertingConditionSpecTrigger_FieldPathArrayOfValues {
	fpaov, err := ParseAlertingConditionSpecTrigger_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type AlertingConditionSpecTrigger_FieldTerminalPathArrayOfValues struct {
	AlertingConditionSpecTrigger_FieldTerminalPath
	values interface{}
}

var _ AlertingConditionSpecTrigger_FieldPathArrayOfValues = (*AlertingConditionSpecTrigger_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *AlertingConditionSpecTrigger_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case AlertingConditionSpecTrigger_FieldPathSelectorType:
		for _, v := range fpaov.values.([]AlertingCondition_Spec_Trigger_Type) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *AlertingConditionSpecTrigger_FieldTerminalPathArrayOfValues) AsTypeArrayOfValues() ([]AlertingCondition_Spec_Trigger_Type, bool) {
	res, ok := fpaov.values.([]AlertingCondition_Spec_Trigger_Type)
	return res, ok
}

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

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

type AlertingConditionSpecTimeSeriesQuery_FieldPathSelector int32

const (
	AlertingConditionSpecTimeSeriesQuery_FieldPathSelectorSelector    AlertingConditionSpecTimeSeriesQuery_FieldPathSelector = 0
	AlertingConditionSpecTimeSeriesQuery_FieldPathSelectorAggregation AlertingConditionSpecTimeSeriesQuery_FieldPathSelector = 1
)

func (s AlertingConditionSpecTimeSeriesQuery_FieldPathSelector) String() string {
	switch s {
	case AlertingConditionSpecTimeSeriesQuery_FieldPathSelectorSelector:
		return "selector"
	case AlertingConditionSpecTimeSeriesQuery_FieldPathSelectorAggregation:
		return "aggregation"
	default:
		panic(fmt.Sprintf("Invalid selector for AlertingCondition_Spec_TimeSeries_Query: %d", s))
	}
}

func BuildAlertingConditionSpecTimeSeriesQuery_FieldPath(fp gotenobject.RawFieldPath) (AlertingConditionSpecTimeSeriesQuery_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object AlertingCondition_Spec_TimeSeries_Query")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "selector":
			return &AlertingConditionSpecTimeSeriesQuery_FieldTerminalPath{selector: AlertingConditionSpecTimeSeriesQuery_FieldPathSelectorSelector}, nil
		case "aggregation":
			return &AlertingConditionSpecTimeSeriesQuery_FieldTerminalPath{selector: AlertingConditionSpecTimeSeriesQuery_FieldPathSelectorAggregation}, nil
		}
	} else {
		switch fp[0] {
		case "selector":
			if subpath, err := common.BuildTimeSeriesSelector_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &AlertingConditionSpecTimeSeriesQuery_FieldSubPath{selector: AlertingConditionSpecTimeSeriesQuery_FieldPathSelectorSelector, subPath: subpath}, nil
			}
		case "aggregation":
			if subpath, err := common.BuildAggregation_FieldPath(fp[1:]); err != nil {
				return nil, err
			} else {
				return &AlertingConditionSpecTimeSeriesQuery_FieldSubPath{selector: AlertingConditionSpecTimeSeriesQuery_FieldPathSelectorAggregation, subPath: subpath}, nil
			}
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object AlertingCondition_Spec_TimeSeries_Query", fp)
}

func ParseAlertingConditionSpecTimeSeriesQuery_FieldPath(rawField string) (AlertingConditionSpecTimeSeriesQuery_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildAlertingConditionSpecTimeSeriesQuery_FieldPath(fp)
}

func MustParseAlertingConditionSpecTimeSeriesQuery_FieldPath(rawField string) AlertingConditionSpecTimeSeriesQuery_FieldPath {
	fp, err := ParseAlertingConditionSpecTimeSeriesQuery_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type AlertingConditionSpecTimeSeriesQuery_FieldTerminalPath struct {
	selector AlertingConditionSpecTimeSeriesQuery_FieldPathSelector
}

var _ AlertingConditionSpecTimeSeriesQuery_FieldPath = (*AlertingConditionSpecTimeSeriesQuery_FieldTerminalPath)(nil)

func (fp *AlertingConditionSpecTimeSeriesQuery_FieldTerminalPath) Selector() AlertingConditionSpecTimeSeriesQuery_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

// GetDefault returns a default value of the field type
func (fp *AlertingConditionSpecTimeSeriesQuery_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case AlertingConditionSpecTimeSeriesQuery_FieldPathSelectorSelector:
		return (*common.TimeSeriesSelector)(nil)
	case AlertingConditionSpecTimeSeriesQuery_FieldPathSelectorAggregation:
		return (*common.Aggregation)(nil)
	default:
		panic(fmt.Sprintf("Invalid selector for AlertingCondition_Spec_TimeSeries_Query: %d", fp.selector))
	}
}

func (fp *AlertingConditionSpecTimeSeriesQuery_FieldTerminalPath) ClearValue(item *AlertingCondition_Spec_TimeSeries_Query) {
	if item != nil {
		switch fp.selector {
		case AlertingConditionSpecTimeSeriesQuery_FieldPathSelectorSelector:
			item.Selector = nil
		case AlertingConditionSpecTimeSeriesQuery_FieldPathSelectorAggregation:
			item.Aggregation = nil
		default:
			panic(fmt.Sprintf("Invalid selector for AlertingCondition_Spec_TimeSeries_Query: %d", fp.selector))
		}
	}
}

func (fp *AlertingConditionSpecTimeSeriesQuery_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*AlertingCondition_Spec_TimeSeries_Query))
}

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

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

func (fp *AlertingConditionSpecTimeSeriesQuery_FieldTerminalPath) WithIValue(value interface{}) AlertingConditionSpecTimeSeriesQuery_FieldPathValue {
	switch fp.selector {
	case AlertingConditionSpecTimeSeriesQuery_FieldPathSelectorSelector:
		return &AlertingConditionSpecTimeSeriesQuery_FieldTerminalPathValue{AlertingConditionSpecTimeSeriesQuery_FieldTerminalPath: *fp, value: value.(*common.TimeSeriesSelector)}
	case AlertingConditionSpecTimeSeriesQuery_FieldPathSelectorAggregation:
		return &AlertingConditionSpecTimeSeriesQuery_FieldTerminalPathValue{AlertingConditionSpecTimeSeriesQuery_FieldTerminalPath: *fp, value: value.(*common.Aggregation)}
	default:
		panic(fmt.Sprintf("Invalid selector for AlertingCondition_Spec_TimeSeries_Query: %d", fp.selector))
	}
}

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

func (fp *AlertingConditionSpecTimeSeriesQuery_FieldTerminalPath) WithIArrayOfValues(values interface{}) AlertingConditionSpecTimeSeriesQuery_FieldPathArrayOfValues {
	fpaov := &AlertingConditionSpecTimeSeriesQuery_FieldTerminalPathArrayOfValues{AlertingConditionSpecTimeSeriesQuery_FieldTerminalPath: *fp}
	switch fp.selector {
	case AlertingConditionSpecTimeSeriesQuery_FieldPathSelectorSelector:
		return &AlertingConditionSpecTimeSeriesQuery_FieldTerminalPathArrayOfValues{AlertingConditionSpecTimeSeriesQuery_FieldTerminalPath: *fp, values: values.([]*common.TimeSeriesSelector)}
	case AlertingConditionSpecTimeSeriesQuery_FieldPathSelectorAggregation:
		return &AlertingConditionSpecTimeSeriesQuery_FieldTerminalPathArrayOfValues{AlertingConditionSpecTimeSeriesQuery_FieldTerminalPath: *fp, values: values.([]*common.Aggregation)}
	default:
		panic(fmt.Sprintf("Invalid selector for AlertingCondition_Spec_TimeSeries_Query: %d", fp.selector))
	}
	return fpaov
}

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

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

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

type AlertingConditionSpecTimeSeriesQuery_FieldSubPath struct {
	selector AlertingConditionSpecTimeSeriesQuery_FieldPathSelector
	subPath  gotenobject.FieldPath
}

var _ AlertingConditionSpecTimeSeriesQuery_FieldPath = (*AlertingConditionSpecTimeSeriesQuery_FieldSubPath)(nil)

func (fps *AlertingConditionSpecTimeSeriesQuery_FieldSubPath) Selector() AlertingConditionSpecTimeSeriesQuery_FieldPathSelector {
	return fps.selector
}
func (fps *AlertingConditionSpecTimeSeriesQuery_FieldSubPath) AsSelectorSubPath() (common.TimeSeriesSelector_FieldPath, bool) {
	res, ok := fps.subPath.(common.TimeSeriesSelector_FieldPath)
	return res, ok
}
func (fps *AlertingConditionSpecTimeSeriesQuery_FieldSubPath) AsAggregationSubPath() (common.Aggregation_FieldPath, bool) {
	res, ok := fps.subPath.(common.Aggregation_FieldPath)
	return res, ok
}

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

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

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

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

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

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

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

func (fps *AlertingConditionSpecTimeSeriesQuery_FieldSubPath) ClearValue(item *AlertingCondition_Spec_TimeSeries_Query) {
	if item != nil {
		switch fps.selector {
		case AlertingConditionSpecTimeSeriesQuery_FieldPathSelectorSelector:
			fps.subPath.ClearValueRaw(item.Selector)
		case AlertingConditionSpecTimeSeriesQuery_FieldPathSelectorAggregation:
			fps.subPath.ClearValueRaw(item.Aggregation)
		default:
			panic(fmt.Sprintf("Invalid selector for AlertingCondition_Spec_TimeSeries_Query: %d", fps.selector))
		}
	}
}

func (fps *AlertingConditionSpecTimeSeriesQuery_FieldSubPath) ClearValueRaw(item proto.Message) {
	fps.ClearValue(item.(*AlertingCondition_Spec_TimeSeries_Query))
}

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

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

func (fps *AlertingConditionSpecTimeSeriesQuery_FieldSubPath) WithIValue(value interface{}) AlertingConditionSpecTimeSeriesQuery_FieldPathValue {
	return &AlertingConditionSpecTimeSeriesQuery_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
}

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

func (fps *AlertingConditionSpecTimeSeriesQuery_FieldSubPath) WithIArrayOfValues(values interface{}) AlertingConditionSpecTimeSeriesQuery_FieldPathArrayOfValues {
	return &AlertingConditionSpecTimeSeriesQuery_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
}

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

func (fps *AlertingConditionSpecTimeSeriesQuery_FieldSubPath) WithIArrayItemValue(value interface{}) AlertingConditionSpecTimeSeriesQuery_FieldPathArrayItemValue {
	return &AlertingConditionSpecTimeSeriesQuery_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
}

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

// AlertingConditionSpecTimeSeriesQuery_FieldPathValue allows storing values for Query fields according to their type
type AlertingConditionSpecTimeSeriesQuery_FieldPathValue interface {
	AlertingConditionSpecTimeSeriesQuery_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **AlertingCondition_Spec_TimeSeries_Query)
	CompareWith(*AlertingCondition_Spec_TimeSeries_Query) (cmp int, comparable bool)
}

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

func MustParseAlertingConditionSpecTimeSeriesQuery_FieldPathValue(pathStr, valueStr string) AlertingConditionSpecTimeSeriesQuery_FieldPathValue {
	fpv, err := ParseAlertingConditionSpecTimeSeriesQuery_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type AlertingConditionSpecTimeSeriesQuery_FieldTerminalPathValue struct {
	AlertingConditionSpecTimeSeriesQuery_FieldTerminalPath
	value interface{}
}

var _ AlertingConditionSpecTimeSeriesQuery_FieldPathValue = (*AlertingConditionSpecTimeSeriesQuery_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'Query' as interface{}
func (fpv *AlertingConditionSpecTimeSeriesQuery_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *AlertingConditionSpecTimeSeriesQuery_FieldTerminalPathValue) AsSelectorValue() (*common.TimeSeriesSelector, bool) {
	res, ok := fpv.value.(*common.TimeSeriesSelector)
	return res, ok
}
func (fpv *AlertingConditionSpecTimeSeriesQuery_FieldTerminalPathValue) AsAggregationValue() (*common.Aggregation, bool) {
	res, ok := fpv.value.(*common.Aggregation)
	return res, ok
}

// SetTo stores value for selected field for object Query
func (fpv *AlertingConditionSpecTimeSeriesQuery_FieldTerminalPathValue) SetTo(target **AlertingCondition_Spec_TimeSeries_Query) {
	if *target == nil {
		*target = new(AlertingCondition_Spec_TimeSeries_Query)
	}
	switch fpv.selector {
	case AlertingConditionSpecTimeSeriesQuery_FieldPathSelectorSelector:
		(*target).Selector = fpv.value.(*common.TimeSeriesSelector)
	case AlertingConditionSpecTimeSeriesQuery_FieldPathSelectorAggregation:
		(*target).Aggregation = fpv.value.(*common.Aggregation)
	default:
		panic(fmt.Sprintf("Invalid selector for AlertingCondition_Spec_TimeSeries_Query: %d", fpv.selector))
	}
}

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

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

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

type AlertingConditionSpecTimeSeriesQuery_FieldSubPathValue struct {
	AlertingConditionSpecTimeSeriesQuery_FieldPath
	subPathValue gotenobject.FieldPathValue
}

var _ AlertingConditionSpecTimeSeriesQuery_FieldPathValue = (*AlertingConditionSpecTimeSeriesQuery_FieldSubPathValue)(nil)

func (fpvs *AlertingConditionSpecTimeSeriesQuery_FieldSubPathValue) AsSelectorPathValue() (common.TimeSeriesSelector_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(common.TimeSeriesSelector_FieldPathValue)
	return res, ok
}
func (fpvs *AlertingConditionSpecTimeSeriesQuery_FieldSubPathValue) AsAggregationPathValue() (common.Aggregation_FieldPathValue, bool) {
	res, ok := fpvs.subPathValue.(common.Aggregation_FieldPathValue)
	return res, ok
}

func (fpvs *AlertingConditionSpecTimeSeriesQuery_FieldSubPathValue) SetTo(target **AlertingCondition_Spec_TimeSeries_Query) {
	if *target == nil {
		*target = new(AlertingCondition_Spec_TimeSeries_Query)
	}
	switch fpvs.Selector() {
	case AlertingConditionSpecTimeSeriesQuery_FieldPathSelectorSelector:
		fpvs.subPathValue.(common.TimeSeriesSelector_FieldPathValue).SetTo(&(*target).Selector)
	case AlertingConditionSpecTimeSeriesQuery_FieldPathSelectorAggregation:
		fpvs.subPathValue.(common.Aggregation_FieldPathValue).SetTo(&(*target).Aggregation)
	default:
		panic(fmt.Sprintf("Invalid selector for AlertingCondition_Spec_TimeSeries_Query: %d", fpvs.Selector()))
	}
}

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

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

func (fpvs *AlertingConditionSpecTimeSeriesQuery_FieldSubPathValue) CompareWith(source *AlertingCondition_Spec_TimeSeries_Query) (int, bool) {
	switch fpvs.Selector() {
	case AlertingConditionSpecTimeSeriesQuery_FieldPathSelectorSelector:
		return fpvs.subPathValue.(common.TimeSeriesSelector_FieldPathValue).CompareWith(source.GetSelector())
	case AlertingConditionSpecTimeSeriesQuery_FieldPathSelectorAggregation:
		return fpvs.subPathValue.(common.Aggregation_FieldPathValue).CompareWith(source.GetAggregation())
	default:
		panic(fmt.Sprintf("Invalid selector for AlertingCondition_Spec_TimeSeries_Query: %d", fpvs.Selector()))
	}
}

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

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

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

func MustParseAlertingConditionSpecTimeSeriesQuery_FieldPathArrayItemValue(pathStr, valueStr string) AlertingConditionSpecTimeSeriesQuery_FieldPathArrayItemValue {
	fpaiv, err := ParseAlertingConditionSpecTimeSeriesQuery_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type AlertingConditionSpecTimeSeriesQuery_FieldTerminalPathArrayItemValue struct {
	AlertingConditionSpecTimeSeriesQuery_FieldTerminalPath
	value interface{}
}

var _ AlertingConditionSpecTimeSeriesQuery_FieldPathArrayItemValue = (*AlertingConditionSpecTimeSeriesQuery_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *AlertingConditionSpecTimeSeriesQuery_FieldTerminalPathArrayItemValue) GetSingle(source *AlertingCondition_Spec_TimeSeries_Query) (interface{}, bool) {
	return nil, false
}

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

// Contains returns a boolean indicating if value that is being held is present in given 'Query'
func (fpaiv *AlertingConditionSpecTimeSeriesQuery_FieldTerminalPathArrayItemValue) ContainsValue(source *AlertingCondition_Spec_TimeSeries_Query) bool {
	slice := fpaiv.AlertingConditionSpecTimeSeriesQuery_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 AlertingConditionSpecTimeSeriesQuery_FieldSubPathArrayItemValue struct {
	AlertingConditionSpecTimeSeriesQuery_FieldPath
	subPathItemValue gotenobject.FieldPathArrayItemValue
}

// GetRawValue returns stored array item value
func (fpaivs *AlertingConditionSpecTimeSeriesQuery_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
	return fpaivs.subPathItemValue.GetRawItemValue()
}
func (fpaivs *AlertingConditionSpecTimeSeriesQuery_FieldSubPathArrayItemValue) AsSelectorPathItemValue() (common.TimeSeriesSelector_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(common.TimeSeriesSelector_FieldPathArrayItemValue)
	return res, ok
}
func (fpaivs *AlertingConditionSpecTimeSeriesQuery_FieldSubPathArrayItemValue) AsAggregationPathItemValue() (common.Aggregation_FieldPathArrayItemValue, bool) {
	res, ok := fpaivs.subPathItemValue.(common.Aggregation_FieldPathArrayItemValue)
	return res, ok
}

// Contains returns a boolean indicating if value that is being held is present in given 'Query'
func (fpaivs *AlertingConditionSpecTimeSeriesQuery_FieldSubPathArrayItemValue) ContainsValue(source *AlertingCondition_Spec_TimeSeries_Query) bool {
	switch fpaivs.Selector() {
	case AlertingConditionSpecTimeSeriesQuery_FieldPathSelectorSelector:
		return fpaivs.subPathItemValue.(common.TimeSeriesSelector_FieldPathArrayItemValue).ContainsValue(source.GetSelector())
	case AlertingConditionSpecTimeSeriesQuery_FieldPathSelectorAggregation:
		return fpaivs.subPathItemValue.(common.Aggregation_FieldPathArrayItemValue).ContainsValue(source.GetAggregation())
	default:
		panic(fmt.Sprintf("Invalid selector for AlertingCondition_Spec_TimeSeries_Query: %d", fpaivs.Selector()))
	}
}

// AlertingConditionSpecTimeSeriesQuery_FieldPathArrayOfValues allows storing slice of values for Query fields according to their type
type AlertingConditionSpecTimeSeriesQuery_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	AlertingConditionSpecTimeSeriesQuery_FieldPath
}

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

func MustParseAlertingConditionSpecTimeSeriesQuery_FieldPathArrayOfValues(pathStr, valuesStr string) AlertingConditionSpecTimeSeriesQuery_FieldPathArrayOfValues {
	fpaov, err := ParseAlertingConditionSpecTimeSeriesQuery_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type AlertingConditionSpecTimeSeriesQuery_FieldTerminalPathArrayOfValues struct {
	AlertingConditionSpecTimeSeriesQuery_FieldTerminalPath
	values interface{}
}

var _ AlertingConditionSpecTimeSeriesQuery_FieldPathArrayOfValues = (*AlertingConditionSpecTimeSeriesQuery_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *AlertingConditionSpecTimeSeriesQuery_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case AlertingConditionSpecTimeSeriesQuery_FieldPathSelectorSelector:
		for _, v := range fpaov.values.([]*common.TimeSeriesSelector) {
			values = append(values, v)
		}
	case AlertingConditionSpecTimeSeriesQuery_FieldPathSelectorAggregation:
		for _, v := range fpaov.values.([]*common.Aggregation) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *AlertingConditionSpecTimeSeriesQuery_FieldTerminalPathArrayOfValues) AsSelectorArrayOfValues() ([]*common.TimeSeriesSelector, bool) {
	res, ok := fpaov.values.([]*common.TimeSeriesSelector)
	return res, ok
}
func (fpaov *AlertingConditionSpecTimeSeriesQuery_FieldTerminalPathArrayOfValues) AsAggregationArrayOfValues() ([]*common.Aggregation, bool) {
	res, ok := fpaov.values.([]*common.Aggregation)
	return res, ok
}

type AlertingConditionSpecTimeSeriesQuery_FieldSubPathArrayOfValues struct {
	AlertingConditionSpecTimeSeriesQuery_FieldPath
	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
}

var _ AlertingConditionSpecTimeSeriesQuery_FieldPathArrayOfValues = (*AlertingConditionSpecTimeSeriesQuery_FieldSubPathArrayOfValues)(nil)

func (fpsaov *AlertingConditionSpecTimeSeriesQuery_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
	return fpsaov.subPathArrayOfValues.GetRawValues()
}
func (fpsaov *AlertingConditionSpecTimeSeriesQuery_FieldSubPathArrayOfValues) AsSelectorPathArrayOfValues() (common.TimeSeriesSelector_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(common.TimeSeriesSelector_FieldPathArrayOfValues)
	return res, ok
}
func (fpsaov *AlertingConditionSpecTimeSeriesQuery_FieldSubPathArrayOfValues) AsAggregationPathArrayOfValues() (common.Aggregation_FieldPathArrayOfValues, bool) {
	res, ok := fpsaov.subPathArrayOfValues.(common.Aggregation_FieldPathArrayOfValues)
	return res, ok
}

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

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

type AlertingConditionSpecTimeSeriesThreshold_FieldPathSelector int32

const (
	AlertingConditionSpecTimeSeriesThreshold_FieldPathSelectorCompare AlertingConditionSpecTimeSeriesThreshold_FieldPathSelector = 0
	AlertingConditionSpecTimeSeriesThreshold_FieldPathSelectorValue   AlertingConditionSpecTimeSeriesThreshold_FieldPathSelector = 1
)

func (s AlertingConditionSpecTimeSeriesThreshold_FieldPathSelector) String() string {
	switch s {
	case AlertingConditionSpecTimeSeriesThreshold_FieldPathSelectorCompare:
		return "compare"
	case AlertingConditionSpecTimeSeriesThreshold_FieldPathSelectorValue:
		return "value"
	default:
		panic(fmt.Sprintf("Invalid selector for AlertingCondition_Spec_TimeSeries_Threshold: %d", s))
	}
}

func BuildAlertingConditionSpecTimeSeriesThreshold_FieldPath(fp gotenobject.RawFieldPath) (AlertingConditionSpecTimeSeriesThreshold_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object AlertingCondition_Spec_TimeSeries_Threshold")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "compare":
			return &AlertingConditionSpecTimeSeriesThreshold_FieldTerminalPath{selector: AlertingConditionSpecTimeSeriesThreshold_FieldPathSelectorCompare}, nil
		case "value":
			return &AlertingConditionSpecTimeSeriesThreshold_FieldTerminalPath{selector: AlertingConditionSpecTimeSeriesThreshold_FieldPathSelectorValue}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object AlertingCondition_Spec_TimeSeries_Threshold", fp)
}

func ParseAlertingConditionSpecTimeSeriesThreshold_FieldPath(rawField string) (AlertingConditionSpecTimeSeriesThreshold_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildAlertingConditionSpecTimeSeriesThreshold_FieldPath(fp)
}

func MustParseAlertingConditionSpecTimeSeriesThreshold_FieldPath(rawField string) AlertingConditionSpecTimeSeriesThreshold_FieldPath {
	fp, err := ParseAlertingConditionSpecTimeSeriesThreshold_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type AlertingConditionSpecTimeSeriesThreshold_FieldTerminalPath struct {
	selector AlertingConditionSpecTimeSeriesThreshold_FieldPathSelector
}

var _ AlertingConditionSpecTimeSeriesThreshold_FieldPath = (*AlertingConditionSpecTimeSeriesThreshold_FieldTerminalPath)(nil)

func (fp *AlertingConditionSpecTimeSeriesThreshold_FieldTerminalPath) Selector() AlertingConditionSpecTimeSeriesThreshold_FieldPathSelector {
	return fp.selector
}

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

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

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

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

// GetSingle returns value pointed by specific field of from source AlertingCondition_Spec_TimeSeries_Threshold
func (fp *AlertingConditionSpecTimeSeriesThreshold_FieldTerminalPath) GetSingle(source *AlertingCondition_Spec_TimeSeries_Threshold) (interface{}, bool) {
	switch fp.selector {
	case AlertingConditionSpecTimeSeriesThreshold_FieldPathSelectorCompare:
		return source.GetCompare(), source != nil
	case AlertingConditionSpecTimeSeriesThreshold_FieldPathSelectorValue:
		return source.GetValue(), source != nil
	default:
		panic(fmt.Sprintf("Invalid selector for AlertingCondition_Spec_TimeSeries_Threshold: %d", fp.selector))
	}
}

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

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

func (fp *AlertingConditionSpecTimeSeriesThreshold_FieldTerminalPath) ClearValue(item *AlertingCondition_Spec_TimeSeries_Threshold) {
	if item != nil {
		switch fp.selector {
		case AlertingConditionSpecTimeSeriesThreshold_FieldPathSelectorCompare:
			item.Compare = AlertingCondition_Spec_TimeSeries_Threshold_COMPARE_UNSPECIFIED
		case AlertingConditionSpecTimeSeriesThreshold_FieldPathSelectorValue:
			item.Value = float64(0)
		default:
			panic(fmt.Sprintf("Invalid selector for AlertingCondition_Spec_TimeSeries_Threshold: %d", fp.selector))
		}
	}
}

func (fp *AlertingConditionSpecTimeSeriesThreshold_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*AlertingCondition_Spec_TimeSeries_Threshold))
}

// IsLeaf - whether field path is holds simple value
func (fp *AlertingConditionSpecTimeSeriesThreshold_FieldTerminalPath) IsLeaf() bool {
	return fp.selector == AlertingConditionSpecTimeSeriesThreshold_FieldPathSelectorCompare ||
		fp.selector == AlertingConditionSpecTimeSeriesThreshold_FieldPathSelectorValue
}

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

func (fp *AlertingConditionSpecTimeSeriesThreshold_FieldTerminalPath) WithIValue(value interface{}) AlertingConditionSpecTimeSeriesThreshold_FieldPathValue {
	switch fp.selector {
	case AlertingConditionSpecTimeSeriesThreshold_FieldPathSelectorCompare:
		return &AlertingConditionSpecTimeSeriesThreshold_FieldTerminalPathValue{AlertingConditionSpecTimeSeriesThreshold_FieldTerminalPath: *fp, value: value.(AlertingCondition_Spec_TimeSeries_Threshold_Compare)}
	case AlertingConditionSpecTimeSeriesThreshold_FieldPathSelectorValue:
		return &AlertingConditionSpecTimeSeriesThreshold_FieldTerminalPathValue{AlertingConditionSpecTimeSeriesThreshold_FieldTerminalPath: *fp, value: value.(float64)}
	default:
		panic(fmt.Sprintf("Invalid selector for AlertingCondition_Spec_TimeSeries_Threshold: %d", fp.selector))
	}
}

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

func (fp *AlertingConditionSpecTimeSeriesThreshold_FieldTerminalPath) WithIArrayOfValues(values interface{}) AlertingConditionSpecTimeSeriesThreshold_FieldPathArrayOfValues {
	fpaov := &AlertingConditionSpecTimeSeriesThreshold_FieldTerminalPathArrayOfValues{AlertingConditionSpecTimeSeriesThreshold_FieldTerminalPath: *fp}
	switch fp.selector {
	case AlertingConditionSpecTimeSeriesThreshold_FieldPathSelectorCompare:
		return &AlertingConditionSpecTimeSeriesThreshold_FieldTerminalPathArrayOfValues{AlertingConditionSpecTimeSeriesThreshold_FieldTerminalPath: *fp, values: values.([]AlertingCondition_Spec_TimeSeries_Threshold_Compare)}
	case AlertingConditionSpecTimeSeriesThreshold_FieldPathSelectorValue:
		return &AlertingConditionSpecTimeSeriesThreshold_FieldTerminalPathArrayOfValues{AlertingConditionSpecTimeSeriesThreshold_FieldTerminalPath: *fp, values: values.([]float64)}
	default:
		panic(fmt.Sprintf("Invalid selector for AlertingCondition_Spec_TimeSeries_Threshold: %d", fp.selector))
	}
	return fpaov
}

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

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

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

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

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

func MustParseAlertingConditionSpecTimeSeriesThreshold_FieldPathValue(pathStr, valueStr string) AlertingConditionSpecTimeSeriesThreshold_FieldPathValue {
	fpv, err := ParseAlertingConditionSpecTimeSeriesThreshold_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type AlertingConditionSpecTimeSeriesThreshold_FieldTerminalPathValue struct {
	AlertingConditionSpecTimeSeriesThreshold_FieldTerminalPath
	value interface{}
}

var _ AlertingConditionSpecTimeSeriesThreshold_FieldPathValue = (*AlertingConditionSpecTimeSeriesThreshold_FieldTerminalPathValue)(nil)

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

// SetTo stores value for selected field for object Threshold
func (fpv *AlertingConditionSpecTimeSeriesThreshold_FieldTerminalPathValue) SetTo(target **AlertingCondition_Spec_TimeSeries_Threshold) {
	if *target == nil {
		*target = new(AlertingCondition_Spec_TimeSeries_Threshold)
	}
	switch fpv.selector {
	case AlertingConditionSpecTimeSeriesThreshold_FieldPathSelectorCompare:
		(*target).Compare = fpv.value.(AlertingCondition_Spec_TimeSeries_Threshold_Compare)
	case AlertingConditionSpecTimeSeriesThreshold_FieldPathSelectorValue:
		(*target).Value = fpv.value.(float64)
	default:
		panic(fmt.Sprintf("Invalid selector for AlertingCondition_Spec_TimeSeries_Threshold: %d", fpv.selector))
	}
}

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

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

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

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

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

func MustParseAlertingConditionSpecTimeSeriesThreshold_FieldPathArrayItemValue(pathStr, valueStr string) AlertingConditionSpecTimeSeriesThreshold_FieldPathArrayItemValue {
	fpaiv, err := ParseAlertingConditionSpecTimeSeriesThreshold_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type AlertingConditionSpecTimeSeriesThreshold_FieldTerminalPathArrayItemValue struct {
	AlertingConditionSpecTimeSeriesThreshold_FieldTerminalPath
	value interface{}
}

var _ AlertingConditionSpecTimeSeriesThreshold_FieldPathArrayItemValue = (*AlertingConditionSpecTimeSeriesThreshold_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *AlertingConditionSpecTimeSeriesThreshold_FieldTerminalPathArrayItemValue) GetSingle(source *AlertingCondition_Spec_TimeSeries_Threshold) (interface{}, bool) {
	return nil, false
}

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

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

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

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

func MustParseAlertingConditionSpecTimeSeriesThreshold_FieldPathArrayOfValues(pathStr, valuesStr string) AlertingConditionSpecTimeSeriesThreshold_FieldPathArrayOfValues {
	fpaov, err := ParseAlertingConditionSpecTimeSeriesThreshold_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type AlertingConditionSpecTimeSeriesThreshold_FieldTerminalPathArrayOfValues struct {
	AlertingConditionSpecTimeSeriesThreshold_FieldTerminalPath
	values interface{}
}

var _ AlertingConditionSpecTimeSeriesThreshold_FieldPathArrayOfValues = (*AlertingConditionSpecTimeSeriesThreshold_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *AlertingConditionSpecTimeSeriesThreshold_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case AlertingConditionSpecTimeSeriesThreshold_FieldPathSelectorCompare:
		for _, v := range fpaov.values.([]AlertingCondition_Spec_TimeSeries_Threshold_Compare) {
			values = append(values, v)
		}
	case AlertingConditionSpecTimeSeriesThreshold_FieldPathSelectorValue:
		for _, v := range fpaov.values.([]float64) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *AlertingConditionSpecTimeSeriesThreshold_FieldTerminalPathArrayOfValues) AsCompareArrayOfValues() ([]AlertingCondition_Spec_TimeSeries_Threshold_Compare, bool) {
	res, ok := fpaov.values.([]AlertingCondition_Spec_TimeSeries_Threshold_Compare)
	return res, ok
}
func (fpaov *AlertingConditionSpecTimeSeriesThreshold_FieldTerminalPathArrayOfValues) AsValueArrayOfValues() ([]float64, bool) {
	res, ok := fpaov.values.([]float64)
	return res, ok
}

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

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

type AlertingConditionSpecTimeSeriesCombineThreshold_FieldPathSelector int32

const (
	AlertingConditionSpecTimeSeriesCombineThreshold_FieldPathSelectorPerMetric AlertingConditionSpecTimeSeriesCombineThreshold_FieldPathSelector = 0
	AlertingConditionSpecTimeSeriesCombineThreshold_FieldPathSelectorCombine   AlertingConditionSpecTimeSeriesCombineThreshold_FieldPathSelector = 1
)

func (s AlertingConditionSpecTimeSeriesCombineThreshold_FieldPathSelector) String() string {
	switch s {
	case AlertingConditionSpecTimeSeriesCombineThreshold_FieldPathSelectorPerMetric:
		return "per_metric"
	case AlertingConditionSpecTimeSeriesCombineThreshold_FieldPathSelectorCombine:
		return "combine"
	default:
		panic(fmt.Sprintf("Invalid selector for AlertingCondition_Spec_TimeSeries_CombineThreshold: %d", s))
	}
}

func BuildAlertingConditionSpecTimeSeriesCombineThreshold_FieldPath(fp gotenobject.RawFieldPath) (AlertingConditionSpecTimeSeriesCombineThreshold_FieldPath, error) {
	if len(fp) == 0 {
		return nil, status.Error(codes.InvalidArgument, "empty field path for object AlertingCondition_Spec_TimeSeries_CombineThreshold")
	}
	if len(fp) == 1 {
		switch fp[0] {
		case "per_metric", "perMetric", "per-metric":
			return &AlertingConditionSpecTimeSeriesCombineThreshold_FieldTerminalPath{selector: AlertingConditionSpecTimeSeriesCombineThreshold_FieldPathSelectorPerMetric}, nil
		case "combine":
			return &AlertingConditionSpecTimeSeriesCombineThreshold_FieldTerminalPath{selector: AlertingConditionSpecTimeSeriesCombineThreshold_FieldPathSelectorCombine}, nil
		}
	} else {
		switch fp[0] {
		case "per_metric", "perMetric", "per-metric":
			if len(fp) > 2 {
				return nil, status.Errorf(codes.InvalidArgument, "sub path for maps ('%s') are not supported (object AlertingCondition_Spec_TimeSeries_CombineThreshold)", fp)
			}
			return &AlertingConditionSpecTimeSeriesCombineThreshold_FieldPathMap{selector: AlertingConditionSpecTimeSeriesCombineThreshold_FieldPathSelectorPerMetric, key: fp[1]}, nil
		}
	}
	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object AlertingCondition_Spec_TimeSeries_CombineThreshold", fp)
}

func ParseAlertingConditionSpecTimeSeriesCombineThreshold_FieldPath(rawField string) (AlertingConditionSpecTimeSeriesCombineThreshold_FieldPath, error) {
	fp, err := gotenobject.ParseRawFieldPath(rawField)
	if err != nil {
		return nil, err
	}
	return BuildAlertingConditionSpecTimeSeriesCombineThreshold_FieldPath(fp)
}

func MustParseAlertingConditionSpecTimeSeriesCombineThreshold_FieldPath(rawField string) AlertingConditionSpecTimeSeriesCombineThreshold_FieldPath {
	fp, err := ParseAlertingConditionSpecTimeSeriesCombineThreshold_FieldPath(rawField)
	if err != nil {
		panic(err)
	}
	return fp
}

type AlertingConditionSpecTimeSeriesCombineThreshold_FieldTerminalPath struct {
	selector AlertingConditionSpecTimeSeriesCombineThreshold_FieldPathSelector
}

var _ AlertingConditionSpecTimeSeriesCombineThreshold_FieldPath = (*AlertingConditionSpecTimeSeriesCombineThreshold_FieldTerminalPath)(nil)

func (fp *AlertingConditionSpecTimeSeriesCombineThreshold_FieldTerminalPath) Selector() AlertingConditionSpecTimeSeriesCombineThreshold_FieldPathSelector {
	return fp.selector
}

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

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

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

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

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

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

// GetDefault returns a default value of the field type
func (fp *AlertingConditionSpecTimeSeriesCombineThreshold_FieldTerminalPath) GetDefault() interface{} {
	switch fp.selector {
	case AlertingConditionSpecTimeSeriesCombineThreshold_FieldPathSelectorPerMetric:
		return (map[string]*AlertingCondition_Spec_TimeSeries_Threshold)(nil)
	case AlertingConditionSpecTimeSeriesCombineThreshold_FieldPathSelectorCombine:
		return AlertingCondition_Spec_TimeSeries_CombineThreshold_OR
	default:
		panic(fmt.Sprintf("Invalid selector for AlertingCondition_Spec_TimeSeries_CombineThreshold: %d", fp.selector))
	}
}

func (fp *AlertingConditionSpecTimeSeriesCombineThreshold_FieldTerminalPath) ClearValue(item *AlertingCondition_Spec_TimeSeries_CombineThreshold) {
	if item != nil {
		switch fp.selector {
		case AlertingConditionSpecTimeSeriesCombineThreshold_FieldPathSelectorPerMetric:
			item.PerMetric = nil
		case AlertingConditionSpecTimeSeriesCombineThreshold_FieldPathSelectorCombine:
			item.Combine = AlertingCondition_Spec_TimeSeries_CombineThreshold_OR
		default:
			panic(fmt.Sprintf("Invalid selector for AlertingCondition_Spec_TimeSeries_CombineThreshold: %d", fp.selector))
		}
	}
}

func (fp *AlertingConditionSpecTimeSeriesCombineThreshold_FieldTerminalPath) ClearValueRaw(item proto.Message) {
	fp.ClearValue(item.(*AlertingCondition_Spec_TimeSeries_CombineThreshold))
}

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

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

func (fp *AlertingConditionSpecTimeSeriesCombineThreshold_FieldTerminalPath) WithIValue(value interface{}) AlertingConditionSpecTimeSeriesCombineThreshold_FieldPathValue {
	switch fp.selector {
	case AlertingConditionSpecTimeSeriesCombineThreshold_FieldPathSelectorPerMetric:
		return &AlertingConditionSpecTimeSeriesCombineThreshold_FieldTerminalPathValue{AlertingConditionSpecTimeSeriesCombineThreshold_FieldTerminalPath: *fp, value: value.(map[string]*AlertingCondition_Spec_TimeSeries_Threshold)}
	case AlertingConditionSpecTimeSeriesCombineThreshold_FieldPathSelectorCombine:
		return &AlertingConditionSpecTimeSeriesCombineThreshold_FieldTerminalPathValue{AlertingConditionSpecTimeSeriesCombineThreshold_FieldTerminalPath: *fp, value: value.(AlertingCondition_Spec_TimeSeries_CombineThreshold_CombineOperator)}
	default:
		panic(fmt.Sprintf("Invalid selector for AlertingCondition_Spec_TimeSeries_CombineThreshold: %d", fp.selector))
	}
}

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

func (fp *AlertingConditionSpecTimeSeriesCombineThreshold_FieldTerminalPath) WithIArrayOfValues(values interface{}) AlertingConditionSpecTimeSeriesCombineThreshold_FieldPathArrayOfValues {
	fpaov := &AlertingConditionSpecTimeSeriesCombineThreshold_FieldTerminalPathArrayOfValues{AlertingConditionSpecTimeSeriesCombineThreshold_FieldTerminalPath: *fp}
	switch fp.selector {
	case AlertingConditionSpecTimeSeriesCombineThreshold_FieldPathSelectorPerMetric:
		return &AlertingConditionSpecTimeSeriesCombineThreshold_FieldTerminalPathArrayOfValues{AlertingConditionSpecTimeSeriesCombineThreshold_FieldTerminalPath: *fp, values: values.([]map[string]*AlertingCondition_Spec_TimeSeries_Threshold)}
	case AlertingConditionSpecTimeSeriesCombineThreshold_FieldPathSelectorCombine:
		return &AlertingConditionSpecTimeSeriesCombineThreshold_FieldTerminalPathArrayOfValues{AlertingConditionSpecTimeSeriesCombineThreshold_FieldTerminalPath: *fp, values: values.([]AlertingCondition_Spec_TimeSeries_CombineThreshold_CombineOperator)}
	default:
		panic(fmt.Sprintf("Invalid selector for AlertingCondition_Spec_TimeSeries_CombineThreshold: %d", fp.selector))
	}
	return fpaov
}

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

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

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

// FieldPath for map type with additional Key information
type AlertingConditionSpecTimeSeriesCombineThreshold_FieldPathMap struct {
	key      string
	selector AlertingConditionSpecTimeSeriesCombineThreshold_FieldPathSelector
}

var _ AlertingConditionSpecTimeSeriesCombineThreshold_FieldPath = (*AlertingConditionSpecTimeSeriesCombineThreshold_FieldPathMap)(nil)

func (fpm *AlertingConditionSpecTimeSeriesCombineThreshold_FieldPathMap) Selector() AlertingConditionSpecTimeSeriesCombineThreshold_FieldPathSelector {
	return fpm.selector
}

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

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

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

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

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

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

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

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

func (fpm *AlertingConditionSpecTimeSeriesCombineThreshold_FieldPathMap) ClearValueRaw(item proto.Message) {
	fpm.ClearValue(item.(*AlertingCondition_Spec_TimeSeries_CombineThreshold))
}

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

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

func (fpm *AlertingConditionSpecTimeSeriesCombineThreshold_FieldPathMap) WithIValue(value interface{}) AlertingConditionSpecTimeSeriesCombineThreshold_FieldPathValue {
	switch fpm.selector {
	case AlertingConditionSpecTimeSeriesCombineThreshold_FieldPathSelectorPerMetric:
		return &AlertingConditionSpecTimeSeriesCombineThreshold_FieldPathMapValue{AlertingConditionSpecTimeSeriesCombineThreshold_FieldPathMap: *fpm, value: value.(*AlertingCondition_Spec_TimeSeries_Threshold)}
	default:
		panic(fmt.Sprintf("Invalid selector for AlertingCondition_Spec_TimeSeries_CombineThreshold: %d", fpm.selector))
	}
}

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

func (fpm *AlertingConditionSpecTimeSeriesCombineThreshold_FieldPathMap) WithIArrayOfValues(values interface{}) AlertingConditionSpecTimeSeriesCombineThreshold_FieldPathArrayOfValues {
	switch fpm.selector {
	case AlertingConditionSpecTimeSeriesCombineThreshold_FieldPathSelectorPerMetric:
		return &AlertingConditionSpecTimeSeriesCombineThreshold_FieldPathMapArrayOfValues{AlertingConditionSpecTimeSeriesCombineThreshold_FieldPathMap: *fpm, values: values.([]*AlertingCondition_Spec_TimeSeries_Threshold)}
	default:
		panic(fmt.Sprintf("Invalid selector for AlertingCondition_Spec_TimeSeries_CombineThreshold: %d", fpm.selector))
	}
}

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

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

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

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

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

func MustParseAlertingConditionSpecTimeSeriesCombineThreshold_FieldPathValue(pathStr, valueStr string) AlertingConditionSpecTimeSeriesCombineThreshold_FieldPathValue {
	fpv, err := ParseAlertingConditionSpecTimeSeriesCombineThreshold_FieldPathValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpv
}

type AlertingConditionSpecTimeSeriesCombineThreshold_FieldTerminalPathValue struct {
	AlertingConditionSpecTimeSeriesCombineThreshold_FieldTerminalPath
	value interface{}
}

var _ AlertingConditionSpecTimeSeriesCombineThreshold_FieldPathValue = (*AlertingConditionSpecTimeSeriesCombineThreshold_FieldTerminalPathValue)(nil)

// GetRawValue returns raw value stored under selected path for 'CombineThreshold' as interface{}
func (fpv *AlertingConditionSpecTimeSeriesCombineThreshold_FieldTerminalPathValue) GetRawValue() interface{} {
	return fpv.value
}
func (fpv *AlertingConditionSpecTimeSeriesCombineThreshold_FieldTerminalPathValue) AsPerMetricValue() (map[string]*AlertingCondition_Spec_TimeSeries_Threshold, bool) {
	res, ok := fpv.value.(map[string]*AlertingCondition_Spec_TimeSeries_Threshold)
	return res, ok
}
func (fpv *AlertingConditionSpecTimeSeriesCombineThreshold_FieldTerminalPathValue) AsCombineValue() (AlertingCondition_Spec_TimeSeries_CombineThreshold_CombineOperator, bool) {
	res, ok := fpv.value.(AlertingCondition_Spec_TimeSeries_CombineThreshold_CombineOperator)
	return res, ok
}

// SetTo stores value for selected field for object CombineThreshold
func (fpv *AlertingConditionSpecTimeSeriesCombineThreshold_FieldTerminalPathValue) SetTo(target **AlertingCondition_Spec_TimeSeries_CombineThreshold) {
	if *target == nil {
		*target = new(AlertingCondition_Spec_TimeSeries_CombineThreshold)
	}
	switch fpv.selector {
	case AlertingConditionSpecTimeSeriesCombineThreshold_FieldPathSelectorPerMetric:
		(*target).PerMetric = fpv.value.(map[string]*AlertingCondition_Spec_TimeSeries_Threshold)
	case AlertingConditionSpecTimeSeriesCombineThreshold_FieldPathSelectorCombine:
		(*target).Combine = fpv.value.(AlertingCondition_Spec_TimeSeries_CombineThreshold_CombineOperator)
	default:
		panic(fmt.Sprintf("Invalid selector for AlertingCondition_Spec_TimeSeries_CombineThreshold: %d", fpv.selector))
	}
}

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

// CompareWith compares value in the 'AlertingConditionSpecTimeSeriesCombineThreshold_FieldTerminalPathValue' with the value under path in 'AlertingCondition_Spec_TimeSeries_CombineThreshold'.
func (fpv *AlertingConditionSpecTimeSeriesCombineThreshold_FieldTerminalPathValue) CompareWith(source *AlertingCondition_Spec_TimeSeries_CombineThreshold) (int, bool) {
	switch fpv.selector {
	case AlertingConditionSpecTimeSeriesCombineThreshold_FieldPathSelectorPerMetric:
		return 0, false
	case AlertingConditionSpecTimeSeriesCombineThreshold_FieldPathSelectorCombine:
		leftValue := fpv.value.(AlertingCondition_Spec_TimeSeries_CombineThreshold_CombineOperator)
		rightValue := source.GetCombine()
		if (leftValue) == (rightValue) {
			return 0, true
		} else if (leftValue) < (rightValue) {
			return -1, true
		} else {
			return 1, true
		}
	default:
		panic(fmt.Sprintf("Invalid selector for AlertingCondition_Spec_TimeSeries_CombineThreshold: %d", fpv.selector))
	}
}

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

type AlertingConditionSpecTimeSeriesCombineThreshold_FieldPathMapValue struct {
	AlertingConditionSpecTimeSeriesCombineThreshold_FieldPathMap
	value interface{}
}

var _ AlertingConditionSpecTimeSeriesCombineThreshold_FieldPathValue = (*AlertingConditionSpecTimeSeriesCombineThreshold_FieldPathMapValue)(nil)

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

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

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

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

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

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

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

func MustParseAlertingConditionSpecTimeSeriesCombineThreshold_FieldPathArrayItemValue(pathStr, valueStr string) AlertingConditionSpecTimeSeriesCombineThreshold_FieldPathArrayItemValue {
	fpaiv, err := ParseAlertingConditionSpecTimeSeriesCombineThreshold_FieldPathArrayItemValue(pathStr, valueStr)
	if err != nil {
		panic(err)
	}
	return fpaiv
}

type AlertingConditionSpecTimeSeriesCombineThreshold_FieldTerminalPathArrayItemValue struct {
	AlertingConditionSpecTimeSeriesCombineThreshold_FieldTerminalPath
	value interface{}
}

var _ AlertingConditionSpecTimeSeriesCombineThreshold_FieldPathArrayItemValue = (*AlertingConditionSpecTimeSeriesCombineThreshold_FieldTerminalPathArrayItemValue)(nil)

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

func (fpaiv *AlertingConditionSpecTimeSeriesCombineThreshold_FieldTerminalPathArrayItemValue) GetSingle(source *AlertingCondition_Spec_TimeSeries_CombineThreshold) (interface{}, bool) {
	return nil, false
}

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

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

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

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

func MustParseAlertingConditionSpecTimeSeriesCombineThreshold_FieldPathArrayOfValues(pathStr, valuesStr string) AlertingConditionSpecTimeSeriesCombineThreshold_FieldPathArrayOfValues {
	fpaov, err := ParseAlertingConditionSpecTimeSeriesCombineThreshold_FieldPathArrayOfValues(pathStr, valuesStr)
	if err != nil {
		panic(err)
	}
	return fpaov
}

type AlertingConditionSpecTimeSeriesCombineThreshold_FieldTerminalPathArrayOfValues struct {
	AlertingConditionSpecTimeSeriesCombineThreshold_FieldTerminalPath
	values interface{}
}

var _ AlertingConditionSpecTimeSeriesCombineThreshold_FieldPathArrayOfValues = (*AlertingConditionSpecTimeSeriesCombineThreshold_FieldTerminalPathArrayOfValues)(nil)

func (fpaov *AlertingConditionSpecTimeSeriesCombineThreshold_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
	switch fpaov.selector {
	case AlertingConditionSpecTimeSeriesCombineThreshold_FieldPathSelectorPerMetric:
		for _, v := range fpaov.values.([]map[string]*AlertingCondition_Spec_TimeSeries_Threshold) {
			values = append(values, v)
		}
	case AlertingConditionSpecTimeSeriesCombineThreshold_FieldPathSelectorCombine:
		for _, v := range fpaov.values.([]AlertingCondition_Spec_TimeSeries_CombineThreshold_CombineOperator) {
			values = append(values, v)
		}
	}
	return
}
func (fpaov *AlertingConditionSpecTimeSeriesCombineThreshold_FieldTerminalPathArrayOfValues) AsPerMetricArrayOfValues() ([]map[string]*AlertingCondition_Spec_TimeSeries_Threshold, bool) {
	res, ok := fpaov.values.([]map[string]*AlertingCondition_Spec_TimeSeries_Threshold)
	return res, ok
}
func (fpaov *AlertingConditionSpecTimeSeriesCombineThreshold_FieldTerminalPathArrayOfValues) AsCombineArrayOfValues() ([]AlertingCondition_Spec_TimeSeries_CombineThreshold_CombineOperator, bool) {
	res, ok := fpaov.values.([]AlertingCondition_Spec_TimeSeries_CombineThreshold_CombineOperator)
	return res, ok
}

type AlertingConditionSpecTimeSeriesCombineThreshold_FieldPathMapArrayOfValues struct {
	AlertingConditionSpecTimeSeriesCombineThreshold_FieldPathMap
	values interface{}
}

var _ AlertingConditionSpecTimeSeriesCombineThreshold_FieldPathArrayOfValues = (*AlertingConditionSpecTimeSeriesCombineThreshold_FieldPathMapArrayOfValues)(nil)

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